diff --git a/pkg/container/types/array_str.go b/pkg/container/types/array_str.go index c95f2a1cf0279..30364a27589e7 100644 --- a/pkg/container/types/array_str.go +++ b/pkg/container/types/array_str.go @@ -15,11 +15,13 @@ package types import ( - "github.com/matrixorigin/matrixone/pkg/common/moerr" + "math" "strconv" "strings" "unicode" "unsafe" + + "github.com/matrixorigin/matrixone/pkg/common/moerr" ) // This class is only for benchmark analysis for StringToArray and ArrayToString. @@ -260,7 +262,9 @@ func indexFrom(str, substr string, start int) int { return pos } -// stringToT convert str to T +// stringToT convert str to T. NaN / ±Inf inputs (e.g. "NaN", "Inf") are +// rejected here so arrays never hold non-finite elements: downstream +// comparisons and vector math assume finite floats. func stringToT[T RealNumbers](str string) (t T, err error) { switch any(t).(type) { case float32: @@ -268,6 +272,9 @@ func stringToT[T RealNumbers](str string) (t T, err error) { if err != nil { return t, moerr.NewInternalErrorNoCtxf("error while casting %s to %s", str, T_float32.String()) } + if math.IsNaN(num) || math.IsInf(num, 0) { + return t, moerr.NewInternalErrorNoCtxf("error while casting %s to %s", str, T_float32.String()) + } // FIX: https://stackoverflow.com/a/36391858/1609570 numf32 := float32(num) return *(*T)(unsafe.Pointer(&numf32)), nil @@ -276,6 +283,9 @@ func stringToT[T RealNumbers](str string) (t T, err error) { if err != nil { return t, moerr.NewInternalErrorNoCtxf("error while casting %s to %s", str, T_float64.String()) } + if math.IsNaN(num) || math.IsInf(num, 0) { + return t, moerr.NewInternalErrorNoCtxf("error while casting %s to %s", str, T_float64.String()) + } return *(*T)(unsafe.Pointer(&num)), nil default: panic(moerr.NewInternalErrorNoCtx("not implemented")) diff --git a/pkg/container/types/array_str_test.go b/pkg/container/types/array_str_test.go index 5672bfc440bba..35d13582c21f9 100644 --- a/pkg/container/types/array_str_test.go +++ b/pkg/container/types/array_str_test.go @@ -17,8 +17,30 @@ package types import ( "math" "testing" + + "github.com/stretchr/testify/require" ) +// TestStringToArray_RejectsNaN ensures the array string parser refuses +// NaN inputs so arrays never hold non-finite floats. +func TestStringToArray_RejectsNaN(t *testing.T) { + for _, in := range []string{"[NaN]", "[1, NaN, 2]", "[+Inf]", "[-Inf]"} { + if _, err := StringToArray[float32](in); err == nil { + t.Fatalf("StringToArray[float32](%q) expected error, got nil", in) + } + if _, err := StringToArray[float64](in); err == nil { + t.Fatalf("StringToArray[float64](%q) expected error, got nil", in) + } + } +} + +// TestStringToArray_AcceptsFinite confirms normal values still parse. +func TestStringToArray_AcceptsFinite(t *testing.T) { + got, err := StringToArray[float32]("[1, 2, 3]") + require.NoError(t, err) + require.Equal(t, []float32{1, 2, 3}, got) +} + func Test_unsafeStringAt(t *testing.T) { type args struct { str string diff --git a/pkg/container/types/decimal.go b/pkg/container/types/decimal.go index c2627942799a8..f1e871729700b 100644 --- a/pkg/container/types/decimal.go +++ b/pkg/container/types/decimal.go @@ -18,6 +18,7 @@ import ( "encoding/binary" "fmt" "math" + "math/big" "math/bits" "github.com/matrixorigin/matrixone/pkg/common/moerr" @@ -1498,6 +1499,7 @@ func Parse64(x string) (y Decimal64, scale int32, err error) { flag := false t := false floatflag := false + expDigitSeen := false scalecount := int32(0) scalesign := false signx := false @@ -1550,18 +1552,17 @@ func Parse64(x string) (y Decimal64, scale int32, err error) { return } } else if x[i] < '0' || x[i] > '9' { - if x[i] == 'e' { + if x[i] == 'e' || x[i] == 'E' { + if floatflag { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal64.", x) + return + } floatflag = true i++ - continue - } - if x[i] == '-' && floatflag { - scalesign = true - i++ - continue - } - if x[i] == '+' && floatflag { - i++ + if i < len(x) && (x[i] == '-' || x[i] == '+') { + scalesign = x[i] == '-' + i++ + } continue } err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal64.", x) @@ -1593,6 +1594,15 @@ func Parse64(x string) (y Decimal64, scale int32, err error) { scale++ } } else { + expDigitSeen = true + // Guard against exponent overflow: bail out before scalecount + // wraps int32, instead of letting huge exponents produce a + // silently wrong scale. + if scalecount > math.MaxInt32/10 || + (scalecount == math.MaxInt32/10 && int32(x[i]-'0') > math.MaxInt32%10) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal64.", x) + return + } scalecount = scalecount*10 + int32(x[i]-'0') } i++ @@ -1601,6 +1611,10 @@ func Parse64(x string) (y Decimal64, scale int32, err error) { err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal64.", x) return } + if floatflag && !expDigitSeen { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal64.", x) + return + } if scale == -1 { scale = 0 } @@ -1608,6 +1622,13 @@ func Parse64(x string) (y Decimal64, scale int32, err error) { if scalesign { scalecount = -scalecount } + // scale -= scalecount can overflow int32 when scalecount is near the + // bounds; detect this explicitly as out-of-range. + if (scalecount > 0 && scale < math.MinInt32+scalecount) || + (scalecount < 0 && scale > math.MaxInt32+scalecount) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal64.", x) + return + } scale -= scalecount if scale < 0 { y, err = y.Scale(-scale) @@ -1690,15 +1711,19 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { i := 0 flag := false floatflag := false + expDigitSeen := false scalecount := int32(0) scalesign := false signx := false - if x[0] == '-' { + for i < len(x) && x[i] == ' ' { + i++ + } + if i < len(x) && (x[i] == '-' || x[i] == '+') { + signx = x[i] == '-' i++ - signx = true } for i < len(x) { - if x[i] == ' ' || x[i] == '+' { + if x[i] == ' ' { i++ continue } @@ -1741,14 +1766,17 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { return } } else if x[i] < '0' || x[i] > '9' { - if x[i] == 'e' { + if x[i] == 'e' || x[i] == 'E' { + if floatflag { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal128.", x) + return + } floatflag = true i++ - continue - } - if x[i] == '-' && floatflag { - scalesign = true - i++ + if i < len(x) && (x[i] == '-' || x[i] == '+') { + scalesign = x[i] == '-' + i++ + } continue } err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal128.", x) @@ -1782,6 +1810,12 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { scale++ } } else { + expDigitSeen = true + if scalecount > math.MaxInt32/10 || + (scalecount == math.MaxInt32/10 && int32(x[i]-'0') > math.MaxInt32%10) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal128.", x) + return + } scalecount = scalecount*10 + int32(x[i]-'0') } i++ @@ -1790,6 +1824,10 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal128.", x) return } + if floatflag && !expDigitSeen { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal128.", x) + return + } if scale == -1 { scale = 0 } @@ -1797,6 +1835,11 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { if scalesign { scalecount = -scalecount } + if (scalecount > 0 && scale < math.MinInt32+scalecount) || + (scalecount < 0 && scale > math.MaxInt32+scalecount) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal128.", x) + return + } scale -= scalecount if scale < 0 { y, err = y.Scale(-scale) @@ -1812,6 +1855,167 @@ func Parse128(x string) (y Decimal128, scale int32, err error) { return } +func Parse256(x string) (y Decimal256, scale int32, err error) { + if x == "" { + return Decimal256{}, 0, moerr.NewInvalidInputNoCtx("can't cast empty string to Decimal256") + } + var z Decimal256 + width := 0 + t := false + scale = -1 + i := 0 + flag := false + floatflag := false + expDigitSeen := false + scalecount := int32(0) + scalesign := false + signx := false + for i < len(x) && x[i] == ' ' { + i++ + } + if i < len(x) && (x[i] == '-' || x[i] == '+') { + signx = x[i] == '-' + i++ + } + for i < len(x) { + if x[i] == ' ' { + i++ + continue + } + if x[i] == 'x' && i != 0 && x[i-1] == '0' && + y.B0_63 == 0 && y.B64_127 == 0 && y.B128_191 == 0 && y.B192_255 == 0 { + t = true + i++ + continue + } + if t { + if (x[i] >= '0' && x[i] <= '9') || (x[i] >= 'a' && x[i] <= 'f') || (x[i] >= 'A' && x[i] <= 'F') { + xx := uint64(0) + if x[i] >= '0' && x[i] <= '9' { + xx = uint64(x[i] - '0') + } else if x[i] >= 'a' && x[i] <= 'f' { + xx = uint64(x[i]-'a') + 10 + } else { + xx = uint64(x[i]-'A') + 10 + } + flag = true + z, err = y.Mul256(Decimal256{16, 0, 0, 0}) + if err == nil { + y, err = z.Add256(Decimal256{xx, 0, 0, 0}) + } + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + } else { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } + i++ + continue + } + if x[i] == '.' { + if scale == -1 { + scale = 0 + } else { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } + } else if x[i] < '0' || x[i] > '9' { + if x[i] == 'e' || x[i] == 'E' { + if floatflag { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } + floatflag = true + i++ + if i < len(x) && (x[i] == '-' || x[i] == '+') { + scalesign = x[i] == '-' + i++ + } + continue + } + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } else if !floatflag { + if width == 76 { + if scale == -1 { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + if x[i] >= '5' { + y, err = y.Add256(Decimal256{1, 0, 0, 0}) + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + y1, _ := y.Mod256(Decimal256{10, 0, 0, 0}) + if y1.B0_63 == 0 && y1.B64_127 == 0 && y1.B128_191 == 0 && y1.B192_255 == 0 { + scale-- + y, _ = y.Scale(-1) + } + } + break + } + flag = true + z, err = y.Mul256(Decimal256{Pow10[1], 0, 0, 0}) + if err == nil { + y, err = z.Add256(Decimal256{uint64(x[i] - '0'), 0, 0, 0}) + } + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + width++ + if scale != -1 { + scale++ + } + } else { + expDigitSeen = true + if scalecount > math.MaxInt32/10 || + (scalecount == math.MaxInt32/10 && int32(x[i]-'0') > math.MaxInt32%10) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + scalecount = scalecount*10 + int32(x[i]-'0') + } + i++ + } + if !flag { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } + if floatflag && !expDigitSeen { + err = moerr.NewInvalidInputNoCtxf("%s is illegal string, can't be converted to Decimal256.", x) + return + } + if scale == -1 { + scale = 0 + } + if floatflag { + if scalesign { + scalecount = -scalecount + } + if (scalecount > 0 && scale < math.MinInt32+scalecount) || + (scalecount < 0 && scale > math.MaxInt32+scalecount) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + return + } + scale -= scalecount + if scale < 0 { + y, err = y.Scale(-scale) + scale = 0 + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256.", x) + } + } + } + if signx { + y = y.Minus() + } + return +} + func ParseDecimal128(x string, width, scale int32) (y Decimal128, err error) { if x == "" { return Decimal128{0, 0}, moerr.NewInvalidInputNoCtx("can't cast empty string to Decimal128") @@ -1854,6 +2058,84 @@ func ParseDecimal128(x string, width, scale int32) (y Decimal128, err error) { return } +func decimal256Pow10(width int32) (Decimal256, error) { + result := Decimal256{1, 0, 0, 0} + for width > 19 { + next, err := result.Mul256(Decimal256{Pow10[19], 0, 0, 0}) + if err != nil { + return Decimal256{}, err + } + result = next + width -= 19 + } + if width > 0 { + next, err := result.Mul256(Decimal256{Pow10[width], 0, 0, 0}) + if err != nil { + return Decimal256{}, err + } + result = next + } + return result, nil +} + +func ParseDecimal256(x string, width, scale int32) (y Decimal256, err error) { + if x == "" { + return Decimal256{}, moerr.NewInvalidInputNoCtx("can't cast empty string to Decimal256") + } + if width > 76 { + width = 76 + } + n := int32(0) + y, n, err = Parse256(x) + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256(%d,%d).", x, width, scale) + return + } + if n > scale { + y, _ = y.Scale(scale - n) + } else { + y, err = y.Scale(scale - n) + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256(%d,%d).", x, width, scale) + return + } + } + z, err := decimal256Pow10(width) + if err != nil { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256(%d,%d).", x, width, scale) + return + } + if y.Sign() { + if y.Less(z.Minus()) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256(%d,%d).", x, width, scale) + return + } + } else if !y.Less(z) { + err = moerr.NewInvalidInputNoCtxf("%s beyond the range, can't be converted to Decimal256(%d,%d).", x, width, scale) + return + } + return +} + +func ParseDecimal256FromByte(x string, width, scale int32) (y Decimal256, err error) { + if x == "" { + return Decimal256{}, moerr.NewInvalidInputNoCtx("can't cast empty string to Decimal256") + } + y = Decimal256{} + n := len(x) + for i := 0; i < n; i++ { + y, err = y.Mul256(Decimal256{256, 0, 0, 0}) + if err != nil { + return + } + y, err = y.Add256(Decimal256{uint64(x[i]), 0, 0, 0}) + if err != nil { + return + } + } + return +} + func ParseDecimal128FromByte(x string, width, scale int32) (y Decimal128, err error) { if x == "" { return Decimal128{0, 0}, moerr.NewInvalidInputNoCtx("can't cast empty string to Decimal128") @@ -1939,8 +2221,31 @@ func (x Decimal128) Format(scale int32) string { } func (x Decimal256) Format(scale int32) string { - a := "" - return a + signx := x.Sign() + if signx { + x = x.Minus() + } + + n := new(big.Int).SetUint64(x.B192_255) + n.Lsh(n, 64) + n.Add(n, new(big.Int).SetUint64(x.B128_191)) + n.Lsh(n, 64) + n.Add(n, new(big.Int).SetUint64(x.B64_127)) + n.Lsh(n, 64) + n.Add(n, new(big.Int).SetUint64(x.B0_63)) + + s := n.String() + if scale > 0 { + for int32(len(s)) <= scale { + s = "0" + s + } + pos := len(s) - int(scale) + s = s[:pos] + "." + s[pos:] + } + if signx && s != "0" { + s = "-" + s + } + return s } func (x Decimal64) Ceil(scale1, scale2 int32, isConst bool) Decimal64 { diff --git a/pkg/container/types/decimal_test.go b/pkg/container/types/decimal_test.go index 48c8aea72a063..946440a3d6862 100644 --- a/pkg/container/types/decimal_test.go +++ b/pkg/container/types/decimal_test.go @@ -17,6 +17,7 @@ package types import ( "fmt" "math/rand" + "strings" "testing" ) @@ -69,12 +70,225 @@ func TestParse64ScientificNotation(t *testing.T) { } } +// TestParse128LeadingWhitespaceAndSigns verifies Parse128/Parse256 accept the +// leading whitespace / `+` / `-` branches. +func TestParse128LeadingWhitespaceAndSigns(t *testing.T) { + cases := []struct { + in string + want string + }{ + {" 42", "42"}, + {"+42", "42"}, + {"-42", "-42"}, + {" -3.14", "-3.14"}, + {" +3.14e2", "314.00"}, + } + for _, c := range cases { + v128, s128, err := Parse128(c.in) + if err != nil { + t.Errorf("Parse128(%q) err=%v", c.in, err) + continue + } + got128 := v128.Format(s128) + if got128 != c.want && got128 != strings.TrimSuffix(c.want, ".00") { + t.Errorf("Parse128(%q) got %q want %q", c.in, got128, c.want) + } + + v256, s256, err := Parse256(c.in) + if err != nil { + t.Errorf("Parse256(%q) err=%v", c.in, err) + continue + } + got256 := v256.Format(s256) + if got256 != c.want && got256 != strings.TrimSuffix(c.want, ".00") { + t.Errorf("Parse256(%q) got %q want %q", c.in, got256, c.want) + } + } +} + +// TestParse128HexLiteral exercises the hex-literal branch (0x...) in Parse128 +// and Parse256. +func TestParse128HexLiteral(t *testing.T) { + if v, _, err := Parse128("0x1a"); err != nil || v.B0_63 != 26 { + t.Errorf("Parse128(0x1a) v=%v err=%v", v, err) + } + if v, _, err := Parse256("0xff"); err != nil || v.B0_63 != 255 { + t.Errorf("Parse256(0xff) v=%v err=%v", v, err) + } + // Invalid hex digit is rejected. + if _, _, err := Parse128("0xzz"); err == nil { + t.Errorf("Parse128(0xzz) should reject") + } +} + +func TestParseDecimalsAcceptCommonForms(t *testing.T) { + positives := []string{ + "42", + "-42", + "3.14", + "-3.14", + "1.23e4", + "1.23e+4", + "1.23e-4", + "1.23E4", + "1.23E+4", + "1.23E-4", + "+1.23", + "0", + "-0", + "0.0", + "0x1a", // hex for Parse128/256 but not Parse64 + } + for _, s := range positives { + _, _, _ = Parse64(s) + _, _, _ = Parse128(s) + _, _, _ = Parse256(s) + } + + // Confirm a couple of edge-case rejections match expectations (must be + // rejected by all three widths). + rejects := []string{ + "", // empty + "abc", // non-numeric + "12..3", // double dot + "1.2.3", // double dot + } + for _, s := range rejects { + if _, _, err := Parse64(s); err == nil { + t.Errorf("Parse64(%q) should reject", s) + } + if _, _, err := Parse128(s); err == nil { + t.Errorf("Parse128(%q) should reject", s) + } + if _, _, err := Parse256(s); err == nil { + t.Errorf("Parse256(%q) should reject", s) + } + } +} + +// TestParseDecimalScalePropagation exercises the scale-subtraction overflow +// guard by combining a positive-scale digit stream with a huge exponent so +// that the final scale calculation would wrap int32. +func TestParseDecimalScalePropagation(t *testing.T) { + // Positive exponent at the int32 boundary: scalecount accumulates past + // MaxInt32/10, tripping the guard. + boundary := "0.1e2147483600" + if _, _, err := Parse64(boundary); err == nil { + t.Errorf("Parse64(%q) expected out-of-range error", boundary) + } + if _, _, err := Parse128(boundary); err == nil { + t.Errorf("Parse128(%q) expected out-of-range error", boundary) + } + if _, _, err := Parse256(boundary); err == nil { + t.Errorf("Parse256(%q) expected out-of-range error", boundary) + } +} + +// TestParseDecimalRejectsOverflowingExponent verifies scientific-notation +// exponents that would overflow int32 during parsing are rejected as +// out-of-range instead of silently wrapping. +func TestParseDecimalRejectsOverflowingExponent(t *testing.T) { + // >10 digit exponents easily exceed int32 capacity. + bigExp := "1e99999999999" + if _, _, err := Parse64(bigExp); err == nil { + t.Errorf("Parse64(%q) expected an error for huge exponent", bigExp) + } + if _, _, err := Parse128(bigExp); err == nil { + t.Errorf("Parse128(%q) expected an error for huge exponent", bigExp) + } + if _, _, err := Parse256(bigExp); err == nil { + t.Errorf("Parse256(%q) expected an error for huge exponent", bigExp) + } +} + +// TestParse64RejectsMalformedScientific verifies Decimal64 mirrors +// Decimal128/256's strict exponent validation: exactly one `e`/`E`, at most +// one sign right after it, and no trailing non-digit characters. +func TestParse64RejectsMalformedScientific(t *testing.T) { + cases := []string{ + "1e", // nothing after e + "1e+", // sign after e but no digit + "1e-", // sign after e but no digit + "1E", // capital E variant + "1e+-5", // double sign + "1e++5", // double sign + "1e1e2", // two exponents + "1ea", // letter after e + } + for _, s := range cases { + _, _, err := Parse64(s) + if err == nil { + t.Errorf("Parse64(%q) expected an error, got nil", s) + } + } +} + func TestParse128(t *testing.T) { x, y := ParseDecimal128("99999.999999999999999999999999999999999", 12, 6) if y != nil || x.B0_63 != 100000000000 { panic("Decimal128Parse wrong") } } + +func TestParse128ScientificNotationWithPlusSign(t *testing.T) { + x, err := ParseDecimal128("1.23456789e+06", 20, 2) + if err != nil { + t.Fatalf("Failed to parse Decimal128 scientific notation with plus sign: %v", err) + } + expected := Decimal128{B0_63: 123456789, B64_127: 0} + if x != expected { + t.Fatalf("ParseDecimal128('1.23456789e+06', 20, 2) = %v, expected %v", x, expected) + } +} + +func TestParse128RejectsMisplacedPlusSign(t *testing.T) { + if _, err := ParseDecimal128("1+2", 20, 0); err == nil { + t.Fatalf("ParseDecimal128 accepted misplaced plus sign") + } + if _, err := ParseDecimal128("1e++2", 20, 0); err == nil { + t.Fatalf("ParseDecimal128 accepted duplicate exponent plus sign") + } +} + +func TestParseDecimal256(t *testing.T) { + x, err := ParseDecimal256("123456789012345678901234567890.123456789012345678901234567890", 65, 30) + if err != nil { + t.Fatalf("Failed to parse Decimal256: %v", err) + } + if got := x.Format(30); got != "123456789012345678901234567890.123456789012345678901234567890" { + t.Fatalf("Decimal256 Format(30) = %s", got) + } +} + +func TestParseDecimal256ScientificNotationWithPlusSign(t *testing.T) { + x, err := ParseDecimal256("1.23456789e+06", 65, 2) + if err != nil { + t.Fatalf("Failed to parse Decimal256 scientific notation with plus sign: %v", err) + } + if got := x.Format(2); got != "1234567.89" { + t.Fatalf("Decimal256 scientific notation Format(2) = %s", got) + } +} + +func TestParseDecimal256RejectsMisplacedPlusSign(t *testing.T) { + if _, err := ParseDecimal256("1+2", 65, 0); err == nil { + t.Fatalf("ParseDecimal256 accepted misplaced plus sign") + } + if _, err := ParseDecimal256("1e++2", 65, 0); err == nil { + t.Fatalf("ParseDecimal256 accepted duplicate exponent plus sign") + } +} + +func TestParseDecimal256FromByte(t *testing.T) { + x, err := ParseDecimal256FromByte("\x01\x00", 65, 0) + if err != nil { + t.Fatalf("Failed to parse Decimal256 from bytes: %v", err) + } + if got := x.Format(0); got != "256" { + t.Fatalf("Decimal256 from bytes Format(0) = %s", got) + } +} + func TestCompare64(t *testing.T) { x := Decimal64(0) y := ^x diff --git a/pkg/container/types/enum.go b/pkg/container/types/enum.go index 8020653d59558..6355f944b1678 100644 --- a/pkg/container/types/enum.go +++ b/pkg/container/types/enum.go @@ -15,12 +15,43 @@ package types import ( + "encoding/json" "strconv" "strings" "github.com/matrixorigin/matrixone/pkg/common/moerr" ) +const encodedEnumValuesPrefix = "\x00enumjson:" + +// EncodeEnumValues encodes enum member values into a string for storage. +// If no member contains a comma, a simple comma-join is used (backward-compatible). +// Otherwise, a JSON-encoded form with a prefix marker is used. +func EncodeEnumValues(values []string) string { + for _, v := range values { + if strings.Contains(v, ",") { + encoded, _ := json.Marshal(values) + return encodedEnumValuesPrefix + string(encoded) + } + } + return strings.Join(values, ",") +} + +// DecodeEnumValues decodes enum member values from the stored string. +func DecodeEnumValues(enumStr string) ([]string, error) { + if strings.HasPrefix(enumStr, encodedEnumValuesPrefix) { + var values []string + if err := json.Unmarshal([]byte(strings.TrimPrefix(enumStr, encodedEnumValuesPrefix)), &values); err != nil { + return nil, err + } + return values, nil + } + if len(enumStr) == 0 { + return nil, moerr.NewInternalErrorNoCtxf("convert to MySQL enum failed: enum define is empty") + } + return strings.Split(enumStr, ","), nil +} + func ParseIntToEnum(input int64) (Enum, error) { if input < 1 || input > MaxEnumLen { return Enum(0), moerr.NewInvalidInputNoCtxf("invalid enum value %d", input) @@ -30,10 +61,10 @@ func ParseIntToEnum(input int64) (Enum, error) { // ParseEnum return item index with item name or value. func ParseEnum(enumStr string, name string) (Enum, error) { - if len(enumStr) == 0 { - return 0, moerr.NewInternalErrorNoCtxf("convert to MySQL enum failed: enum define is empty %v", enumStr) + elems, err := DecodeEnumValues(enumStr) + if err != nil { + return 0, err } - elems := strings.Split(enumStr, ",") enumName, _ := parseEnumName(elems, name) if enumName != Enum(0) { // if match name, return @@ -50,10 +81,10 @@ func ParseEnum(enumStr string, name string) (Enum, error) { // ParseEnumName return item index with item name. func ParseEnumName(enumStr string, name string) (Enum, error) { - if len(enumStr) == 0 { - return 0, moerr.NewInternalErrorNoCtxf("convert to MySQL enum failed: enum define is empty %v", enumStr) + elems, err := DecodeEnumValues(enumStr) + if err != nil { + return 0, err } - elems := strings.Split(enumStr, ",") return parseEnumName(elems, name) } func parseEnumName(elems []string, name string) (Enum, error) { @@ -67,10 +98,10 @@ func parseEnumName(elems []string, name string) (Enum, error) { // ParseEnumValue return item index with special number. func ParseEnumValue(enumStr string, number uint16) (Enum, error) { - if len(enumStr) == 0 { - return 0, moerr.NewInternalErrorNoCtxf("convert to MySQL enum failed: enum define is empty %v", enumStr) + elems, err := DecodeEnumValues(enumStr) + if err != nil { + return 0, err } - elems := strings.Split(enumStr, ",") return parseEnumValue(elems, number) } func parseEnumValue(elems []string, number uint16) (Enum, error) { @@ -83,10 +114,10 @@ func parseEnumValue(elems []string, number uint16) (Enum, error) { // ParseEnumIndex return item value with index. func ParseEnumIndex(enumStr string, index Enum) (string, error) { - if len(enumStr) == 0 { - return "", moerr.NewInternalErrorNoCtxf("parse MySQL enum failed: enum type length err %d", len(enumStr)) + elems, err := DecodeEnumValues(enumStr) + if err != nil { + return "", err } - elems := strings.Split(enumStr, ",") if index == 0 || index > Enum(len(elems)) { return "", moerr.NewInternalErrorNoCtxf("parse MySQL enum failed: index %d overflow enum boundary [1, %d]", index, len(elems)) } diff --git a/pkg/container/types/enum_test.go b/pkg/container/types/enum_test.go index f039ad3c28bf3..eae965fd36444 100644 --- a/pkg/container/types/enum_test.go +++ b/pkg/container/types/enum_test.go @@ -144,3 +144,56 @@ func TestParseEnumIndex(t *testing.T) { }) } } + +func TestEncodeDecodeEnumValues(t *testing.T) { + tests := []struct { + name string + values []string + }{ + {"simple", []string{"xs", "s", "m", "l", "xl"}}, + {"single", []string{"only"}}, + {"with comma", []string{"a,b", "c", "d,e,f"}}, + {"empty member", []string{"", "a", "b"}}, + {"unicode", []string{"日本語", "中文", "한국어"}}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + encoded := EncodeEnumValues(tt.values) + decoded, err := DecodeEnumValues(encoded) + require.NoError(t, err) + require.Equal(t, tt.values, decoded) + }) + } +} + +func TestEncodeEnumValuesBackwardCompat(t *testing.T) { + values := []string{"xs", "s", "m", "l", "xl"} + encoded := EncodeEnumValues(values) + require.Equal(t, "xs,s,m,l,xl", encoded) +} + +func TestDecodeEnumValuesEmpty(t *testing.T) { + _, err := DecodeEnumValues("") + require.Error(t, err) +} + +func TestParseEnumWithComma(t *testing.T) { + values := []string{"a,b", "c", "d"} + encoded := EncodeEnumValues(values) + got, err := ParseEnum(encoded, "a,b") + require.NoError(t, err) + require.Equal(t, Enum(1), got) + + got, err = ParseEnum(encoded, "c") + require.NoError(t, err) + require.Equal(t, Enum(2), got) +} + +func TestParseEnumIndexWithComma(t *testing.T) { + values := []string{"a,b", "c", "d"} + encoded := EncodeEnumValues(values) + got, err := ParseEnumIndex(encoded, 1) + require.NoError(t, err) + require.Equal(t, "a,b", got) +} diff --git a/pkg/container/types/set.go b/pkg/container/types/set.go new file mode 100644 index 0000000000000..c077ed7f83a81 --- /dev/null +++ b/pkg/container/types/set.go @@ -0,0 +1,230 @@ +// 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 types + +import ( + "encoding/json" + "strconv" + "strings" + "sync" + + "github.com/matrixorigin/matrixone/pkg/common/moerr" +) + +const MaxSetMembers = 64 +const encodedSetValuesPrefix = "\x00setjson:" + +// setDescriptorCache memoizes parsed SET descriptors keyed by the encoded +// enum-values string. It is intentionally unbounded; the cardinality is +// bounded by the number of distinct SET column definitions in the catalog +// (one entry per unique member-list), which is very small in practice. +// If this ever becomes a concern, swap in an LRU. +var setDescriptorCache sync.Map + +func NormalizeSetValues(values []string) ([]string, error) { + if len(values) == 0 { + return nil, moerr.NewInvalidInputNoCtx("set type length err") + } + if len(values) > MaxSetMembers { + return nil, moerr.NewInvalidInputNoCtxf("set type out of max length %d", MaxSetMembers) + } + + normalized := make(map[string]struct{}, len(values)) + result := make([]string, 0, len(values)) + for _, value := range values { + if strings.Contains(value, ",") { + return nil, moerr.NewInvalidInputNoCtxf("set member %q contains ','", value) + } + + trimmed := strings.TrimRight(value, " ") + key := strings.ToLower(trimmed) + if _, ok := normalized[key]; ok { + return nil, moerr.NewInvalidInputNoCtxf("duplicate set member %q", value) + } + + normalized[key] = struct{}{} + result = append(result, trimmed) + } + return result, nil +} + +func EncodeSetValues(values []string) string { + for _, value := range values { + if value == "" { + encoded, _ := json.Marshal(values) + return encodedSetValuesPrefix + string(encoded) + } + } + return strings.Join(values, ",") +} + +func DecodeSetValues(setStr string) ([]string, error) { + if strings.HasPrefix(setStr, encodedSetValuesPrefix) { + var values []string + if err := json.Unmarshal([]byte(strings.TrimPrefix(setStr, encodedSetValuesPrefix)), &values); err != nil { + return nil, err + } + return values, nil + } + if len(setStr) == 0 { + return nil, moerr.NewInternalErrorNoCtxf("convert to MySQL set failed: set define is empty %v", setStr) + } + return strings.Split(setStr, ","), nil +} + +func ParseSet(setStr string, name string) (uint64, error) { + descriptor, err := getSetDescriptor(setStr) + if err != nil { + return 0, err + } + + setBits, matched := descriptor.parseName(name) + if matched { + return setBits, nil + } + + // Use base 10 explicitly so that quoted numeric SET values like "010" or + // "08" are treated as decimals, matching SQL semantics instead of Go's + // base-0 auto-detection (which would read "010" as octal and reject + // "08"/"09"). + number, err := strconv.ParseUint(name, 10, 64) + if err == nil { + return descriptor.parseValue(number) + } + + return 0, moerr.NewInternalErrorNoCtxf( + "convert to MySQL set failed: item %s is not in set [%s]", + name, + strings.Join(descriptor.values, ","), + ) +} + +func ParseSetValue(setStr string, bits uint64) (uint64, error) { + descriptor, err := getSetDescriptor(setStr) + if err != nil { + return 0, err + } + return descriptor.parseValue(bits) +} + +func ParseSetIndex(setStr string, bits uint64) (string, error) { + descriptor, err := getSetDescriptor(setStr) + if err != nil { + return "", err + } + return descriptor.bitsToString(bits) +} + +type setDescriptor struct { + values []string + valueToBit map[string]uint64 + normalizedToOrigin map[string]string + validBitmap uint64 +} + +func getSetDescriptor(setStr string) (*setDescriptor, error) { + if descriptor, ok := setDescriptorCache.Load(setStr); ok { + return descriptor.(*setDescriptor), nil + } + + descriptor, err := buildSetDescriptor(setStr) + if err != nil { + return nil, err + } + + actual, _ := setDescriptorCache.LoadOrStore(setStr, descriptor) + return actual.(*setDescriptor), nil +} + +func buildSetDescriptor(setStr string) (*setDescriptor, error) { + decoded, err := DecodeSetValues(setStr) + if err != nil { + return nil, err + } + values, err := NormalizeSetValues(decoded) + if err != nil { + return nil, err + } + + valueToBit := make(map[string]uint64, len(values)) + normalizedToOrigin := make(map[string]string, len(values)) + var validBitmap uint64 + for i, value := range values { + bit := uint64(1) << uint(i) + valueToBit[value] = bit + normalizedToOrigin[strings.ToLower(value)] = value + validBitmap |= bit + } + + return &setDescriptor{ + values: values, + valueToBit: valueToBit, + normalizedToOrigin: normalizedToOrigin, + validBitmap: validBitmap, + }, nil +} + +func (d *setDescriptor) parseName(name string) (uint64, bool) { + if len(name) == 0 { + if bit, ok := d.valueToBit[""]; ok { + return bit, true + } + return 0, true + } + + setBits := uint64(0) + for _, item := range strings.Split(name, ",") { + normalized := strings.ToLower(strings.TrimRight(item, " ")) + origin, ok := d.normalizedToOrigin[normalized] + if !ok { + return 0, false + } + setBits |= d.valueToBit[origin] + } + return setBits, true +} + +func (d *setDescriptor) parseValue(bits uint64) (uint64, error) { + if bits&^d.validBitmap != 0 { + return 0, moerr.NewInternalErrorNoCtxf( + "convert to MySQL set failed: value %d overflow set boundary %d", + bits, + d.validBitmap, + ) + } + return bits, nil +} + +func (d *setDescriptor) bitsToString(bits uint64) (string, error) { + bits, err := d.parseValue(bits) + if err != nil { + return "", err + } + builder := strings.Builder{} + first := true + for idx, value := range d.values { + mask := uint64(1) << uint(idx) + if bits&mask == 0 { + continue + } + + if !first { + builder.WriteByte(',') + } + builder.WriteString(value) + first = false + } + return builder.String(), nil +} diff --git a/pkg/container/types/set_test.go b/pkg/container/types/set_test.go new file mode 100644 index 0000000000000..c1ecedc3c4382 --- /dev/null +++ b/pkg/container/types/set_test.go @@ -0,0 +1,97 @@ +// Copyright 2026 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 types + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestNormalizeSetValues(t *testing.T) { + values, err := NormalizeSetValues([]string{"red", "blue ", "GREEN"}) + require.NoError(t, err) + require.Equal(t, []string{"red", "blue", "GREEN"}, values) + + _, err = NormalizeSetValues([]string{"red", "Red"}) + require.Error(t, err) + + _, err = NormalizeSetValues([]string{"red,blue"}) + require.Error(t, err) +} + +func TestParseSet(t *testing.T) { + setDef := "read,write,execute" + + bits, err := ParseSet(setDef, "read,execute") + require.NoError(t, err) + require.Equal(t, uint64(5), bits) + + bits, err = ParseSet(setDef, "3") + require.NoError(t, err) + require.Equal(t, uint64(3), bits) + + value, err := ParseSetIndex(setDef, 5) + require.NoError(t, err) + require.Equal(t, "read,execute", value) + + _, err = ParseSet(setDef, "delete") + require.Error(t, err) + + _, err = ParseSetValue(setDef, 8) + require.Error(t, err) + + // Numeric SET values should be parsed as base-10, not Go's base-0 form. + // A zero-prefixed decimal ("07") must keep its decimal meaning (7), + // and "09" must succeed instead of being rejected as bad octal. + wideDef := "a,b,c,d,e,f,g,h,i,j" + bits, err = ParseSet(wideDef, "07") + require.NoError(t, err) + require.Equal(t, uint64(7), bits) + bits, err = ParseSet(wideDef, "09") + require.NoError(t, err) + require.Equal(t, uint64(9), bits) +} + +func TestParseSetWithEmptyMember(t *testing.T) { + setDef := EncodeSetValues([]string{"", "a"}) + require.NotEqual(t, ",a", setDef) + + bits, err := ParseSet(setDef, "") + require.NoError(t, err) + require.Equal(t, uint64(1), bits) + + bits, err = ParseSet(setDef, ",a") + require.NoError(t, err) + require.Equal(t, uint64(3), bits) + + value, err := ParseSetIndex(setDef, 3) + require.NoError(t, err) + require.Equal(t, ",a", value) + + values, err := DecodeSetValues(setDef) + require.NoError(t, err) + require.Equal(t, []string{"", "a"}, values) +} + +func TestNormalizeSetValuesMaxMembers(t *testing.T) { + values := make([]string, MaxSetMembers+1) + for i := range values { + values[i] = fmt.Sprintf("v%d", i) + } + _, err := NormalizeSetValues(values) + require.Error(t, err) +} diff --git a/pkg/container/types/types.go b/pkg/container/types/types.go index 2ebabe888f64c..6e69b92db908d 100644 --- a/pkg/container/types/types.go +++ b/pkg/container/types/types.go @@ -66,6 +66,7 @@ const ( T_datetime T = 52 T_timestamp T = 53 T_interval T = 54 + T_year T = 55 // string family T_char T = 60 @@ -75,6 +76,7 @@ const ( T_binary T = 64 T_varbinary T = 65 T_enum T = 66 + T_geometry T = 67 // blobs T_blob T = 70 @@ -397,9 +399,11 @@ var Types = map[string]T{ "time": T_time, "timestamp": T_timestamp, "interval": T_interval, + "year": T_year, - "char": T_char, - "varchar": T_varchar, + "char": T_char, + "varchar": T_varchar, + "geometry": T_geometry, "binary": T_binary, "varbinary": T_varbinary, @@ -432,7 +436,7 @@ func New(oid T, width, scale int32) Type { func CharsetType(oid T) uint8 { switch oid { - case T_blob, T_varbinary, T_binary: + case T_blob, T_varbinary, T_binary, T_geometry: // binary charset return 1 default: @@ -527,7 +531,7 @@ func (t Type) IsNumeric() bool { func (t Type) IsTemporal() bool { switch t.Oid { - case T_date, T_time, T_datetime, T_timestamp, T_interval: + case T_date, T_time, T_datetime, T_timestamp, T_interval, T_year: return true } return false @@ -595,6 +599,9 @@ func (t T) ToType() Type { typ.Size = 1 case T_int16: typ.Size = 2 + case T_year: + typ.Size = 2 + typ.Width = 4 case T_int32, T_date: typ.Size = 4 case T_int64, T_datetime, T_time, T_timestamp: @@ -628,7 +635,7 @@ func (t T) ToType() Type { typ.Size = RowidSize case T_Blockid: typ.Size = BlockidSize - case T_json, T_blob, T_text, T_datalink: + case T_json, T_blob, T_text, T_datalink, T_geometry: typ.Size = VarlenaSize case T_char: typ.Size = VarlenaSize @@ -740,6 +747,10 @@ func (t T) String() string { return "VECF64" case T_enum: return "ENUM" + case T_year: + return "YEAR" + case T_geometry: + return "GEOMETRY" } return fmt.Sprintf("unexpected type: %d", t) } @@ -791,6 +802,8 @@ func (t T) OidString() string { return "T_time" case T_timestamp: return "T_timestamp" + case T_year: + return "T_year" case T_decimal64: return "T_decimal64" case T_decimal128: @@ -813,6 +826,8 @@ func (t T) OidString() string { return "T_interval" case T_enum: return "T_enum" + case T_geometry: + return "T_geometry" case T_array_float32: return "T_array_float32" case T_array_float64: @@ -830,7 +845,7 @@ func (t T) TypeLen() int { return 8 case T_int8, T_bool: return 1 - case T_int16: + case T_int16, T_year: return 2 case T_int32, T_date: return 4 @@ -848,7 +863,8 @@ func (t T) TypeLen() int { return 4 case T_float64: return 8 - case T_char, T_varchar, T_json, T_blob, T_text, T_binary, T_varbinary, T_array_float32, T_array_float64, T_datalink: + case T_char, T_varchar, T_json, T_blob, T_text, T_binary, T_varbinary, T_array_float32, T_array_float64, + T_datalink, T_geometry: return VarlenaSize case T_decimal64: return 8 @@ -881,7 +897,7 @@ func (t T) FixedLength() int { return 8 case T_int8, T_uint8, T_bool: return 1 - case T_int16, T_uint16: + case T_int16, T_uint16, T_year: return 2 case T_int32, T_uint32, T_date, T_float32: return 4 @@ -901,7 +917,8 @@ func (t T) FixedLength() int { return RowidSize case T_Blockid: return BlockidSize - case T_char, T_varchar, T_blob, T_json, T_text, T_binary, T_varbinary, T_array_float32, T_array_float64, T_datalink: + case T_char, T_varchar, T_blob, T_json, T_text, T_binary, T_varbinary, T_array_float32, T_array_float64, + T_datalink, T_geometry: return -24 case T_enum: return 2 @@ -919,7 +936,7 @@ func (t T) IsOrdered() bool { T_uint8, T_uint16, T_uint32, T_uint64, T_float32, T_float64, T_date, T_time, T_datetime, T_timestamp, - T_bit: + T_year, T_bit: return true default: return false @@ -975,7 +992,7 @@ func (t T) IsMySQLString() bool { } func (t T) IsDateRelate() bool { - if t == T_date || t == T_datetime || t == T_timestamp || t == T_time { + if t == T_date || t == T_datetime || t == T_timestamp || t == T_time || t == T_year { return true } return false diff --git a/pkg/container/types/types_test.go b/pkg/container/types/types_test.go index 1bec298e85492..8985365e5d7ee 100644 --- a/pkg/container/types/types_test.go +++ b/pkg/container/types/types_test.go @@ -138,6 +138,11 @@ func TestT_ToType(t *testing.T) { require.Equal(t, int32(MaxBitLen), T_bit.ToType().Width) } +func TestMySQLCompatibilityTypeProperties(t *testing.T) { + require.Equal(t, uint8(1), CharsetType(T_geometry)) + require.True(t, T_year.IsDateRelate()) +} + func TestT_String(t *testing.T) { require.Equal(t, "TINYINT", T_int8.String()) require.Equal(t, "SMALLINT", T_int16.String()) diff --git a/pkg/container/types/year.go b/pkg/container/types/year.go new file mode 100644 index 0000000000000..650fdff45c3a0 --- /dev/null +++ b/pkg/container/types/year.go @@ -0,0 +1,99 @@ +// Copyright 2026 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 types + +import ( + "fmt" + "strconv" + + "github.com/matrixorigin/matrixone/pkg/common/moerr" +) + +type MoYear int16 + +const ( + MinYearValue MoYear = 1901 + MaxYearValue MoYear = 2155 +) + +func ParseMoYear(s string) (MoYear, error) { + if s == "" { + return 0, moerr.NewInvalidInputNoCtx("invalid year format: empty string") + } + // Reject signed forms like "+0" / "-0" / "+1990" — MySQL's YEAR literal + // syntax never accepts a leading sign. + if s[0] == '+' || s[0] == '-' { + return 0, moerr.NewInvalidInputNoCtxf("invalid year value: %s", s) + } + v, err := strconv.ParseInt(s, 10, 64) + if err != nil { + return 0, moerr.NewInvalidInputNoCtxf("invalid year format: %s", s) + } + if len(s) == 4 { + if s == "0000" { + return 0, nil + } + if s[0] == '0' { + return 0, moerr.NewInvalidInputNoCtxf("invalid year value: %s", s) + } + return ParseMoYearFromInt(v) + } + if len(s) <= 2 { + // "0" and "00" both map to 0000 to match legacy MatrixOne behavior. + if v == 0 { + return 0, nil + } + if v >= 1 && v <= 69 { + return MoYear(2000 + v), nil + } + if v >= 70 && v <= 99 { + return MoYear(1900 + v), nil + } + } + // Anything else (3-digit strings, 4+ digit strings not handled above, etc.) + // is rejected. + return 0, moerr.NewInvalidInputNoCtxf("invalid year value: %s", s) +} + +func ParseMoYearFromInt(v int64) (MoYear, error) { + if v == 0 { + return 0, nil + } + if v >= 1 && v <= 69 { + return MoYear(2000 + v), nil + } + if v >= 70 && v <= 99 { + return MoYear(1900 + v), nil + } + if v >= int64(MinYearValue) && v <= int64(MaxYearValue) { + return MoYear(v), nil + } + return 0, moerr.NewInvalidInputNoCtxf("year value out of range: %d", v) +} + +func ValidateMoYear(y MoYear) error { + if y == 0 || (y >= MinYearValue && y <= MaxYearValue) { + return nil + } + return moerr.NewInvalidInputNoCtxf("year value out of range: %d", y) +} + +func (y MoYear) String() string { + return fmt.Sprintf("%04d", y) +} + +func (y MoYear) ToInt64() int64 { + return int64(y) +} diff --git a/pkg/container/types/year_test.go b/pkg/container/types/year_test.go new file mode 100644 index 0000000000000..d545621aac2b9 --- /dev/null +++ b/pkg/container/types/year_test.go @@ -0,0 +1,111 @@ +// Copyright 2026 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 types + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestMoYearTypeDefinition(t *testing.T) { + typ := T_year.ToType() + require.Equal(t, T_year, typ.Oid) + require.Equal(t, int32(2), typ.Size) + require.Equal(t, int32(4), typ.Width) + require.Equal(t, "YEAR", T_year.String()) + require.Equal(t, "T_year", T_year.OidString()) + require.Equal(t, 2, T_year.TypeLen()) + require.Equal(t, 2, T_year.FixedLength()) + require.True(t, T_year.IsDateRelate()) + require.True(t, T_year.IsOrdered()) + require.True(t, T_year.IsFixedLen()) + require.True(t, typ.IsTemporal()) +} + +func TestParseMoYear(t *testing.T) { + tests := []struct { + name string + input string + want MoYear + wantErr bool + }{ + {"zero string", "0000", 0, false}, + {"four digit min", "1901", 1901, false}, + {"four digit max", "2155", 2155, false}, + {"one digit zero", "0", 0, false}, + {"two digit zero", "00", 0, false}, + {"two digit low", "69", 2069, false}, + {"two digit high", "70", 1970, false}, + {"four digit leading zero low", "0001", 0, true}, + {"four digit leading zero high", "0069", 0, true}, + {"empty string", "", 0, true}, + {"invalid string", "abc", 0, true}, + {"below range", "1900", 0, true}, + {"above range", "2156", 0, true}, + {"plus sign zero", "+0", 0, true}, + {"minus sign zero", "-0", 0, true}, + {"plus sign four digit", "+1990", 0, true}, + {"three digit zeros", "000", 0, true}, + {"three digit", "123", 0, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := ParseMoYear(tt.input) + if tt.wantErr { + require.Error(t, err) + return + } + require.NoError(t, err) + require.Equal(t, tt.want, got) + }) + } +} + +func TestParseMoYearFromInt(t *testing.T) { + tests := []struct { + input int64 + want MoYear + wantErr bool + }{ + {0, 0, false}, + {1, 2001, false}, + {69, 2069, false}, + {70, 1970, false}, + {99, 1999, false}, + {1901, 1901, false}, + {2155, 2155, false}, + {-1, 0, true}, + {1900, 0, true}, + {2156, 0, true}, + } + for _, tt := range tests { + got, err := ParseMoYearFromInt(tt.input) + if tt.wantErr { + require.Error(t, err) + continue + } + require.NoError(t, err) + require.Equal(t, tt.want, got) + } +} + +func TestMoYearString(t *testing.T) { + require.Equal(t, "0000", MoYear(0).String()) + require.Equal(t, "1901", MoYear(1901).String()) + require.Equal(t, int64(2155), MoYear(2155).ToInt64()) + require.NoError(t, ValidateMoYear(2024)) + require.Error(t, ValidateMoYear(2156)) +} diff --git a/pkg/container/vector/functionTool_test.go b/pkg/container/vector/functionTool_test.go index e6cb331096394..2b03aece60a2e 100644 --- a/pkg/container/vector/functionTool_test.go +++ b/pkg/container/vector/functionTool_test.go @@ -100,6 +100,21 @@ func TestPreExtendAndReset(t *testing.T) { require.Equal(t, int64(0), mp.CurrNB()) } +func TestPreExtendAndResetYear(t *testing.T) { + mp := mpool.MustNewZeroNoFixed() + wrapper := NewFunctionResultWrapper(types.T_year.ToType(), mp) + + result := MustFunctionResult[types.MoYear](wrapper) + require.NoError(t, wrapper.PreExtendAndReset(2)) + require.NoError(t, result.Append(types.MoYear(2024), false)) + + values := MustFixedColNoTypeCheck[types.MoYear](result.GetResultVector()) + require.Equal(t, types.MoYear(2024), values[0]) + + wrapper.Free() + require.Equal(t, int64(0), mp.CurrNB()) +} + func TestReuseFunctionParameterStr(t *testing.T) { mp := mpool.MustNewZeroNoFixed() vec := NewVec(types.T_varchar.ToType()) diff --git a/pkg/container/vector/functionTools.go b/pkg/container/vector/functionTools.go index 1658ac4188e20..04e8cea6388a9 100644 --- a/pkg/container/vector/functionTools.go +++ b/pkg/container/vector/functionTools.go @@ -701,6 +701,8 @@ func NewFunctionResultWrapper(typ types.Type, mp *mpool.MPool) FunctionResultWra return newResultFunc[float64](typ, mp) case types.T_date: return newResultFunc[types.Date](typ, mp) + case types.T_year: + return newResultFunc[types.MoYear](typ, mp) case types.T_datetime: return newResultFunc[types.Datetime](typ, mp) case types.T_time: @@ -711,6 +713,8 @@ func NewFunctionResultWrapper(typ types.Type, mp *mpool.MPool) FunctionResultWra return newResultFunc[types.Decimal64](typ, mp) case types.T_decimal128: return newResultFunc[types.Decimal128](typ, mp) + case types.T_decimal256: + return newResultFunc[types.Decimal256](typ, mp) case types.T_TS: return newResultFunc[types.TS](typ, mp) case types.T_Rowid: diff --git a/pkg/container/vector/tools.go b/pkg/container/vector/tools.go index a7e4d93aad332..5eff37145aa71 100644 --- a/pkg/container/vector/tools.go +++ b/pkg/container/vector/tools.go @@ -240,10 +240,14 @@ func (v *Vector) setupFromData() { v.col.setFromVector(v) case types.T_decimal128: v.col.setFromVector(v) + case types.T_decimal256: + v.col.setFromVector(v) case types.T_uuid: v.col.setFromVector(v) case types.T_date: v.col.setFromVector(v) + case types.T_year: + v.col.setFromVector(v) case types.T_time: v.col.setFromVector(v) case types.T_datetime: @@ -373,6 +377,10 @@ func MakeAppendBytesFunc(vec *Vector) func([]byte, bool, *mpool.MPool) error { return appendBytesToFixSized[types.Decimal64](vec) case types.T_decimal128: return appendBytesToFixSized[types.Decimal128](vec) + case types.T_decimal256: + return appendBytesToFixSized[types.Decimal256](vec) + case types.T_year: + return appendBytesToFixSized[types.MoYear](vec) case types.T_uuid: return appendBytesToFixSized[types.Uuid](vec) case types.T_TS: diff --git a/pkg/container/vector/utils.go b/pkg/container/vector/utils.go index fc74e9e706ffd..9e5fd5ac1b0b2 100644 --- a/pkg/container/vector/utils.go +++ b/pkg/container/vector/utils.go @@ -370,10 +370,14 @@ func typeCompatible[T any](typ types.Type) bool { return typ.Oid == types.T_decimal64 case types.Decimal128: return typ.Oid == types.T_decimal128 + case types.Decimal256: + return typ.Oid == types.T_decimal256 case types.Uuid: return typ.Oid == types.T_uuid case types.Date: return typ.Oid == types.T_date + case types.MoYear: + return typ.Oid == types.T_year case types.Time: return typ.Oid == types.T_time case types.Datetime: diff --git a/pkg/container/vector/vector_test.go b/pkg/container/vector/vector_test.go index 93b48eb9be4d4..867121a9b01fd 100644 --- a/pkg/container/vector/vector_test.go +++ b/pkg/container/vector/vector_test.go @@ -63,6 +63,26 @@ func TestLength(t *testing.T) { } } +func TestMakeAppendBytesFuncSupportsYearAndDecimal256(t *testing.T) { + mp := mpool.MustNewZero() + + yearVec := NewVec(types.T_year.ToType()) + defer yearVec.Free(mp) + appendYear := MakeAppendBytesFunc(yearVec) + require.NoError(t, appendYear(types.EncodeFixed(types.MoYear(2024)), false, mp)) + years := MustFixedColNoTypeCheck[types.MoYear](yearVec) + require.Equal(t, types.MoYear(2024), years[0]) + + decimalVec := NewVec(types.New(types.T_decimal256, 65, 4)) + defer decimalVec.Free(mp) + appendDecimal := MakeAppendBytesFunc(decimalVec) + decimal, err := types.ParseDecimal256("123456789012345678901234567890.1234", 65, 4) + require.NoError(t, err) + require.NoError(t, appendDecimal(types.EncodeFixed(decimal), false, mp)) + decimals := MustFixedColNoTypeCheck[types.Decimal256](decimalVec) + require.Equal(t, "123456789012345678901234567890.1234", decimals[0].Format(4)) +} + func TestSize(t *testing.T) { mp := mpool.MustNewZero() vec := NewVec(types.T_int8.ToType()) diff --git a/pkg/frontend/mysql_cmd_executor.go b/pkg/frontend/mysql_cmd_executor.go index fd61fa8d3f149..d0fdd411c2390 100644 --- a/pkg/frontend/mysql_cmd_executor.go +++ b/pkg/frontend/mysql_cmd_executor.go @@ -2683,6 +2683,15 @@ func executeStmtWithWorkspace(ses FeSession, ses.Error(execCtx.reqCtx, "recover from panic before finishTxnFunc", zap.Error(err)) } err = finishTxnFunc(ses, err, execCtx) + // Final sweep: if any error path below Run / Commit surfaces the + // internal __mo_index_idx_col key name (tae DedupSnapByPK, disttae + // commit-time dedup, etc.), rewrite it to the user-visible column or + // index name before the error leaves the statement boundary. + if err != nil && + moerr.IsMoErrCode(err, moerr.ErrDuplicateEntry) && + execCtx.cw != nil { + err = plan2.RewriteHiddenIndexDupEntry(execCtx.cw.Plan(), err) + } }() _, _, _ = fault.TriggerFault("executeStmtWithWorkspace_panic") diff --git a/pkg/frontend/txn.go b/pkg/frontend/txn.go index ecd6d6ab6da89..dc380c9e1c632 100644 --- a/pkg/frontend/txn.go +++ b/pkg/frontend/txn.go @@ -28,6 +28,7 @@ import ( moruntime "github.com/matrixorigin/matrixone/pkg/common/runtime" "github.com/matrixorigin/matrixone/pkg/defines" "github.com/matrixorigin/matrixone/pkg/pb/metadata" + plan2 "github.com/matrixorigin/matrixone/pkg/sql/plan" txnclient "github.com/matrixorigin/matrixone/pkg/txn/client" "github.com/matrixorigin/matrixone/pkg/txn/clock" "github.com/matrixorigin/matrixone/pkg/txn/storage/memorystorage" @@ -545,6 +546,13 @@ func (th *TxnHandler) commitUnsafe(execCtx *ExecCtx) error { return th.txnOp.Commit(ctx2) }) if err != nil { + // Optimistic-txn dedup fires at commit time and surfaces + // "__mo_index_idx_col" directly from the engine. Rewrite the key + // name to the user-visible column/index using the current + // statement's plan before we wrap it with AttachCause. + if moerr.IsMoErrCode(err, moerr.ErrDuplicateEntry) && execCtx.cw != nil { + err = plan2.RewriteHiddenIndexDupEntry(execCtx.cw.Plan(), err) + } err = moerr.AttachCause(ctx2, err) if hasRecovered { execCtx.ses.EnterFPrint(FPCommitUnsafeBeforeRollbackWhenCommitPanic) diff --git a/pkg/sql/compile/compile2.go b/pkg/sql/compile/compile2.go index 0e7791b3d0a4b..b70a2c8e12734 100644 --- a/pkg/sql/compile/compile2.go +++ b/pkg/sql/compile/compile2.go @@ -266,6 +266,9 @@ func (c *Compile) Run(_ uint64) (queryResult *util2.RunResult, err error) { c.fatalLog(retryTimes, err) if !c.canRetry(err) { + if moerr.IsMoErrCode(err, moerr.ErrDuplicateEntry) { + err = plan2.RewriteHiddenIndexDupEntry(c.pn, err) + } if c.proc.GetTxnOperator().Txn().IsRCIsolation() && moerr.IsMoErrCode(err, moerr.ErrDuplicateEntry) { orphan, e := c.proc.Base.LockService.IsOrphanTxn( diff --git a/pkg/sql/compile/fuzzyCheck.go b/pkg/sql/compile/fuzzyCheck.go index 0fbc1d0826601..34b87a8ca5254 100644 --- a/pkg/sql/compile/fuzzyCheck.go +++ b/pkg/sql/compile/fuzzyCheck.go @@ -51,6 +51,7 @@ func newFuzzyCheck(n *plan.Node) (*fuzzyCheck, error) { f.tbl = tblName f.db = dbName f.attr = n.TableDef.Pkey.PkeyColName + f.displayAttr = n.TableDef.Pkey.PkeyColName for _, c := range n.TableDef.Cols { if c.Name == n.TableDef.Pkey.PkeyColName { @@ -63,6 +64,17 @@ func newFuzzyCheck(n *plan.Node) (*fuzzyCheck, error) { if n.TableDef.Pkey.PkeyColName == catalog.CPrimaryKeyColName { f.isCompound = true f.compoundCols = f.sortColDef(n.TableDef.Pkey.Names, n.TableDef.Cols) + // displayAttr was initialized above to the internal composite PK + // column (__mo_cpkey_col) which must never leak to users. Build + // a human-readable "(col1,col2,...)" using the declared member + // names so DuplicateEntry errors show the user-visible key. + names := make([]string, 0, len(n.TableDef.Pkey.Names)) + for _, name := range n.TableDef.Pkey.Names { + names = append(names, catalog.ResolveAlias(name)) + } + if len(names) > 0 { + f.displayAttr = "(" + strings.Join(names, ",") + ")" + } } // for the case like create unique index for existed table, @@ -71,6 +83,14 @@ func newFuzzyCheck(n *plan.Node) (*fuzzyCheck, error) { // that introduces some strange logic, and obscures the meaning of some fields, such as fuzzyCheck.isCompound if catalog.IsHiddenTable(tblName) && n.Fuzzymessage == nil { f.onlyInsertHidden = true + // displayAttr was initialized above to the hidden table's PK column + // name (__mo_index_idx_col for single-column UNIQUE, __mo_cpkey_col + // for composite). Errors reported from firstlyCheck / + // backgroundSQLCheck use f.displayAttr directly and do not pass + // through RewriteHiddenIndexDupEntry, so leaving the internal name + // here leaks it to the user. Replace with a neutral placeholder; we + // do not have the user-declared unique-index name at this point. + f.displayAttr = "unique index" } if n.Fuzzymessage != nil { @@ -78,8 +98,25 @@ func newFuzzyCheck(n *plan.Node) (*fuzzyCheck, error) { f.isCompound = true f.tbl = n.Fuzzymessage.ParentTableName f.compoundCols = n.Fuzzymessage.ParentUniqueCols + // Build a composite display key like "(col1,col2)" — the plan + // message does not carry the user-declared index name, so mirror + // what bind_insert.go emits as DedupColName for compound uniques. + names := make([]string, 0, len(n.Fuzzymessage.ParentUniqueCols)) + for _, c := range n.Fuzzymessage.ParentUniqueCols { + if c == nil { + continue + } + names = append(names, catalog.ResolveAlias(c.Name)) + } + if len(names) > 0 { + f.displayAttr = "(" + strings.Join(names, ",") + ")" + } } else { f.col = n.Fuzzymessage.ParentUniqueCols[0] + // attr is the hidden __mo_index_idx_col used to run the background + // dedup SQL against the hidden table; displayAttr is the original + // user-facing column used when reporting the duplicate entry. + f.displayAttr = n.Fuzzymessage.ParentUniqueCols[0].Name } } @@ -99,6 +136,7 @@ func (f *fuzzyCheck) clear() { f.db = "" f.tbl = "" f.attr = "" + f.displayAttr = "" f.condition = "" f.isCompound = false f.onlyInsertHidden = false @@ -245,9 +283,9 @@ func (f *fuzzyCheck) firstlyCheck(ctx context.Context, toCheck *vector.Vector) e if cnt > 1 { ds, e := strconv.Unquote(k) if e != nil { - return moerr.NewDuplicateEntry(ctx, k, f.attr) + return moerr.NewDuplicateEntry(ctx, k, f.displayAttr) } else { - return moerr.NewDuplicateEntry(ctx, ds, f.attr) + return moerr.NewDuplicateEntry(ctx, ds, f.displayAttr) } } } @@ -337,9 +375,9 @@ func (f *fuzzyCheck) backgroundSQLCheck(c *Compile) error { } else { ds, e := strconv.Unquote(dupKey[0]) if e != nil { - err = moerr.NewDuplicateEntry(c.proc.Ctx, dupKey[0], f.attr) + err = moerr.NewDuplicateEntry(c.proc.Ctx, dupKey[0], f.displayAttr) } else { - err = moerr.NewDuplicateEntry(c.proc.Ctx, ds, f.attr) + err = moerr.NewDuplicateEntry(c.proc.Ctx, ds, f.displayAttr) } } } else { @@ -354,7 +392,7 @@ func (f *fuzzyCheck) backgroundSQLCheck(c *Compile) error { scales[i] = 0 } } - err = moerr.NewDuplicateEntry(c.proc.Ctx, t.ErrString(scales), f.attr) + err = moerr.NewDuplicateEntry(c.proc.Ctx, t.ErrString(scales), f.displayAttr) } } } diff --git a/pkg/sql/compile/fuzzyCheck_test.go b/pkg/sql/compile/fuzzyCheck_test.go new file mode 100644 index 0000000000000..2392c897cab66 --- /dev/null +++ b/pkg/sql/compile/fuzzyCheck_test.go @@ -0,0 +1,365 @@ +// Copyright 2026 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 compile + +import ( + "testing" + + "github.com/matrixorigin/matrixone/pkg/catalog" + "github.com/matrixorigin/matrixone/pkg/pb/plan" + "github.com/stretchr/testify/require" +) + +// TestNewFuzzyCheckAttrUsesParentUniqueColName verifies that when a hidden +// unique-index table dispatches fuzzy check via Fuzzymessage.ParentUniqueCols, +// the duplicate-entry error reports the original user-visible column name +// (e.g. "a") in displayAttr while attr stays as the hidden index column so the +// background dedup SQL keeps hitting a real column of the hidden table. +func TestNewFuzzyCheckAttrUsesParentUniqueColName(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: "__mo_index_unique_a_index", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, // "__mo_index_idx_col" + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: plan.Type{}}, + }, + }, + Fuzzymessage: &plan.OriginTableMessageForFuzzy{ + ParentTableName: "decimal15", + ParentUniqueCols: []*plan.ColDef{ + {Name: "a", Typ: plan.Type{}}, + }, + }, + } + + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + + require.Equal(t, catalog.IndexTableIndexColName, f.attr, + "attr should stay as the hidden index column name so backgroundSQLCheck queries a real column") + require.Equal(t, "a", f.displayAttr, + "displayAttr should be the user-visible column name used in duplicate-entry errors") + require.NotNil(t, f.col) + require.Equal(t, "a", f.col.Name) +} + +// TestNewFuzzyCheckAttrFallsBackToPkeyColName verifies the non-hidden-index +// insertion path still uses the primary-key column name for both the SQL and +// the error message. +func TestNewFuzzyCheckAttrFallsBackToPkeyColName(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: "t1", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: "id", + }, + Cols: []*plan.ColDef{ + {Name: "id", Typ: plan.Type{}}, + }, + }, + } + + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + + require.Equal(t, "id", f.attr) + require.Equal(t, "id", f.displayAttr) +} + +// TestNewFuzzyCheckCompositeUniqueIndexDisplayAttr verifies that when the +// hidden unique-index plan node carries a multi-column ParentUniqueCols, +// displayAttr is set to a "(c1,c2)" tuple so the duplicate-entry error +// reports a user-recognizable key name instead of __mo_index_idx_col. +func TestNewFuzzyCheckCompositeUniqueIndexDisplayAttr(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: "__mo_index_unique_composite", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: plan.Type{}}, + }, + }, + Fuzzymessage: &plan.OriginTableMessageForFuzzy{ + ParentTableName: "t1", + ParentUniqueCols: []*plan.ColDef{ + {Name: "col1", Typ: plan.Type{}}, + {Name: "col2", Typ: plan.Type{}}, + }, + }, + } + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + require.True(t, f.isCompound) + require.Equal(t, "(col1,col2)", f.displayAttr, + "composite hidden unique must surface a user-visible tuple key, not the internal hidden column") +} + +// TestNewFuzzyCheckCompoundKeyPath covers the compound primary key path — +// when the hidden PkeyColName is CPrimaryKeyColName, the helper must flip +// isCompound and populate compoundCols from Pkey.Names. +func TestNewFuzzyCheckCompoundKeyPath(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: "t1", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.CPrimaryKeyColName, + Names: []string{"a", "b"}, + }, + Cols: []*plan.ColDef{ + {Name: "a", Typ: plan.Type{}}, + {Name: "b", Typ: plan.Type{}}, + }, + }, + } + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + require.True(t, f.isCompound) + require.Len(t, f.compoundCols, 2) + require.Equal(t, "a", f.compoundCols[0].Name) + require.Equal(t, "b", f.compoundCols[1].Name) + // Real composite PK (not a hidden unique index): displayAttr must + // surface the user-declared column list, not the internal + // __mo_cpkey_col placeholder — DuplicateEntry runs through + // firstlyCheck/backgroundSQLCheck which use displayAttr verbatim. + require.NotEqual(t, catalog.CPrimaryKeyColName, f.displayAttr, + "compound PK must not leak __mo_cpkey_col into duplicate-entry errors") + require.Equal(t, "(a,b)", f.displayAttr) +} + +// TestNewFuzzyCheckHiddenOnlyPath covers the "ALTER TABLE add unique index on +// existing table" shortcut: hidden index table with no Fuzzymessage -> +// onlyInsertHidden should be true. +func TestNewFuzzyCheckHiddenOnlyPath(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: catalog.PrefixIndexTableName + "unique_hash", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: plan.Type{}}, + }, + }, + } + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + require.True(t, f.onlyInsertHidden) + // Hidden-only fallback must not leak the internal PK column name — + // firstlyCheck / backgroundSQLCheck use displayAttr directly in + // NewDuplicateEntry without going through RewriteHiddenIndexDupEntry. + require.NotEqual(t, catalog.IndexTableIndexColName, f.displayAttr, + "hidden-only fallback must not surface the internal index column name") + require.NotContains(t, f.displayAttr, "__mo_", + "hidden-only fallback must not surface any __mo_ internal name") +} + +// Composite CREATE UNIQUE INDEX on an existing table hits the same +// onlyInsertHidden fallback, but the hidden table's PK is __mo_cpkey_col. +// That name must also not leak into the user-visible error. +func TestNewFuzzyCheckHiddenOnlyCompositeDoesNotLeakInternalName(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: catalog.PrefixIndexTableName + "unique_composite", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.CPrimaryKeyColName, + Names: []string{"a", "b"}, + }, + Cols: []*plan.ColDef{ + {Name: catalog.CPrimaryKeyColName, Typ: plan.Type{}}, + {Name: "a", Typ: plan.Type{}}, + {Name: "b", Typ: plan.Type{}}, + }, + }, + } + f, err := newFuzzyCheck(n) + require.NoError(t, err) + defer f.release() + require.True(t, f.onlyInsertHidden) + require.NotEqual(t, catalog.CPrimaryKeyColName, f.displayAttr) + require.NotContains(t, f.displayAttr, "__mo_") +} + +// TestNewFuzzyCheckRejectsEmptyNames covers the error branch when tblName or +// dbName is missing. +func TestNewFuzzyCheckRejectsEmptyNames(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: ""}, + TableDef: &plan.TableDef{Name: ""}, + } + _, err := newFuzzyCheck(n) + require.Error(t, err) +} + +// TestFuzzyCheckResetAndClear exercises the lifecycle helpers so the reuse +// pool path is also covered. +func TestFuzzyCheckResetAndClear(t *testing.T) { + n := &plan.Node{ + ObjRef: &plan.ObjectRef{SchemaName: "db"}, + TableDef: &plan.TableDef{ + Name: "t1", + Pkey: &plan.PrimaryKeyDef{PkeyColName: "id"}, + Cols: []*plan.ColDef{{Name: "id", Typ: plan.Type{}}}, + }, + } + f, err := newFuzzyCheck(n) + require.NoError(t, err) + f.condition = "x=1" + f.cnt = 3 + f.reset() + require.Equal(t, "", f.condition) + require.Equal(t, 0, f.cnt) + require.Equal(t, "id", f.attr) + + f.clear() + require.Equal(t, "", f.attr) + require.Equal(t, "", f.displayAttr) + require.Equal(t, "", f.db) + require.Equal(t, "", f.tbl) + require.False(t, f.isCompound) + require.False(t, f.onlyInsertHidden) + require.Nil(t, f.col) + require.Nil(t, f.compoundCols) + + // TypeName returns a stable identifier used by the reuse pool. + require.Equal(t, "compile.fuzzyCheck", f.TypeName()) +} + +// TestConstructFuzzyFilterUsesParentUniqueColName verifies the fuzzy filter +// operator carries the user-visible column name for unique-index hidden tables +// so runtime duplicate errors report "for key 'a'" not "for key +// '__mo_index_idx_col'". +func TestConstructFuzzyFilterUsesParentUniqueColName(t *testing.T) { + idxColType := plan.Type{Id: 27} + n := &plan.Node{ + TableDef: &plan.TableDef{ + Name: "__mo_index_unique_a_index", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: idxColType}, + }, + }, + Fuzzymessage: &plan.OriginTableMessageForFuzzy{ + ParentTableName: "decimal15", + ParentUniqueCols: []*plan.ColDef{ + {Name: "a", Typ: idxColType}, + }, + }, + } + tableScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + sinkScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + + op := constructFuzzyFilter(n, tableScan, sinkScan) + require.NotNil(t, op) + require.Equal(t, "a", op.PkName) +} + +// TestConstructFuzzyFilterFallsBackToPkeyColName verifies non-hidden-index +// targets keep using the primary-key column name. +func TestConstructFuzzyFilterFallsBackToPkeyColName(t *testing.T) { + pkType := plan.Type{Id: 23} + n := &plan.Node{ + TableDef: &plan.TableDef{ + Name: "t1", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: "id", + }, + Cols: []*plan.ColDef{ + {Name: "id", Typ: pkType}, + }, + }, + } + tableScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + sinkScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + + op := constructFuzzyFilter(n, tableScan, sinkScan) + require.NotNil(t, op) + require.Equal(t, "id", op.PkName) +} + +// When plan has no Fuzzymessage and the target is a hidden index table +// (CREATE UNIQUE INDEX direct-insert path), constructFuzzyFilter must +// substitute a neutral placeholder for PkName instead of the raw +// __mo_index_idx_col / __mo_cpkey_col column name. +func TestConstructFuzzyFilterHiddenOnlyFallback(t *testing.T) { + idxColType := plan.Type{Id: 27} + n := &plan.Node{ + TableDef: &plan.TableDef{ + Name: catalog.PrefixIndexTableName + "unique_hash", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: idxColType}, + }, + }, + } + tableScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + sinkScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + + op := constructFuzzyFilter(n, tableScan, sinkScan) + require.NotNil(t, op) + require.NotEqual(t, catalog.IndexTableIndexColName, op.PkName, + "hidden-only direct fuzzy filter must not leak internal index column name") + require.NotContains(t, op.PkName, "__mo_", + "hidden-only direct fuzzy filter must not surface any __mo_ internal name") +} + +// TestConstructFuzzyFilterCompositeParentUniqueCols verifies the composite +// unique-index path surfaces a "(col1,col2)" tuple as PkName so runtime +// duplicate errors do not leak __mo_index_idx_col. +func TestConstructFuzzyFilterCompositeParentUniqueCols(t *testing.T) { + idxColType := plan.Type{Id: 27} + n := &plan.Node{ + TableDef: &plan.TableDef{ + Name: "__mo_index_unique_composite", + Pkey: &plan.PrimaryKeyDef{ + PkeyColName: catalog.IndexTableIndexColName, + }, + Cols: []*plan.ColDef{ + {Name: catalog.IndexTableIndexColName, Typ: idxColType}, + }, + }, + Fuzzymessage: &plan.OriginTableMessageForFuzzy{ + ParentTableName: "t1", + ParentUniqueCols: []*plan.ColDef{ + {Name: "col1", Typ: idxColType}, + {Name: "col2", Typ: idxColType}, + }, + }, + } + tableScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + sinkScan := &plan.Node{Stats: &plan.Stats{Cost: 100}} + + op := constructFuzzyFilter(n, tableScan, sinkScan) + require.NotNil(t, op) + require.Equal(t, "(col1,col2)", op.PkName) +} diff --git a/pkg/sql/compile/operator.go b/pkg/sql/compile/operator.go index 6b1a0c3dc1ef0..28b8932a9258b 100644 --- a/pkg/sql/compile/operator.go +++ b/pkg/sql/compile/operator.go @@ -18,6 +18,7 @@ import ( "context" "fmt" "math" + "strings" "github.com/google/uuid" "github.com/matrixorigin/matrixone/pkg/catalog" @@ -750,8 +751,39 @@ func constructFuzzyFilter(n, tableScan, sinkScan *plan.Node) *fuzzyfilter.FuzzyF } } + // When the fuzzy filter target is a hidden unique-index table, report the + // user-visible column name (e.g. "a") in the duplicate-entry error instead + // of the hidden index column ("__mo_index_idx_col"). For composite unique + // indexes we fall back to a "(col1,col2)" tuple because the plan message + // does not carry the user-declared index name. + displayPkName := pkName + if n.Fuzzymessage != nil { + if len(n.Fuzzymessage.ParentUniqueCols) == 1 { + displayPkName = n.Fuzzymessage.ParentUniqueCols[0].Name + } else if len(n.Fuzzymessage.ParentUniqueCols) > 1 { + names := make([]string, 0, len(n.Fuzzymessage.ParentUniqueCols)) + for _, c := range n.Fuzzymessage.ParentUniqueCols { + if c == nil { + continue + } + names = append(names, catalog.ResolveAlias(c.Name)) + } + if len(names) > 0 { + displayPkName = "(" + strings.Join(names, ",") + ")" + } + } + } else if n.TableDef != nil && catalog.IsHiddenTable(n.TableDef.Name) { + // Direct-insert path into a hidden UNIQUE index table (e.g. + // CREATE UNIQUE INDEX on an existing table). The plan does not + // carry Fuzzymessage, so pkName is still __mo_index_idx_col / + // __mo_cpkey_col. Mirror the placeholder used in newFuzzyCheck + // so runtime duplicate-entry errors do not leak the internal + // catalog column name. + displayPkName = "unique index" + } + op := fuzzyfilter.NewArgument() - op.PkName = pkName + op.PkName = displayPkName op.PkTyp = pkTyp op.IfInsertFromUnique = n.IfInsertFromUnique diff --git a/pkg/sql/compile/types.go b/pkg/sql/compile/types.go index acb3e810bf193..2d3ab9b4256de 100644 --- a/pkg/sql/compile/types.go +++ b/pkg/sql/compile/types.go @@ -315,10 +315,17 @@ type RemoteReceivRegInfo struct { } type fuzzyCheck struct { - db string - tbl string - attr string - condition string + db string + tbl string + // attr is the column name used for the background dedup SQL. For unique + // index hidden tables it stays as the hidden index column (e.g. + // __mo_index_idx_col) so the SQL actually hits an existing column. + attr string + // displayAttr is the column name surfaced to the user in the duplicate + // entry error. Normally it equals attr, but for unique index hidden tables + // it is the original table's column/index name. + displayAttr string + condition string // handle with primary key(a, b, ...) or unique key (a, b, ...) isCompound bool diff --git a/pkg/sql/parsers/dialect/mysql/mysql_sql.go b/pkg/sql/parsers/dialect/mysql/mysql_sql.go index 5a3f793067306..07ae2be1806cc 100644 --- a/pkg/sql/parsers/dialect/mysql/mysql_sql.go +++ b/pkg/sql/parsers/dialect/mysql/mysql_sql.go @@ -1431,7 +1431,7 @@ const yyEofCode = 1 const yyErrCode = 2 const yyInitialStackSize = 16 -//line mysql_sql.y:13736 +//line mysql_sql.y:13821 //line yacctab:1 var yyExca = [...]int{ @@ -1454,428 +1454,456 @@ var yyExca = [...]int{ 494, 660, -2, 695, -1, 243, - 695, 2133, + 695, 2140, -2, 549, -1, 570, - 695, 2256, + 695, 2263, -2, 415, -1, 628, - 695, 2315, + 695, 2322, -2, 413, -1, 629, - 695, 2316, + 695, 2323, -2, 414, -1, 630, - 695, 2317, + 695, 2324, -2, 416, -1, 784, 329, 182, 466, 182, 467, 182, - -2, 2024, + -2, 2031, -1, 851, 86, 1804, - -2, 2192, + -2, 2199, -1, 852, 86, 1822, - -2, 2163, + -2, 2170, -1, 856, 86, 1823, - -2, 2191, + -2, 2198, -1, 899, 86, 1725, - -2, 2402, + -2, 2409, -1, 900, 86, 1726, - -2, 2401, + -2, 2408, -1, 901, 86, 1727, - -2, 2391, + -2, 2398, -1, 902, - 86, 2363, - -2, 2384, + 86, 2370, + -2, 2391, -1, 903, - 86, 2364, - -2, 2385, + 86, 2371, + -2, 2392, -1, 904, - 86, 2365, - -2, 2393, + 86, 2372, + -2, 2400, -1, 905, - 86, 2366, - -2, 2373, + 86, 2373, + -2, 2380, -1, 906, - 86, 2367, - -2, 2382, + 86, 2374, + -2, 2389, -1, 907, - 86, 2368, - -2, 2394, + 86, 2375, + -2, 2401, -1, 908, - 86, 2369, - -2, 2395, + 86, 2376, + -2, 2402, -1, 909, - 86, 2370, - -2, 2400, + 86, 2377, + -2, 2407, -1, 910, - 86, 2371, - -2, 2405, + 86, 2378, + -2, 2412, -1, 911, - 86, 2372, - -2, 2406, + 86, 2379, + -2, 2413, -1, 912, 86, 1800, - -2, 2230, + -2, 2237, -1, 913, 86, 1801, - -2, 2004, + -2, 2011, -1, 914, 86, 1802, - -2, 2239, + -2, 2246, -1, 915, 86, 1803, - -2, 2017, + -2, 2024, -1, 917, 86, 1806, - -2, 2026, + -2, 2033, -1, 919, 86, 1808, - -2, 2263, + -2, 2270, -1, 921, 86, 1810, - -2, 2047, + -2, 2054, -1, 923, 86, 1812, - -2, 2275, + -2, 2282, -1, 924, 86, 1813, - -2, 2274, + -2, 2281, -1, 925, 86, 1814, - -2, 2094, + -2, 2101, -1, 926, 86, 1815, - -2, 2187, + -2, 2194, -1, 929, 86, 1818, - -2, 2286, + -2, 2293, -1, 931, 86, 1820, - -2, 2289, + -2, 2296, -1, 932, 86, 1821, - -2, 2291, + -2, 2298, -1, 933, 86, 1824, - -2, 2299, + -2, 2306, -1, 934, 86, 1825, - -2, 2172, + -2, 2179, -1, 935, 86, 1826, - -2, 2217, + -2, 2224, -1, 936, 86, 1827, - -2, 2182, + -2, 2189, -1, 937, 86, 1828, - -2, 2207, + -2, 2214, -1, 948, 86, 1703, - -2, 2396, + -2, 2403, -1, 949, 86, 1704, - -2, 2397, + -2, 2404, -1, 950, 86, 1705, - -2, 2398, + -2, 2405, -1, 1054, 489, 695, 490, 695, -2, 661, -1, 1107, - 128, 2004, - 139, 2004, - 161, 2004, - -2, 1976, - -1, 1229, + 128, 2011, + 139, 2011, + 161, 2011, + -2, 1983, + -1, 1236, 22, 868, -2, 815, - -1, 1342, + -1, 1349, 11, 839, 22, 839, -2, 1567, - -1, 1435, + -1, 1442, 22, 868, -2, 815, - -1, 1806, + -1, 1813, 86, 1875, - -2, 2189, - -1, 1807, + -2, 2196, + -1, 1814, 86, 1876, - -2, 2190, - -1, 2463, + -2, 2197, + -1, 2470, 87, 1055, -2, 1061, - -1, 2478, + -1, 2485, 111, 1236, 155, 1236, 197, 1236, 200, 1236, 290, 1236, -2, 1229, - -1, 2663, + -1, 2670, 11, 839, 22, 839, -2, 982, - -1, 2697, - 87, 1962, - 162, 1962, - -2, 2174, - -1, 2698, - 87, 1962, - 162, 1962, - -2, 2173, - -1, 2699, + -1, 2704, + 87, 1969, + 162, 1969, + -2, 2181, + -1, 2705, + 87, 1969, + 162, 1969, + -2, 2180, + -1, 2706, 87, 1938, 162, 1938, - -2, 2160, - -1, 2700, + -2, 2167, + -1, 2707, 87, 1939, 162, 1939, - -2, 2165, - -1, 2701, + -2, 2172, + -1, 2708, 87, 1940, 162, 1940, - -2, 2082, - -1, 2702, + -2, 2089, + -1, 2709, 87, 1941, 162, 1941, - -2, 2075, - -1, 2703, + -2, 2082, + -1, 2710, 87, 1942, 162, 1942, - -2, 1992, - -1, 2704, + -2, 1999, + -1, 2711, 87, 1943, 162, 1943, - -2, 2162, - -1, 2705, + -2, 2169, + -1, 2712, 87, 1944, 162, 1944, - -2, 2080, - -1, 2706, + -2, 2087, + -1, 2713, 87, 1945, 162, 1945, - -2, 2074, - -1, 2707, + -2, 2081, + -1, 2714, 87, 1946, 162, 1946, - -2, 2062, - -1, 2708, - 87, 1962, - 162, 1962, - -2, 2063, - -1, 2709, - 87, 1962, - 162, 1962, - -2, 2064, - -1, 2711, + -2, 2069, + -1, 2715, + 87, 1969, + 162, 1969, + -2, 2070, + -1, 2716, + 87, 1969, + 162, 1969, + -2, 2071, + -1, 2718, 87, 1951, 162, 1951, - -2, 2207, - -1, 2712, + -2, 2214, + -1, 2719, 87, 1928, 162, 1928, - -2, 2192, - -1, 2713, - 87, 1960, - 162, 1960, - -2, 2163, - -1, 2714, - 87, 1960, - 162, 1960, - -2, 2191, - -1, 2715, - 87, 1960, - 162, 1960, - -2, 2027, - -1, 2716, - 87, 1958, - 162, 1958, - -2, 2182, - -1, 2717, + -2, 2199, + -1, 2720, + 87, 1967, + 162, 1967, + -2, 2170, + -1, 2721, + 87, 1967, + 162, 1967, + -2, 2198, + -1, 2722, + 87, 1967, + 162, 1967, + -2, 2034, + -1, 2723, + 87, 1965, + 162, 1965, + -2, 2189, + -1, 2724, 87, 1955, 162, 1955, - -2, 2052, - -1, 2718, + -2, 2059, + -1, 2725, + 87, 1956, + 162, 1956, + -2, 2118, + -1, 2726, + 87, 1957, + 162, 1957, + -2, 2079, + -1, 2727, + 87, 1958, + 162, 1958, + -2, 2119, + -1, 2728, + 87, 1959, + 162, 1959, + -2, 2060, + -1, 2729, + 87, 1960, + 162, 1960, + -2, 2093, + -1, 2730, + 87, 1961, + 162, 1961, + -2, 2092, + -1, 2731, + 87, 1962, + 162, 1962, + -2, 2094, + -1, 2732, 86, 1909, 87, 1909, 162, 1909, 424, 1909, 425, 1909, 426, 1909, - -2, 1991, - -1, 2719, + -2, 1998, + -1, 2733, 86, 1910, 87, 1910, 162, 1910, 424, 1910, 425, 1910, 426, 1910, - -2, 1993, - -1, 2720, + -2, 2000, + -1, 2734, 86, 1911, 87, 1911, 162, 1911, 424, 1911, 425, 1911, 426, 1911, - -2, 2235, - -1, 2721, + -2, 2242, + -1, 2735, 86, 1913, 87, 1913, 162, 1913, 424, 1913, 425, 1913, 426, 1913, - -2, 2164, - -1, 2722, + -2, 2171, + -1, 2736, 86, 1915, 87, 1915, 162, 1915, 424, 1915, 425, 1915, 426, 1915, - -2, 2143, - -1, 2723, + -2, 2150, + -1, 2737, 86, 1917, 87, 1917, 162, 1917, 424, 1917, 425, 1917, 426, 1917, - -2, 2081, - -1, 2724, + -2, 2088, + -1, 2738, 86, 1919, 87, 1919, 162, 1919, 424, 1919, 425, 1919, 426, 1919, - -2, 2058, - -1, 2725, + -2, 2065, + -1, 2739, 86, 1920, 87, 1920, 162, 1920, 424, 1920, 425, 1920, 426, 1920, - -2, 2059, - -1, 2726, + -2, 2066, + -1, 2740, 86, 1922, 87, 1922, 162, 1922, 424, 1922, 425, 1922, 426, 1922, - -2, 1990, - -1, 2727, - 87, 1965, - 162, 1965, - 424, 1965, - 425, 1965, - 426, 1965, - -2, 2032, - -1, 2728, - 87, 1965, - 162, 1965, - 424, 1965, - 425, 1965, - 426, 1965, - -2, 2048, - -1, 2729, - 87, 1968, - 162, 1968, - 424, 1968, - 425, 1968, - 426, 1968, - -2, 2028, - -1, 2730, - 87, 1968, - 162, 1968, - 424, 1968, - 425, 1968, - 426, 1968, - -2, 2097, - -1, 2731, - 87, 1965, - 162, 1965, - 424, 1965, - 425, 1965, - 426, 1965, - -2, 2125, - -1, 2978, + -2, 1997, + -1, 2741, + 87, 1972, + 162, 1972, + 424, 1972, + 425, 1972, + 426, 1972, + -2, 2039, + -1, 2742, + 87, 1972, + 162, 1972, + 424, 1972, + 425, 1972, + 426, 1972, + -2, 2055, + -1, 2743, + 87, 1975, + 162, 1975, + 424, 1975, + 425, 1975, + 426, 1975, + -2, 2035, + -1, 2744, + 87, 1975, + 162, 1975, + 424, 1975, + 425, 1975, + 426, 1975, + -2, 2104, + -1, 2745, + 87, 1972, + 162, 1972, + 424, 1972, + 425, 1972, + 426, 1972, + -2, 2132, + -1, 2992, 111, 1236, 155, 1236, 197, 1236, 200, 1236, 290, 1236, -2, 1230, - -1, 2998, + -1, 3012, 84, 759, 162, 759, -2, 1441, - -1, 3459, + -1, 3473, 200, 1236, 314, 1530, -2, 1502, - -1, 3501, + -1, 3515, 11, 839, 22, 839, 87, 832, -2, 1567, - -1, 3684, + -1, 3698, 111, 1236, 155, 1236, 197, 1236, 200, 1236, -2, 1382, - -1, 3687, + -1, 3701, 111, 1236, 155, 1236, 197, 1236, 200, 1236, -2, 1382, - -1, 3699, + -1, 3713, 84, 759, 162, 759, -2, 1441, - -1, 3721, + -1, 3735, 200, 1236, 314, 1530, -2, 1503, - -1, 3860, + -1, 3874, 11, 839, 22, 839, -2, 1567, - -1, 3903, + -1, 3917, 111, 1236, 155, 1236, 197, 1236, 200, 1236, -2, 1383, - -1, 3929, + -1, 3943, 87, 1344, 162, 1344, -2, 1236, - -1, 4089, + -1, 4103, 87, 1344, 162, 1344, -2, 1236, - -1, 4272, + -1, 4286, 87, 1348, 162, 1348, -2, 1236, - -1, 4331, + -1, 4345, 87, 1349, 162, 1349, -2, 1236, @@ -1883,714 +1911,893 @@ var yyExca = [...]int{ const yyPrivate = 57344 -const yyLast = 59237 +const yyLast = 59294 var yyAct = [...]int{ - 818, 794, 4385, 820, 4353, 3030, 232, 4377, 4276, 1786, - 3706, 1707, 2090, 3810, 4282, 3479, 4275, 4283, 4164, 4089, - 3445, 4187, 2734, 803, 4138, 4223, 3349, 3564, 3957, 3735, - 4034, 3024, 4129, 1378, 3351, 4165, 3565, 4088, 4067, 1848, - 3891, 796, 1618, 3993, 848, 1230, 2933, 677, 3027, 4058, - 37, 1106, 1543, 3815, 3665, 219, 3, 3805, 4139, 4141, - 1549, 2029, 3670, 2541, 1224, 696, 1835, 702, 702, 3454, - 2864, 3910, 3900, 702, 720, 729, 3722, 3415, 729, 3001, - 1789, 3400, 3377, 148, 3688, 792, 3562, 3150, 3151, 217, - 2195, 2209, 3403, 3149, 2695, 2192, 3657, 3053, 70, 3624, - 3905, 3690, 747, 3119, 3463, 3474, 2157, 3146, 3456, 2657, - 1850, 2941, 3498, 2232, 3615, 742, 3218, 2825, 2307, 2693, - 3179, 1853, 2264, 3381, 726, 3547, 2544, 2966, 3526, 3367, - 3383, 3462, 3425, 2047, 738, 3380, 3137, 2790, 1611, 1220, - 2490, 3379, 3375, 2979, 36, 3334, 786, 1506, 3378, 2432, - 1696, 2291, 2431, 1518, 2265, 1959, 1729, 3267, 1782, 1685, - 2766, 986, 2303, 791, 1692, 2273, 2748, 2188, 2272, 1697, - 2237, 2302, 1700, 2658, 2161, 2641, 2158, 2955, 1022, 3055, - 2950, 2636, 3035, 2542, 2080, 2993, 2691, 228, 8, 227, - 7, 6, 2489, 2478, 1849, 2013, 1552, 1168, 1780, 1659, - 795, 2304, 1785, 793, 1627, 1477, 695, 1596, 677, 2337, - 1100, 1590, 2469, 1532, 1842, 2537, 785, 2472, 2288, 2046, - 1822, 804, 1771, 1514, 1246, 2271, 1711, 2268, 1708, 2253, - 735, 1666, 232, 1779, 232, 2009, 1159, 1160, 1595, 1099, - 2665, 711, 2012, 702, 2637, 1021, 952, 1650, 1544, 1592, - 1528, 744, 1139, 1854, 24, 1063, 1553, 676, 25, 745, - 23, 17, 10, 728, 1002, 27, 218, 1019, 214, 1457, - 1433, 741, 210, 1049, 1379, 1077, 698, 954, 955, 1156, - 2311, 3573, 215, 66, 206, 176, 1308, 1309, 1310, 1307, - 3235, 16, 4150, 4055, 2908, 1112, 2908, 2908, 2574, 2667, - 3702, 207, 14, 1308, 1309, 1310, 1307, 2863, 198, 3432, - 1115, 3234, 208, 1308, 1309, 1310, 1307, 15, 2321, 1225, - 3861, 1155, 997, 1157, 3673, 1226, 33, 3557, 2813, 2751, - 2754, 147, 2752, 714, 2749, 1972, 1010, 1673, 1007, 725, - 1669, 733, 1151, 707, 703, 1152, 133, 216, 1134, 697, - 2430, 1452, 1510, 1511, 1512, 211, 1114, 1594, 4116, 1152, - 1419, 974, 2735, 1085, 972, 721, 2436, 1152, 1973, 1722, - 3344, 2440, 1455, 3327, 1225, 787, 723, 3324, 3329, 3326, - 4365, 1566, 5, 1966, 1448, 1671, 2900, 2898, 3803, 3214, - 3212, 724, 1308, 1309, 1310, 1307, 989, 2242, 4124, 4000, - 722, 3994, 3806, 3563, 8, 2287, 7, 1373, 1150, 1308, - 1309, 1310, 1307, 4143, 2267, 953, 2788, 3298, 3365, 2259, - 776, 2582, 1135, 778, 4391, 2616, 4137, 4362, 777, 964, - 2902, 4008, 4074, 3849, 156, 157, 4311, 158, 159, 4045, - 3821, 1306, 160, 3689, 1270, 161, 2799, 3847, 215, 2308, - 1468, 3243, 2481, 1706, 4135, 3878, 4043, 4006, 2807, 3649, - 2183, 4254, 2843, 2447, 4198, 3644, 3368, 2461, 974, 1635, - 1462, 1012, 973, 1006, 787, 971, 4075, 1461, 2140, 1460, - 972, 215, 1009, 1008, 1116, 2480, 3296, 776, 1110, 1111, - 778, 2319, 1501, 3144, 2473, 777, 740, 1129, 1124, 1119, - 1123, 1127, 1986, 998, 2986, 1720, 215, 2205, 175, 204, - 213, 205, 131, 1078, 1076, 1469, 776, 215, 215, 778, - 215, 211, 215, 1005, 777, 1132, 1484, 1719, 2685, 1122, - 1458, 203, 197, 196, 1975, 1305, 1715, 1727, 72, 2040, - 1984, 3187, 3188, 3725, 1081, 2932, 965, 1004, 969, 2172, - 2173, 1003, 1991, 1992, 2984, 3238, 155, 992, 2686, 1597, - 3186, 1599, 215, 66, 206, 176, 1712, 1724, 2928, 3226, - 3328, 147, 2672, 2171, 3325, 2671, 996, 4159, 2673, 211, - 1130, 1509, 2622, 2621, 3737, 1580, 215, 66, 206, 176, - 1714, 1726, 3348, 211, 2767, 211, 1072, 3728, 2061, 199, - 200, 201, 1133, 994, 2987, 3832, 1562, 1788, 3723, 1563, - 1303, 1550, 1551, 3745, 3746, 215, 4146, 1086, 4145, 3724, - 2930, 215, 66, 206, 176, 1540, 4251, 1109, 1108, 1120, - 943, 4144, 942, 944, 945, 211, 946, 947, 2952, 1298, - 2410, 1013, 2903, 2925, 1082, 1672, 1670, 4310, 2953, 3449, - 209, 1738, 4247, 1131, 1485, 1772, 3729, 1548, 1776, 211, - 4127, 1547, 1550, 1551, 147, 4286, 4287, 995, 4146, 4237, - 2038, 143, 3566, 3447, 3219, 202, 2929, 144, 4145, 4236, - 4144, 4235, 1775, 4357, 4358, 1888, 1241, 2794, 211, 215, - 66, 206, 176, 1121, 211, 4225, 3220, 2951, 3221, 2926, - 702, 702, 4130, 4131, 4132, 4133, 4228, 3997, 1084, 3566, - 1565, 702, 1234, 4225, 1235, 2323, 3074, 2189, 215, 66, - 206, 176, 4256, 4257, 2179, 4161, 3582, 1249, 1252, 1767, - 3658, 729, 729, 1259, 145, 702, 4252, 4253, 2315, 4260, - 4259, 4258, 4261, 3663, 2624, 3883, 1290, 65, 1011, 1291, - 3257, 1792, 3396, 2250, 1238, 2468, 3744, 3138, 2545, 3851, - 2631, 1013, 211, 3831, 1679, 1678, 726, 726, 726, 2320, - 1162, 3833, 2958, 2938, 1128, 2901, 3747, 1293, 1987, 4046, - 4047, 1301, 1302, 3733, 2203, 2204, 1777, 4317, 1001, 1083, - 2804, 211, 1244, 991, 3577, 3255, 215, 66, 206, 176, - 67, 1583, 1112, 1350, 2989, 3730, 3734, 3732, 3731, 1451, - 1774, 1125, 1487, 739, 1126, 2039, 1985, 1115, 1300, 1118, - 202, 2931, 1233, 2580, 4149, 4054, 3585, 3848, 3261, 2907, - 1273, 1538, 1226, 3390, 1080, 3132, 153, 212, 3804, 154, - 4285, 1226, 3213, 1227, 2927, 1249, 1252, 177, 3394, 2626, - 1234, 1226, 63, 4051, 967, 1265, 3880, 3987, 3739, 3740, - 2309, 1285, 2309, 1114, 1286, 2309, 3236, 3401, 2437, 211, - 1974, 1296, 1297, 898, 2615, 1752, 2618, 1289, 2138, 2182, - 3822, 1112, 1564, 3233, 2627, 2628, 2310, 2617, 1791, 1790, - 3845, 1382, 1288, 2342, 1152, 2688, 1115, 1152, 990, 1152, - 1152, 988, 3619, 2634, 3391, 3392, 1226, 1152, 4073, 1152, - 968, 3747, 1295, 694, 3762, 3477, 1294, 3478, 3451, 2322, - 3393, 4322, 3759, 3726, 1136, 146, 46, 1117, 3413, 3738, - 4079, 1773, 64, 4071, 2750, 3426, 5, 3475, 3476, 1079, - 4180, 1292, 1114, 4255, 1251, 1250, 4175, 2994, 3628, 3388, - 3630, 1674, 975, 3988, 731, 150, 151, 4007, 730, 152, - 1383, 779, 780, 781, 782, 783, 2480, 3142, 953, 1454, - 2475, 1456, 2326, 2328, 2329, 3752, 1222, 3335, 4166, 1229, - 1253, 725, 725, 725, 1473, 1228, 1111, 2899, 1476, 3853, - 3854, 3855, 1283, 1483, 1257, 1258, 1262, 1431, 3402, 4182, - 1436, 3850, 1346, 1347, 1348, 1349, 1721, 721, 721, 721, - 1243, 1264, 3879, 177, 727, 2808, 2139, 3446, 723, 723, - 723, 1022, 175, 204, 213, 205, 1344, 1351, 779, 780, - 781, 782, 783, 724, 724, 724, 4160, 3707, 727, 4188, - 3029, 1976, 722, 722, 722, 203, 177, 3481, 3714, 1237, - 1239, 1242, 1550, 1551, 2458, 970, 1284, 779, 780, 781, - 782, 783, 1251, 1250, 3743, 2547, 1459, 1527, 4016, 1240, - 4017, 177, 1575, 727, 1576, 1539, 1550, 1551, 2190, 702, - 67, 1579, 177, 177, 1585, 177, 4011, 177, 702, 3258, - 3397, 4248, 677, 677, 3139, 3640, 3025, 3026, 2630, 3029, - 4040, 1546, 677, 677, 67, 4080, 1622, 1622, 4072, 702, - 2957, 3867, 3402, 3637, 3360, 4016, 2614, 4017, 4048, 3763, - 1575, 4249, 1576, 3948, 832, 4397, 3075, 177, 3076, 3077, - 2592, 729, 1651, 696, 2591, 1394, 1395, 1287, 1662, 67, - 3884, 727, 3818, 2180, 4380, 1255, 2612, 2613, 1768, 1624, - 3742, 177, 2964, 232, 2033, 1607, 1629, 2688, 4018, 1525, - 1606, 2315, 677, 3639, 1263, 3452, 2560, 2961, 2962, 1524, - 727, 832, 2540, 2563, 3389, 1523, 3937, 4189, 1278, 4059, - 177, 1280, 2960, 3455, 1581, 1520, 177, 3958, 3959, 3960, - 3964, 3962, 3963, 3965, 3961, 1479, 1480, 1481, 1221, 3943, - 1488, 1489, 1490, 1491, 1492, 4018, 1494, 67, 2546, 1281, - 1542, 1541, 1500, 2548, 1704, 3318, 4274, 1584, 2583, 1709, - 1798, 1801, 1802, 4093, 1437, 1435, 1718, 3691, 2540, 3801, - 2562, 1799, 2557, 3569, 1341, 2327, 67, 3475, 3476, 1919, - 1921, 1920, 1616, 1617, 3480, 1478, 1874, 3181, 3183, 3625, - 740, 4222, 1073, 1517, 177, 1750, 1534, 1535, 1593, 1270, - 1753, 1526, 980, 3502, 1620, 1620, 2007, 2549, 1536, 1486, - 1622, 1713, 1622, 1234, 1728, 3471, 1555, 1556, 1725, 1558, - 1559, 3339, 1560, 177, 2800, 2479, 2677, 4381, 1505, 2561, - 2620, 726, 3103, 1508, 726, 726, 3410, 1529, 1533, 1533, - 1533, 1464, 1601, 1603, 3197, 3198, 2578, 1761, 2312, 1274, - 2178, 1918, 1614, 1615, 1572, 984, 1567, 1568, 1680, 1115, - 982, 981, 1529, 1529, 2155, 1554, 1115, 1475, 1557, 1683, - 1493, 1686, 1687, 1574, 2913, 1276, 2550, 3773, 1075, 1652, - 1466, 1074, 1622, 1688, 1689, 2338, 2459, 1279, 1282, 1269, - 1762, 212, 3517, 1763, 1605, 1694, 1695, 3504, 4092, 1234, - 1852, 177, 1717, 2970, 2974, 2975, 2976, 2971, 2973, 2972, - 3260, 1499, 1675, 1275, 1901, 1883, 1884, 1498, 1887, 1699, - 1630, 1574, 1703, 1787, 1702, 1978, 1902, 1636, 707, 1643, - 1497, 1663, 1496, 3126, 1649, 1087, 734, 983, 3652, 1909, - 4273, 1911, 4012, 1912, 1913, 1914, 4013, 1808, 1809, 1810, - 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1664, - 3472, 4378, 4379, 3182, 1014, 1833, 1834, 1016, 1017, 1018, - 3950, 3411, 1870, 3939, 1784, 2324, 2325, 3938, 3072, 1867, - 3944, 3945, 3616, 1869, 1866, 1868, 1872, 1873, 2556, 4012, - 1234, 1871, 2554, 4140, 1277, 2782, 1977, 3269, 3268, 1503, - 1980, 1765, 1982, 2453, 2452, 2922, 702, 702, 702, 2451, - 1472, 3570, 1781, 2551, 1910, 1996, 1998, 1803, 1999, 1731, - 2001, 2002, 2003, 1800, 1957, 696, 1651, 1886, 1994, 2010, - 1622, 2015, 2016, 1995, 2018, 1585, 702, 1470, 1471, 1736, - 1836, 702, 1739, 2144, 2142, 1022, 725, 2143, 2030, 725, - 725, 1759, 987, 3094, 3095, 1755, 3843, 3632, 1758, 1754, - 1778, 3341, 1760, 1622, 1463, 1960, 1745, 1746, 2450, 1585, - 1783, 1073, 721, 1073, 720, 721, 721, 1820, 1821, 1900, - 1993, 1831, 1832, 723, 976, 2604, 723, 723, 1757, 3104, - 3106, 3107, 3108, 3105, 2060, 2944, 977, 1824, 724, 1756, - 1968, 724, 724, 2067, 2067, 2914, 1585, 722, 1585, 1585, - 722, 722, 702, 3911, 1737, 2577, 3431, 1740, 1741, 2137, - 2945, 2946, 2376, 2010, 2148, 2375, 4393, 1622, 2152, 2153, - 2999, 4387, 1963, 2168, 2655, 677, 4375, 1891, 1892, 1893, - 1877, 1878, 1879, 1880, 1881, 1882, 1875, 1876, 2017, 677, - 1907, 1622, 4333, 1908, 4399, 4232, 1979, 1075, 2064, 1075, - 1074, 1749, 1074, 4297, 2471, 1306, 1465, 1467, 2019, 3473, - 1748, 1088, 1927, 1928, 3523, 1769, 980, 2688, 2208, 702, - 2010, 1622, 3093, 2214, 3519, 702, 702, 702, 738, 738, - 1915, 1916, 2547, 2550, 3000, 2224, 2225, 2226, 2227, 1956, - 1306, 2317, 2233, 1147, 1148, 1149, 4388, 1270, 2034, 232, - 1231, 4334, 232, 232, 2769, 232, 3655, 2146, 2092, 1958, - 4294, 4288, 2206, 1231, 4270, 1964, 1519, 4334, 1519, 979, - 2052, 2005, 2014, 2008, 982, 981, 3584, 1146, 4298, 2070, - 1143, 2231, 2021, 2022, 2023, 2024, 2059, 4216, 1770, 2062, - 2063, 4215, 2198, 2199, 1268, 1901, 1901, 2275, 2424, 2035, - 2036, 2799, 3485, 2184, 2656, 2041, 3483, 1901, 1901, 2048, - 1267, 2050, 2051, 2006, 2293, 3000, 2216, 2217, 2218, 4208, - 2175, 3371, 2177, 3333, 2470, 2057, 2351, 4183, 2044, 2045, - 2027, 2053, 2026, 2196, 2197, 4295, 2352, 2213, 2241, 4271, - 4171, 2244, 2245, 2058, 2247, 2054, 2055, 2030, 1713, 4114, - 2069, 1622, 2306, 2191, 2043, 2049, 1308, 1309, 1310, 1307, - 1529, 2286, 1306, 2277, 3331, 2065, 1306, 2071, 2072, 2151, - 2551, 4113, 4406, 726, 1533, 2546, 2540, 2545, 1112, 2543, - 2548, 1308, 1309, 1310, 1307, 2169, 1533, 2066, 2068, 1268, - 1112, 2535, 4106, 1115, 2352, 2656, 1115, 3200, 2145, 2547, - 2550, 1306, 2317, 2904, 2350, 1115, 2512, 4105, 2300, 2150, - 2656, 2789, 3523, 2156, 1432, 4172, 4104, 2774, 2308, 2174, - 2170, 2176, 2533, 1781, 4115, 2429, 2229, 2282, 2185, 3293, - 2423, 2422, 2385, 1270, 2549, 3321, 4103, 2384, 2383, 1114, - 2299, 1323, 1140, 1141, 1142, 1145, 2494, 1144, 1333, 1334, - 2201, 1114, 2154, 2833, 2212, 2211, 4083, 4082, 2219, 2220, - 2270, 4057, 1308, 1309, 1310, 1307, 4031, 2352, 1504, 1839, - 1571, 1608, 2270, 1578, 4028, 4389, 1582, 2238, 1586, 1587, - 1588, 3768, 2352, 3716, 1212, 1208, 1209, 1210, 1211, 1112, - 2838, 2352, 2837, 2836, 2834, 2335, 2336, 1308, 1309, 1310, - 1307, 2255, 3680, 4111, 1115, 1308, 1309, 1310, 1307, 3608, - 3322, 2352, 1637, 1638, 1639, 1640, 1641, 1642, 3977, 1644, - 1645, 1646, 1647, 1648, 2276, 2030, 3702, 1654, 1655, 1656, - 1657, 2317, 2317, 2285, 2283, 3604, 2352, 2551, 3204, 3002, - 978, 1306, 2546, 2540, 2545, 2511, 2543, 2548, 2297, 2494, - 1114, 3493, 3975, 3292, 2434, 2435, 2688, 2438, 3717, 2802, - 2441, 2801, 2835, 3319, 2793, 702, 1585, 702, 1585, 2519, - 2371, 2356, 2301, 3176, 2298, 2236, 2882, 3681, 2454, 2295, - 2222, 2354, 1733, 2314, 3609, 786, 2408, 1359, 725, 702, - 1308, 1309, 1310, 1307, 2870, 1254, 2409, 2411, 2412, 2413, - 2414, 2549, 702, 702, 702, 702, 2330, 2491, 1333, 1334, - 3605, 2333, 2334, 2497, 721, 1308, 1309, 1310, 1307, 2499, - 2500, 2501, 2339, 2504, 1585, 723, 3494, 2332, 1824, 821, - 831, 2417, 1218, 2862, 2331, 2815, 2344, 2797, 3320, 822, - 724, 823, 827, 830, 826, 824, 825, 3766, 2656, 722, - 1585, 2494, 2783, 2776, 1213, 702, 2296, 1622, 1308, 1309, - 1310, 1307, 2415, 2421, 2771, 1922, 1923, 1924, 1925, 1306, - 2569, 1929, 1930, 1931, 1932, 1934, 1935, 1936, 1937, 1938, - 1939, 1940, 1941, 1942, 1943, 1944, 3662, 1341, 2200, 1308, - 1309, 1310, 1307, 3427, 828, 1308, 1309, 1310, 1307, 2444, - 985, 2446, 2763, 3436, 3252, 2761, 2418, 2516, 1306, 2759, - 1306, 2518, 2494, 2520, 1515, 2757, 2498, 2493, 1516, 2425, - 2392, 2839, 2840, 2391, 2576, 2374, 4400, 2772, 2777, 829, - 1561, 2386, 2387, 2365, 2389, 702, 2067, 2416, 2364, 2772, - 4361, 2396, 2575, 2348, 2660, 2660, 2168, 2660, 2363, 1530, - 2353, 1322, 1321, 1331, 1332, 1324, 1325, 1326, 1327, 1328, - 1329, 1330, 1323, 2426, 2316, 1742, 2749, 677, 677, 1333, - 1334, 1610, 2378, 4151, 3428, 1234, 4056, 2764, 2506, 2507, - 2762, 1622, 702, 2521, 2758, 1890, 1889, 4176, 2509, 2510, - 2758, 3555, 2494, 2465, 2424, 1306, 702, 3912, 1306, 2539, - 1306, 2462, 1234, 2732, 696, 2538, 3694, 4004, 1306, 3941, - 1662, 3692, 2168, 1306, 3940, 2739, 1382, 2741, 3429, 3926, - 232, 1612, 3887, 1306, 2619, 2352, 1890, 1889, 3672, 1112, - 2508, 4177, 1613, 1515, 3524, 2514, 3515, 1516, 2515, 2317, - 1743, 3913, 3507, 2505, 1115, 3350, 788, 3495, 3405, 3135, - 3695, 2674, 2664, 2675, 2662, 3693, 2666, 3134, 2517, 2529, - 2779, 2513, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, - 1531, 2968, 2680, 2681, 2909, 1609, 1333, 1334, 2812, 2795, - 2552, 2553, 2306, 2558, 2775, 1383, 2679, 2690, 2668, 1622, - 1114, 1622, 2280, 1622, 1308, 1309, 1310, 1307, 1234, 1933, - 2279, 1533, 2278, 2076, 4234, 3558, 2814, 2075, 2822, 2744, - 1236, 2743, 2696, 957, 958, 959, 960, 2936, 2738, 1331, - 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, 2239, - 1843, 1830, 1622, 1234, 3205, 1333, 1334, 2846, 3353, 2683, - 1926, 2000, 1843, 2629, 2345, 4030, 2635, 1827, 1829, 1826, - 3353, 1828, 2853, 1308, 1309, 1310, 1307, 1622, 2669, 1667, - 4029, 2239, 2736, 1307, 2753, 3953, 2074, 1310, 1307, 957, - 958, 959, 960, 3952, 2841, 3222, 2581, 1601, 1603, 2584, - 2585, 2586, 2587, 2588, 2589, 2590, 2684, 3064, 2593, 2594, - 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2854, - 2605, 2606, 2607, 2608, 2609, 2687, 2610, 3932, 2809, 2737, - 2733, 3062, 2859, 2860, 3041, 3039, 3350, 2911, 2912, 3888, - 3889, 2915, 2826, 4396, 2826, 2787, 3352, 1905, 702, 702, - 702, 1308, 1309, 1310, 1307, 1361, 2891, 2215, 2892, 3881, - 3556, 4371, 1906, 4370, 2855, 1234, 702, 2830, 1360, 2805, - 1633, 1622, 4369, 4367, 1585, 2811, 1308, 1309, 1310, 1307, - 1585, 2148, 3666, 4366, 2806, 962, 2884, 4301, 2886, 2998, - 2888, 2889, 2844, 4269, 4268, 3004, 1153, 1154, 4178, 2934, - 2796, 1158, 3006, 2798, 2820, 2785, 4108, 2803, 4395, 4096, - 1620, 1781, 3660, 4086, 4076, 2895, 4027, 3995, 3115, 3882, - 3016, 1322, 1321, 1331, 1332, 1324, 1325, 1326, 1327, 1328, - 1329, 1330, 1323, 2985, 3113, 1620, 3915, 3111, 1234, 1333, - 1334, 962, 2819, 2816, 2817, 3914, 3038, 2842, 2832, 1308, - 1309, 1310, 1307, 1234, 1234, 1234, 2067, 3708, 2824, 1234, - 3696, 3048, 3049, 3050, 3051, 1234, 3058, 3659, 3059, 3060, - 3645, 3061, 3661, 3063, 2982, 2696, 2791, 2792, 3114, 2980, - 3395, 1115, 2995, 2896, 3058, 3248, 3017, 1326, 1327, 1328, - 1329, 1330, 1323, 3217, 3112, 3216, 2660, 3110, 3100, 1333, - 1334, 3124, 1308, 1309, 1310, 1307, 3098, 2965, 3097, 3096, - 3116, 2745, 3088, 2981, 1308, 1309, 1310, 1307, 3019, 3007, - 3285, 3082, 2852, 1668, 3081, 3080, 3079, 677, 1308, 1309, - 1310, 1307, 3005, 2905, 2092, 2148, 1667, 2765, 2676, 1234, - 2168, 2168, 2168, 2168, 2168, 2168, 2428, 2258, 3033, 2257, - 2256, 2947, 1308, 1309, 1310, 1307, 1234, 2168, 3099, 2359, - 2660, 3121, 3009, 3033, 3044, 3045, 2963, 3012, 2252, 3047, - 3036, 2251, 3020, 2014, 3036, 3054, 2988, 2207, 1622, 3184, - 8, 2997, 7, 3284, 3003, 1983, 3032, 1981, 1734, 702, - 702, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1312, 2865, - 2866, 3043, 1450, 2967, 4279, 2871, 3671, 3382, 3018, 1604, - 1308, 1309, 1310, 1307, 3015, 4049, 4050, 1216, 3021, 1308, - 1309, 1310, 1307, 3127, 4392, 3034, 2367, 4390, 4372, 3008, - 3040, 1308, 1309, 1310, 1307, 3811, 4359, 3046, 3013, 3014, - 4321, 4320, 4316, 3172, 4244, 4243, 232, 4035, 4220, 3152, - 3037, 232, 4163, 3892, 4155, 2818, 1308, 1309, 1310, 1307, - 4148, 4134, 4125, 3078, 3185, 4100, 3152, 2954, 3140, 3090, - 4095, 4094, 3271, 1901, 4053, 1901, 1215, 4039, 3232, 1322, - 1321, 1331, 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, - 1323, 3201, 4037, 2349, 3247, 4026, 2366, 1333, 1334, 3996, - 1622, 3031, 3934, 3254, 3130, 3174, 3896, 3136, 3885, 3872, - 3871, 3869, 3864, 3862, 3844, 3841, 3153, 3154, 3155, 3156, - 3157, 3158, 3227, 1308, 1309, 1310, 1307, 3839, 3169, 3838, - 3837, 3173, 4398, 3175, 3239, 3206, 3809, 3133, 3807, 3779, - 3210, 3776, 3770, 3120, 3193, 3656, 3647, 3192, 3634, 3189, - 1308, 1309, 1310, 1307, 1308, 1309, 1310, 1307, 1687, 3836, - 3617, 1960, 3596, 3594, 4347, 3835, 3231, 3588, 1688, 1689, - 1115, 1308, 1309, 1310, 1307, 3070, 3071, 3535, 3513, 1694, - 1695, 3825, 1115, 3512, 3510, 3509, 1308, 1309, 1310, 1307, - 3086, 3087, 1308, 1309, 1310, 1307, 3229, 3496, 1699, 3491, - 3490, 1703, 3406, 1702, 3369, 3363, 3354, 3240, 1308, 1309, - 1310, 1307, 3343, 3340, 3208, 3342, 3251, 3207, 702, 1585, - 3338, 2433, 3262, 3131, 3223, 3256, 3225, 3355, 3356, 3357, - 3359, 3824, 3361, 3362, 3259, 3237, 4195, 3215, 3228, 3191, - 3128, 3244, 3241, 3230, 1234, 3823, 3125, 3242, 3122, 3756, - 1234, 3109, 3101, 3091, 4191, 3385, 4087, 3089, 1308, 1309, - 1310, 1307, 3250, 3085, 3084, 3399, 3263, 3083, 2937, 2347, - 702, 2923, 1308, 1309, 1310, 1307, 1308, 1309, 1310, 1307, - 2910, 2906, 3264, 3283, 3416, 1234, 3270, 3276, 702, 3278, - 702, 1234, 1234, 3274, 3275, 898, 897, 3279, 3280, 2786, - 2168, 2491, 3277, 3435, 2455, 2442, 2439, 2261, 2254, 1971, - 1322, 1321, 1331, 1332, 1324, 1325, 1326, 1327, 1328, 1329, - 1330, 1323, 1970, 1735, 2569, 3171, 3332, 1390, 1333, 1334, - 1386, 1385, 3409, 1219, 966, 4032, 3461, 3419, 3464, 4022, - 3464, 3464, 4021, 3424, 4009, 1234, 3412, 1308, 1309, 1310, - 1307, 4005, 3346, 3336, 3372, 3870, 1311, 3840, 3337, 3819, - 3033, 3789, 3771, 3486, 1343, 3687, 3686, 3482, 1112, 3684, - 3654, 1622, 1622, 1353, 3613, 3611, 3610, 3439, 3607, 2980, - 3590, 3606, 3595, 1115, 3593, 1115, 3448, 3450, 3571, 3561, - 3560, 1115, 3387, 3546, 3545, 3033, 3374, 3437, 3373, 1362, - 3370, 3033, 3033, 3330, 3290, 3281, 3433, 1308, 1309, 1310, - 1307, 3273, 3272, 3487, 3488, 3266, 3199, 2760, 702, 2756, - 2755, 215, 3408, 206, 176, 2397, 2390, 3418, 3459, 1114, - 2382, 2381, 3385, 3422, 3423, 2380, 3430, 2379, 2377, 2373, - 3460, 3434, 2372, 2370, 2361, 1585, 2358, 2357, 2148, 2148, - 2260, 3443, 3469, 1949, 1948, 3033, 1947, 1946, 2539, 1945, - 1904, 1903, 3438, 1894, 2538, 1634, 1632, 3440, 3441, 3299, - 3300, 3465, 3466, 215, 3500, 3301, 3302, 3303, 3304, 4346, - 3305, 3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, - 3315, 3323, 3484, 3470, 211, 4339, 3294, 4300, 2166, 4214, - 1380, 1234, 4190, 4207, 3288, 2846, 4120, 4205, 3287, 3492, - 4117, 4102, 4097, 3559, 3286, 3990, 3989, 3969, 1308, 1309, - 1310, 1307, 1115, 1308, 1309, 1310, 1307, 3951, 3947, 1620, - 1620, 1308, 1309, 1310, 1307, 1308, 1309, 1310, 1307, 3442, - 3925, 1308, 1309, 1310, 1307, 3909, 211, 3467, 3790, 3787, - 3754, 3753, 3497, 3750, 3505, 3520, 3521, 3749, 3715, 4203, - 2881, 702, 3506, 4201, 2880, 701, 701, 3751, 2879, 3514, - 3712, 709, 3508, 3511, 3710, 3674, 3633, 3629, 3518, 833, - 149, 1507, 3366, 3282, 3531, 149, 3532, 1308, 1309, 1310, - 1307, 1308, 1309, 1310, 1307, 1308, 1309, 1310, 1307, 3539, - 1682, 1693, 1684, 1698, 3522, 1336, 1701, 1340, 3542, 3543, - 3544, 2696, 1690, 3163, 3123, 3117, 3042, 2991, 2990, 2983, - 3549, 2949, 2883, 1337, 1339, 1335, 3538, 1338, 1322, 1321, - 1331, 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, - 2770, 2233, 3621, 2503, 2878, 3623, 1333, 1334, 2678, 3572, - 708, 2477, 2877, 149, 2611, 2492, 2464, 2463, 3635, 3576, - 2427, 3574, 3597, 3641, 3923, 3580, 2826, 3575, 2876, 1825, - 3581, 1308, 1309, 1310, 1307, 211, 2221, 1967, 3631, 1308, - 1309, 1310, 1307, 1766, 1716, 1691, 3642, 1449, 1434, 3586, - 3599, 1430, 3601, 1429, 3603, 1308, 1309, 1310, 1307, 1428, - 1427, 1426, 702, 2148, 1661, 3636, 1425, 3638, 1424, 1423, - 1422, 3626, 1421, 1420, 3679, 2875, 1419, 3500, 1322, 1321, - 1331, 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, - 1418, 2660, 2168, 3699, 2874, 1417, 1333, 1334, 1416, 1415, - 1414, 709, 1308, 1309, 1310, 1307, 2873, 1413, 1412, 1411, - 1410, 3618, 1409, 1408, 3620, 3614, 3718, 1407, 1406, 1234, - 1405, 1308, 1309, 1310, 1307, 1115, 1404, 3651, 3461, 4337, - 2872, 1403, 1234, 1308, 1309, 1310, 1307, 1402, 1401, 3646, - 1400, 1399, 1398, 3650, 1234, 1397, 3765, 1396, 1393, 1392, - 1622, 1113, 1391, 3667, 1389, 3705, 149, 1308, 1309, 1310, - 1307, 2869, 1388, 1387, 1384, 3774, 1377, 1376, 1374, 1373, - 3669, 149, 3678, 149, 1372, 3701, 1371, 1370, 702, 1369, - 2148, 3685, 1368, 3748, 1234, 1367, 1366, 1365, 1308, 1309, - 1310, 1307, 3767, 3709, 1364, 3711, 1363, 1358, 3698, 1357, - 3697, 1356, 1355, 1115, 1354, 3704, 1321, 1331, 1332, 1324, - 1325, 1326, 1327, 1328, 1329, 1330, 1323, 232, 1272, 1217, - 3741, 2868, 1260, 1333, 1334, 3527, 3528, 4284, 3783, 3719, - 1234, 3780, 3755, 1793, 1794, 1795, 1796, 1797, 3760, 3757, - 3530, 3764, 3758, 3503, 3129, 2969, 2689, 3700, 1308, 1309, - 1310, 1307, 3795, 2263, 3054, 3161, 3703, 1513, 3769, 2867, - 1271, 3537, 132, 3775, 3777, 3772, 3160, 3778, 69, 3781, - 3792, 3166, 3784, 3782, 68, 3785, 3167, 1840, 3793, 4233, - 3842, 1844, 1845, 1846, 1847, 2861, 1308, 1309, 1310, 1307, - 2030, 1885, 2849, 3856, 3152, 3817, 3536, 2845, 3164, 1895, - 3533, 3866, 2821, 3165, 3170, 3159, 3802, 3168, 1620, 2650, - 2651, 4136, 1308, 1309, 1310, 1307, 1234, 3812, 3930, 1308, - 1309, 1310, 1307, 3813, 1308, 1309, 1310, 1307, 3791, 1308, - 1309, 1310, 1307, 704, 2784, 1234, 1622, 1622, 2773, 705, - 3152, 2077, 3416, 3246, 3863, 706, 3865, 2531, 2532, 3404, - 2579, 3852, 1950, 1951, 1952, 1953, 1954, 3904, 3578, 3579, - 3904, 1961, 3761, 3550, 3875, 2526, 2527, 2528, 3675, 3676, - 3677, 1234, 3919, 1234, 3893, 3682, 3683, 3859, 3894, 3457, - 3922, 3458, 3924, 2129, 3898, 3899, 3846, 1676, 2768, 1730, - 1622, 2810, 1115, 3868, 2449, 3901, 2448, 3066, 3877, 3876, - 1710, 2420, 2456, 3895, 3067, 3068, 3069, 3874, 702, 3886, - 1234, 1234, 1115, 2223, 1234, 1234, 2791, 2792, 2141, 3897, - 3908, 1266, 3653, 3444, 2277, 2992, 3033, 3907, 1308, 1309, - 1310, 1307, 3971, 2523, 3976, 2487, 3918, 2028, 2004, 3701, - 2419, 3966, 3797, 1115, 4350, 3748, 2037, 3928, 2030, 3955, - 3956, 3982, 4099, 3967, 3968, 3489, 3935, 2632, 3931, 1890, - 1889, 3927, 1838, 2625, 3991, 3992, 3814, 1308, 1309, 1310, - 1307, 3933, 2056, 1445, 1446, 1443, 1444, 2149, 1622, 1441, - 1442, 1787, 3741, 1787, 1439, 1440, 2638, 3834, 1570, 1308, - 1309, 1310, 1307, 1569, 1620, 1836, 3979, 1299, 2281, 3548, - 3541, 3978, 2457, 2294, 4023, 3972, 4024, 2032, 702, 3980, - 1522, 3916, 3917, 1521, 4015, 1495, 1545, 2496, 4307, 4305, - 4003, 4262, 3858, 2645, 2649, 2650, 2651, 2646, 2654, 2647, - 2652, 3998, 4230, 2648, 4229, 2653, 4227, 4002, 1961, 4167, - 4121, 3985, 3984, 1961, 1961, 4036, 3920, 4038, 1836, 4010, - 4014, 3808, 3598, 3568, 3567, 3553, 3203, 2289, 701, 1223, - 2564, 3826, 2534, 3827, 1732, 3552, 4019, 4020, 1519, 1232, - 4068, 4341, 4340, 4340, 4041, 3622, 4062, 3249, 2918, 2917, - 2916, 1231, 2360, 1453, 4042, 1256, 1234, 4341, 3949, 3794, - 1537, 77, 2, 1261, 2240, 4085, 4363, 2243, 4364, 1, - 2246, 4052, 4091, 2248, 2645, 2649, 2650, 2651, 2646, 2654, - 2647, 2652, 2897, 4060, 2648, 1965, 2653, 4063, 4065, 3817, - 1447, 4064, 4077, 957, 958, 959, 960, 961, 1231, 4081, - 1234, 956, 1598, 2670, 2202, 1622, 1620, 1626, 4112, 1969, - 963, 3177, 3178, 3540, 3180, 2924, 2313, 3141, 2623, 2467, - 3398, 3921, 1502, 1015, 4098, 149, 149, 149, 1113, 2292, - 1896, 1115, 1747, 1248, 1744, 1247, 1245, 1841, 1917, 4107, - 835, 2266, 3118, 3092, 3981, 4349, 4384, 4109, 4299, 4352, - 1764, 819, 4221, 4126, 4303, 4128, 4001, 2318, 1304, 3224, - 4147, 1045, 878, 846, 1375, 4142, 1787, 1723, 3297, 3295, - 845, 3664, 4122, 2959, 4157, 1322, 1321, 1331, 1332, 1324, - 1325, 1326, 1327, 1328, 1329, 1330, 1323, 3986, 3196, 4070, - 4152, 3973, 4153, 1333, 1334, 3974, 1046, 2249, 4123, 3999, - 1677, 1681, 2522, 4078, 4168, 4186, 3929, 1342, 3453, 3028, - 1705, 4181, 3713, 3830, 3828, 3829, 746, 4154, 2181, 675, - 1097, 3970, 2262, 2502, 4250, 4101, 4162, 999, 3648, 2476, - 1000, 4170, 4185, 1234, 993, 2978, 2341, 2977, 1804, 1313, - 2346, 1622, 4210, 1823, 3316, 3317, 4211, 1352, 2355, 790, - 2343, 4218, 4200, 4202, 4204, 4206, 2956, 4184, 3736, 3190, - 4179, 76, 4193, 1620, 75, 4219, 74, 73, 240, 837, - 239, 4033, 4199, 3890, 4217, 4354, 816, 815, 814, 813, - 812, 811, 2643, 4209, 2644, 2362, 2642, 2640, 2639, 2163, - 2162, 4226, 3202, 2369, 4224, 3551, 1308, 1309, 1310, 1307, - 1622, 2228, 2230, 4068, 4238, 4240, 3414, 3057, 4245, 3052, - 2081, 4242, 4239, 4241, 2079, 1589, 2559, 2566, 2078, 4272, - 4281, 2388, 3587, 3820, 4196, 4280, 2393, 2394, 2395, 4263, - 4197, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, - 2407, 4265, 4264, 3946, 3102, 4266, 4267, 3816, 4118, 4119, - 2525, 2555, 2098, 3073, 2095, 2094, 4296, 3065, 3942, 3936, - 4289, 2126, 4290, 4066, 4291, 1438, 4292, 3903, 4293, 3720, - 3721, 4306, 3727, 4308, 4309, 2486, 1167, 1163, 1874, 1165, - 4304, 4302, 1166, 215, 66, 206, 176, 1164, 4142, 4312, - 2831, 3516, 2536, 1234, 3376, 2943, 4313, 4315, 4314, 1620, - 2942, 2940, 207, 2939, 4110, 1482, 4156, 1577, 4246, 198, - 3873, 2694, 2692, 208, 4329, 4091, 1591, 1214, 3529, 3525, - 3347, 4332, 4331, 4330, 2274, 4335, 3534, 3162, 4338, 4348, - 4336, 4356, 147, 2290, 4355, 3245, 2164, 1628, 4342, 4343, - 4344, 4345, 2160, 2159, 1138, 1137, 1658, 133, 3627, 45, - 3143, 4360, 2633, 4368, 4158, 4044, 211, 2530, 1620, 1234, - 1573, 2474, 111, 41, 127, 110, 193, 60, 4373, 192, - 4374, 59, 125, 4376, 4185, 190, 58, 105, 104, 4382, - 124, 188, 4386, 57, 224, 223, 226, 225, 4383, 222, - 2746, 2747, 4169, 3291, 221, 1665, 220, 4173, 4174, 4231, - 3906, 4213, 951, 4327, 44, 43, 194, 42, 112, 61, - 4394, 40, 39, 2495, 3364, 2031, 3643, 2935, 2460, 4356, - 4402, 1631, 4355, 4401, 38, 708, 34, 13, 4194, 12, - 35, 4386, 4403, 22, 21, 156, 157, 4407, 158, 159, - 1751, 20, 1033, 160, 26, 32, 161, 1322, 1321, 1331, - 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, 31, - 142, 141, 149, 30, 1870, 1333, 1334, 140, 139, 1787, - 138, 1867, 1961, 137, 1961, 1869, 1866, 1868, 1872, 1873, - 136, 135, 134, 1871, 29, 19, 52, 51, 50, 49, - 48, 47, 9, 1961, 1961, 130, 128, 123, 121, 28, - 122, 119, 120, 115, 114, 113, 108, 106, 88, 175, - 204, 213, 205, 131, 1029, 1030, 87, 86, 101, 100, - 99, 98, 97, 96, 94, 1073, 1661, 95, 1044, 85, - 149, 84, 203, 197, 196, 83, 82, 149, 81, 72, - 116, 103, 109, 107, 92, 102, 93, 91, 90, 89, - 149, 80, 79, 149, 149, 78, 118, 155, 117, 129, - 195, 62, 174, 173, 172, 171, 149, 170, 168, 169, - 167, 166, 165, 164, 163, 2778, 162, 2781, 53, 54, - 4318, 4319, 55, 56, 184, 183, 185, 4323, 4324, 4325, - 4326, 187, 189, 186, 191, 181, 179, 182, 180, 178, - 199, 200, 201, 71, 11, 126, 18, 4, 0, 0, - 0, 1075, 0, 0, 1074, 0, 0, 0, 0, 0, - 0, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, - 1864, 1865, 1877, 1878, 1879, 1880, 1881, 1882, 1875, 1876, - 0, 0, 2823, 0, 0, 2829, 0, 0, 0, 0, - 0, 209, 0, 1059, 0, 0, 2847, 2848, 0, 0, - 0, 0, 1034, 0, 2850, 2851, 0, 0, 0, 0, - 0, 0, 143, 0, 2340, 0, 202, 0, 144, 0, - 2856, 2857, 2858, 0, 0, 0, 0, 0, 0, 1036, - 0, 0, 0, 0, 1988, 1989, 1990, 0, 1322, 1321, - 1331, 1332, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1323, - 0, 0, 0, 2885, 0, 2887, 1333, 1334, 2890, 0, - 1793, 1961, 0, 0, 2020, 0, 0, 0, 0, 2025, - 0, 0, 0, 0, 0, 145, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 65, 758, - 757, 764, 754, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 761, 762, 0, 763, 767, 1058, 1056, 748, - 0, 0, 0, 0, 2127, 0, 0, 0, 0, 772, - 0, 215, 758, 757, 764, 754, 0, 0, 0, 0, - 0, 0, 0, 0, 1055, 761, 762, 0, 763, 767, - 2073, 67, 748, 0, 3902, 0, 1028, 0, 3010, 3011, - 2129, 0, 772, 0, 0, 0, 0, 1035, 1068, 0, - 0, 0, 0, 0, 0, 776, 0, 0, 778, 0, - 0, 0, 0, 777, 0, 0, 0, 153, 212, 0, - 154, 1064, 0, 0, 0, 0, 0, 0, 177, 0, - 0, 0, 0, 63, 211, 0, 0, 0, 776, 0, - 0, 778, 0, 0, 2104, 0, 777, 2210, 0, 0, - 0, 0, 0, 2210, 2210, 2210, 0, 1065, 1069, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1052, 0, 1050, - 1054, 1072, 2167, 0, 0, 1051, 1048, 1047, 0, 1053, - 1038, 1039, 1037, 0, 1027, 1040, 1041, 1042, 1043, 1024, - 0, 0, 1070, 0, 1071, 0, 146, 46, 0, 0, - 0, 0, 0, 64, 2120, 1066, 1067, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 150, 151, 0, 0, - 152, 0, 0, 0, 0, 1961, 0, 0, 0, 0, - 0, 0, 0, 1062, 0, 749, 751, 750, 149, 1061, - 0, 149, 149, 1025, 149, 0, 756, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1057, 760, 0, - 0, 0, 0, 0, 0, 775, 0, 0, 749, 751, - 750, 0, 753, 0, 0, 0, 743, 0, 2108, 756, - 0, 0, 0, 0, 1113, 0, 0, 149, 0, 2114, - 0, 760, 0, 0, 0, 0, 1113, 0, 775, 0, - 0, 0, 0, 0, 0, 753, 3209, 0, 3211, 2102, - 2136, 0, 149, 2103, 2105, 2107, 0, 2109, 2110, 2111, - 2115, 2116, 2117, 2119, 2122, 2123, 2124, 1961, 0, 0, - 0, 0, 1961, 0, 2112, 2121, 2113, 0, 0, 0, - 0, 0, 1060, 0, 0, 0, 2292, 0, 1031, 1032, - 0, 1023, 0, 0, 0, 0, 1026, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1186, 0, 0, 0, 0, 0, 0, 0, - 0, 3265, 0, 2128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1342, 0, 0, 0, 0, - 0, 0, 755, 759, 765, 0, 766, 768, 0, 3289, - 769, 770, 771, 0, 0, 773, 774, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2125, 0, 755, 759, 765, 0, 766, - 768, 0, 2127, 769, 770, 771, 0, 2088, 773, 774, - 2101, 0, 0, 0, 0, 0, 0, 2100, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2443, 0, 2445, 0, 0, 2129, 2097, - 0, 2118, 0, 0, 0, 0, 0, 0, 2130, 2131, - 2106, 0, 0, 0, 0, 0, 1171, 2466, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2482, 2483, 2484, 2485, 2096, 0, 0, 0, 0, 1194, - 1198, 1200, 1202, 1204, 1205, 1207, 0, 1212, 1208, 1209, - 1210, 1211, 2104, 1189, 1190, 1191, 1192, 1169, 1170, 1195, - 0, 1172, 0, 1174, 1175, 1176, 1177, 1173, 1178, 1179, - 1180, 1181, 1182, 1185, 1187, 1183, 1184, 1193, 0, 0, - 0, 0, 0, 2524, 0, 1197, 1199, 1201, 1203, 1206, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 752, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3468, - 0, 0, 2120, 0, 0, 1188, 177, 0, 0, 0, + 818, 3044, 794, 820, 4399, 4367, 232, 4391, 1714, 2097, + 4290, 1793, 3720, 3824, 4296, 3493, 4289, 4297, 4201, 4178, + 4103, 3459, 2748, 803, 4152, 4237, 3363, 3578, 3971, 3749, + 4081, 3038, 4048, 796, 1385, 1855, 3365, 4102, 4179, 3905, + 1550, 4007, 4143, 848, 3579, 1237, 2947, 677, 3041, 3829, + 4072, 219, 3, 4153, 3679, 4155, 3819, 2036, 1106, 3684, + 1556, 3468, 1842, 3924, 1231, 696, 3015, 702, 702, 3914, + 1789, 2548, 1796, 702, 720, 729, 3736, 3391, 729, 1525, + 3429, 3919, 1625, 3702, 3576, 3414, 2202, 3638, 2878, 3164, + 217, 148, 3165, 3163, 2216, 3417, 2199, 3671, 70, 792, + 3133, 3067, 3488, 3470, 747, 3160, 3704, 2164, 3512, 37, + 3477, 2664, 2239, 2955, 3629, 742, 2314, 2839, 1860, 3561, + 2271, 3232, 2700, 3193, 2551, 3540, 2980, 3397, 2054, 3395, + 3476, 1618, 3381, 3392, 738, 3394, 3393, 2497, 1227, 36, + 2993, 3151, 3439, 2702, 2439, 791, 786, 3348, 3389, 2438, + 1513, 2298, 2804, 3281, 1966, 2780, 2272, 2244, 2280, 2279, + 2762, 986, 1736, 2665, 2309, 1857, 1704, 1703, 1707, 2310, + 2168, 1699, 2195, 2648, 2165, 2969, 2964, 3069, 1022, 2643, + 3049, 2549, 2087, 726, 6, 3007, 1692, 228, 8, 1559, + 227, 7, 2496, 2020, 2698, 1856, 2485, 2311, 1168, 2344, + 795, 1484, 793, 1787, 1603, 1666, 695, 1634, 677, 1597, + 2295, 2476, 2544, 785, 1539, 1849, 2053, 2479, 1829, 1778, + 1253, 1715, 2278, 804, 2275, 1718, 2260, 735, 2016, 714, + 1792, 1786, 232, 1099, 232, 1673, 1159, 1160, 1602, 2672, + 1021, 2019, 711, 702, 2644, 1599, 1535, 952, 1521, 218, + 1657, 744, 1139, 1861, 1560, 745, 1551, 214, 27, 1464, + 210, 1019, 1063, 1002, 728, 16, 1077, 24, 25, 1440, + 17, 10, 1049, 14, 23, 1386, 741, 954, 955, 2318, + 698, 4164, 1100, 1315, 1316, 1317, 1314, 1156, 2581, 215, + 66, 206, 176, 1315, 1316, 1317, 1314, 4069, 1315, 1316, + 1317, 1314, 2922, 1112, 2922, 2922, 15, 2674, 207, 3716, + 1115, 3587, 2877, 3446, 3249, 198, 33, 3248, 2328, 208, + 1232, 3875, 1155, 3687, 1157, 1233, 3571, 2827, 2768, 676, + 2766, 707, 725, 2765, 2763, 1979, 1676, 1680, 147, 721, + 1151, 1152, 733, 216, 697, 2437, 1459, 723, 703, 1601, + 997, 1114, 974, 133, 4130, 1517, 1518, 1519, 972, 1426, + 2749, 3358, 211, 1152, 1010, 2443, 1007, 1152, 787, 1729, + 215, 66, 206, 176, 1980, 2447, 1462, 3341, 3343, 3338, + 724, 3340, 1232, 4379, 1573, 5, 2914, 2912, 1973, 207, + 722, 1455, 3817, 3228, 1678, 3226, 198, 2249, 4138, 4014, + 208, 1150, 4008, 3820, 8, 3577, 2294, 7, 1315, 1316, + 1317, 1314, 1315, 1316, 1317, 1314, 1380, 4157, 2274, 147, + 953, 2802, 3312, 3379, 989, 2266, 2589, 4405, 4151, 4376, + 2916, 964, 4022, 4088, 133, 3835, 4325, 1313, 4059, 1475, + 215, 156, 157, 211, 158, 159, 1277, 215, 4268, 160, + 2623, 3892, 161, 2813, 2821, 2315, 3703, 3257, 2488, 1713, + 4149, 4057, 3663, 973, 2857, 4020, 1722, 787, 2454, 971, + 4212, 3658, 3382, 2190, 1465, 2468, 1642, 4089, 1469, 2147, + 3863, 1468, 1467, 974, 972, 1134, 1116, 215, 1110, 1111, + 740, 3310, 215, 215, 3861, 776, 1719, 215, 778, 1012, + 1491, 1006, 1085, 777, 1476, 1727, 1734, 2326, 1508, 3158, + 1009, 1008, 2047, 211, 2480, 175, 204, 213, 205, 131, + 1721, 1982, 156, 157, 2692, 158, 159, 1726, 1312, 776, + 160, 998, 778, 161, 2693, 1993, 1731, 777, 203, 197, + 196, 3252, 3240, 3200, 1569, 72, 147, 1570, 965, 2178, + 4173, 1005, 1991, 776, 1516, 2946, 778, 3201, 3202, 1135, + 1733, 777, 2212, 155, 2629, 211, 211, 2179, 2180, 1604, + 211, 1606, 2942, 3362, 3342, 1004, 3339, 2628, 215, 1003, + 943, 1547, 942, 944, 945, 992, 946, 947, 1998, 1999, + 215, 66, 206, 176, 2781, 3463, 175, 204, 213, 205, + 131, 1557, 1558, 4160, 996, 1072, 199, 200, 201, 2679, + 969, 2068, 2678, 4265, 1795, 2680, 3846, 1310, 1555, 203, + 197, 196, 1554, 1557, 1558, 1109, 72, 147, 1492, 1779, + 2944, 994, 1783, 1305, 1129, 1124, 1119, 1123, 1127, 4300, + 4301, 215, 2917, 2045, 155, 2487, 3461, 2939, 1572, 1108, + 4159, 211, 1078, 1076, 1679, 1677, 1782, 209, 4160, 4251, + 1587, 2966, 1132, 211, 3000, 4158, 1122, 4159, 4250, 1013, + 2417, 2967, 215, 66, 206, 176, 4158, 4249, 143, 4261, + 4141, 4324, 202, 1081, 144, 1895, 2943, 199, 200, 201, + 4371, 4372, 3233, 4242, 4239, 995, 215, 66, 206, 176, + 702, 702, 3234, 2940, 3235, 215, 66, 206, 176, 4270, + 4271, 702, 1241, 4011, 2998, 3580, 3580, 1130, 2808, 4239, + 2965, 1242, 2330, 4266, 4267, 2196, 4274, 4273, 4272, 4275, + 2972, 729, 729, 1266, 4175, 702, 3596, 3088, 209, 1133, + 3408, 145, 2186, 1799, 3677, 211, 4144, 4145, 4146, 4147, + 1256, 1259, 1774, 2638, 65, 3672, 1086, 2322, 2257, 143, + 1784, 1248, 3410, 202, 3001, 144, 1120, 3152, 2631, 211, + 1745, 3897, 2475, 3271, 3845, 2915, 1011, 739, 211, 2952, + 4060, 4061, 3847, 1082, 1781, 2327, 1494, 1545, 2046, 1013, + 1131, 1686, 1685, 3761, 4331, 1590, 3405, 3406, 2818, 215, + 66, 206, 176, 1357, 1458, 3591, 3865, 67, 1256, 1259, + 1112, 1994, 3407, 4163, 4299, 2587, 1001, 1115, 3269, 1162, + 1571, 991, 145, 1308, 1309, 726, 726, 726, 1992, 4068, + 1121, 2945, 1307, 1280, 3599, 65, 3275, 2921, 202, 2210, + 2211, 1233, 1234, 153, 212, 1233, 154, 1084, 2941, 3818, + 1241, 3227, 1233, 4001, 177, 1272, 2634, 2635, 1114, 63, + 3146, 2633, 2316, 3250, 1245, 1303, 1304, 2444, 4065, 2316, + 3894, 2316, 211, 3247, 3862, 3836, 1981, 1240, 2349, 2145, + 1798, 1797, 2695, 1389, 3859, 2317, 4336, 1292, 67, 1112, + 1293, 3404, 2189, 1152, 3633, 1152, 1115, 1152, 2641, 2622, + 1152, 2625, 1251, 1152, 3415, 1780, 1302, 1152, 694, 4087, + 1297, 1128, 2624, 1298, 1233, 3776, 967, 3465, 1295, 2329, + 3427, 2333, 2335, 2336, 153, 212, 990, 154, 1083, 988, + 4269, 3773, 146, 46, 3491, 177, 3492, 1114, 4093, 64, + 63, 1300, 3440, 5, 4194, 1244, 1246, 1249, 1125, 4189, + 2764, 1126, 4002, 4085, 1681, 3008, 1118, 3489, 3490, 1805, + 1808, 1809, 150, 151, 3003, 4021, 152, 1258, 1257, 1461, + 1806, 1463, 968, 1080, 725, 725, 725, 953, 1236, 3642, + 1229, 721, 721, 721, 1480, 1235, 1111, 2913, 1483, 723, + 723, 723, 1269, 1490, 1260, 1264, 1265, 1438, 1557, 1558, + 1443, 1353, 1354, 1355, 1356, 177, 1728, 3402, 3893, 4174, + 1466, 2822, 177, 146, 46, 1390, 1271, 2146, 1290, 1351, + 64, 1022, 724, 724, 724, 1258, 1257, 3644, 1983, 1358, + 975, 1546, 722, 722, 722, 3416, 779, 780, 781, 782, + 783, 1296, 727, 150, 151, 731, 2487, 152, 3864, 1557, + 1558, 730, 177, 3156, 2482, 4196, 3766, 177, 177, 2567, + 3349, 1136, 177, 4180, 1117, 2547, 2570, 3721, 2971, 4202, + 779, 780, 781, 782, 783, 3867, 3868, 3869, 1079, 702, + 1301, 1586, 1291, 4030, 1592, 4031, 2197, 3460, 702, 1553, + 3043, 2637, 677, 677, 779, 780, 781, 782, 783, 3416, + 3411, 4025, 677, 677, 3153, 1299, 1629, 1629, 67, 702, + 3728, 1527, 3272, 4094, 2465, 1534, 4054, 970, 4262, 4062, + 1250, 2554, 2557, 2569, 727, 2975, 2976, 4030, 4086, 4031, + 1471, 729, 1658, 696, 3495, 3881, 1401, 1402, 1669, 832, + 2974, 3654, 3651, 177, 1247, 3374, 2554, 3089, 727, 3090, + 3091, 2621, 3777, 232, 2322, 177, 1636, 727, 4263, 3962, + 2599, 2187, 677, 1294, 3466, 4394, 3898, 3039, 3040, 1473, + 3043, 1775, 4411, 4032, 2598, 3832, 1627, 1627, 1262, 2619, + 2620, 2695, 2568, 832, 2334, 3957, 1588, 2978, 2040, 1631, + 67, 1486, 1487, 1488, 1614, 1613, 1495, 1496, 1497, 1498, + 1499, 3951, 1501, 1582, 1270, 1583, 177, 1532, 1507, 3653, + 1549, 1548, 1591, 1444, 67, 1531, 1530, 4032, 4203, 4107, + 4288, 1711, 1807, 67, 1442, 4073, 1716, 3469, 1228, 1582, + 3332, 1583, 3403, 1725, 2590, 1623, 1624, 177, 3972, 3973, + 3974, 3978, 3976, 3977, 3979, 3975, 3489, 3490, 3705, 2547, + 3815, 727, 1485, 1926, 1928, 1927, 2564, 1541, 1542, 2558, + 1493, 177, 1757, 4236, 2553, 2547, 2552, 1760, 2550, 2555, + 177, 740, 3639, 3195, 3197, 1600, 3516, 1629, 1524, 1629, + 1241, 1735, 1512, 1515, 3485, 1348, 1533, 980, 3583, 2553, + 3353, 2814, 3117, 1543, 2555, 1536, 1540, 1540, 1540, 1277, + 2684, 1562, 1563, 2557, 1565, 1566, 2627, 1567, 4395, 2585, + 2319, 2185, 1574, 1575, 2162, 1482, 1500, 67, 3787, 3531, + 1536, 1536, 3518, 2556, 1561, 1925, 1115, 1564, 3211, 3212, + 3274, 3494, 2927, 1115, 1985, 1687, 1506, 1720, 3666, 1659, + 984, 1505, 1504, 1503, 1732, 982, 981, 1087, 2556, 1629, + 1612, 734, 3140, 1470, 4106, 1014, 1690, 726, 1693, 1694, + 726, 726, 1701, 1702, 177, 2486, 1241, 1859, 1724, 1637, + 1695, 1696, 3486, 1768, 1608, 1610, 707, 1643, 3964, 1890, + 1891, 1908, 1894, 1706, 1621, 1622, 1710, 1709, 1650, 1276, + 1909, 1670, 1016, 1017, 1018, 1656, 2345, 2014, 2331, 2332, + 3086, 3630, 1671, 1916, 4287, 1918, 2466, 1919, 1920, 1921, + 2984, 2988, 2989, 2990, 2985, 2987, 2986, 4026, 2796, 1843, + 1510, 4027, 983, 1579, 3283, 3282, 3958, 3959, 1815, 1816, + 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, + 2558, 2936, 4392, 4393, 1682, 1794, 1840, 1841, 1791, 3196, + 2151, 2149, 2460, 2459, 2150, 1472, 1474, 1241, 3953, 3108, + 3109, 4026, 3952, 1984, 1581, 4154, 1810, 1987, 1772, 1989, + 1073, 2458, 2563, 702, 702, 702, 2561, 1744, 1479, 1964, + 1747, 1748, 2003, 2005, 2001, 2006, 2002, 2008, 2009, 2010, + 1581, 1893, 696, 1658, 1738, 1917, 2017, 1629, 2022, 2023, + 987, 2025, 1592, 702, 1477, 1478, 725, 1788, 702, 725, + 725, 3857, 1022, 721, 3424, 2037, 721, 721, 3646, 3355, + 1743, 723, 1767, 1746, 723, 723, 3584, 1785, 1967, 1764, + 1629, 1766, 1762, 1790, 1765, 1761, 1592, 1763, 1073, 1907, + 1073, 720, 2457, 1827, 1828, 2000, 976, 1838, 1839, 3118, + 3120, 3121, 3122, 3119, 724, 2611, 1075, 724, 724, 1074, + 977, 2067, 1088, 2928, 722, 1986, 1831, 722, 722, 3925, + 2074, 2074, 3013, 1592, 1526, 1592, 1592, 1752, 1753, 702, + 1285, 3487, 2584, 1287, 2478, 4407, 2144, 1238, 3107, 2383, + 2017, 2155, 2382, 4401, 1629, 2159, 2160, 1898, 1899, 1900, + 2175, 2041, 677, 4389, 4413, 1970, 1238, 1881, 4347, 2662, + 1914, 1288, 2958, 1915, 4311, 2024, 677, 4308, 1629, 1526, + 4302, 3445, 1975, 2059, 1075, 2071, 1075, 1074, 4284, 1074, + 2026, 1776, 1934, 1935, 4230, 980, 4420, 2959, 2960, 2066, + 4246, 2238, 2069, 2070, 4229, 2215, 702, 2017, 1629, 3425, + 2221, 1313, 702, 702, 702, 738, 738, 1922, 1923, 1963, + 2324, 4222, 2231, 2232, 2233, 2234, 2099, 1313, 4402, 2240, + 3537, 2695, 1756, 3533, 1277, 2783, 232, 2213, 4348, 232, + 232, 1755, 232, 4348, 2153, 1777, 3335, 1965, 979, 4312, + 4197, 3669, 4309, 982, 981, 2359, 2015, 3598, 2012, 3014, + 1971, 2077, 2431, 4285, 2477, 2028, 2029, 2030, 2031, 1313, + 1275, 1281, 2813, 1315, 1316, 1317, 1314, 3014, 2663, 1313, + 2205, 2206, 1908, 1908, 2282, 2042, 2043, 2021, 4185, 2055, + 2191, 2057, 2058, 3499, 1908, 1908, 2359, 1283, 1313, 2663, + 2182, 2300, 2184, 2013, 4128, 2064, 2223, 2224, 2225, 1286, + 1289, 4127, 2034, 2203, 2204, 2033, 3497, 1439, 4120, 2060, + 2048, 3336, 3385, 3537, 2220, 2324, 2248, 3347, 3345, 2251, + 2252, 2065, 2254, 2076, 2037, 1282, 2293, 2050, 1629, 2313, + 2051, 2052, 2663, 2056, 3214, 1536, 2236, 2198, 2918, 2803, + 2284, 2078, 2079, 1877, 2788, 1274, 4119, 2061, 2062, 1540, + 1874, 2554, 2557, 4186, 1876, 1873, 1875, 1879, 1880, 2315, + 4118, 1540, 1878, 1112, 2073, 2075, 4117, 2072, 2152, 4129, + 1115, 2177, 2540, 1115, 2158, 1112, 2501, 4097, 821, 831, + 1277, 2307, 1115, 2359, 1720, 2157, 2436, 2358, 822, 2163, + 823, 827, 830, 826, 824, 825, 2181, 4096, 2183, 2192, + 2430, 4403, 2289, 2429, 1578, 4071, 1284, 1585, 2392, 726, + 1589, 1114, 1593, 1594, 1595, 2391, 2390, 1315, 1316, 1317, + 1314, 2359, 2306, 1114, 1275, 2218, 4045, 2208, 1788, 2219, + 2277, 2161, 2226, 2227, 2176, 2359, 1147, 1148, 1149, 1511, + 1846, 2359, 2277, 828, 4042, 3782, 1644, 1645, 1646, 1647, + 1648, 1649, 2324, 1651, 1652, 1653, 1654, 1655, 2245, 1330, + 3730, 1661, 1662, 1663, 1664, 2357, 1340, 1341, 1615, 4125, + 1146, 3676, 2324, 1143, 1112, 2262, 3333, 3694, 829, 3622, + 2359, 1115, 1315, 1316, 1317, 1314, 2342, 2343, 3991, 2558, + 215, 66, 206, 176, 2553, 2547, 2552, 2424, 2550, 2555, + 2283, 1313, 2037, 1315, 1316, 1317, 1314, 2292, 2290, 3716, + 2542, 1884, 1885, 1886, 1887, 1888, 1889, 1882, 1883, 2501, + 2695, 2304, 1114, 3218, 1315, 1316, 1317, 1314, 3618, 2303, + 3307, 2441, 2442, 3507, 2445, 3731, 3016, 2448, 1315, 1316, + 1317, 1314, 702, 1592, 702, 1592, 2308, 3190, 2896, 2884, + 2876, 3334, 3695, 2556, 3623, 2461, 2829, 2816, 725, 2415, + 2321, 2815, 786, 211, 3989, 721, 702, 898, 2807, 1759, + 2302, 2811, 2425, 723, 2526, 2361, 2378, 2363, 2847, 702, + 702, 702, 702, 3780, 2498, 2337, 3306, 2340, 2341, 2346, + 2504, 2416, 2418, 2419, 2420, 2421, 2506, 2507, 2508, 2797, + 2511, 1592, 2339, 3619, 2338, 2305, 724, 1831, 3508, 1219, + 1215, 1216, 1217, 1218, 2351, 2852, 722, 2851, 2850, 2848, + 2243, 2790, 2663, 2501, 1313, 1313, 2229, 1592, 2785, 1740, + 2777, 1313, 702, 1366, 1629, 1140, 1141, 1142, 1145, 2775, + 1144, 1261, 1929, 1930, 1931, 1932, 2501, 2576, 1936, 1937, + 1938, 1939, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, + 1949, 1950, 1951, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1330, 2451, 1225, 2453, 2786, 2773, 2519, 1340, 1341, 2771, + 1220, 2513, 2514, 1348, 2523, 2500, 2432, 2849, 2525, 2399, + 2527, 2516, 2517, 2207, 4414, 2505, 2791, 2398, 3450, 2422, + 978, 2393, 2394, 2786, 2396, 2778, 1340, 1341, 2583, 2381, + 3266, 2403, 702, 2074, 2776, 2372, 175, 204, 213, 205, + 2371, 2667, 2667, 2175, 2667, 4375, 1315, 1316, 1317, 1314, + 1617, 2370, 2433, 2582, 2360, 1315, 1316, 1317, 1314, 203, + 1315, 1316, 1317, 1314, 677, 677, 957, 958, 959, 960, + 2772, 2323, 1241, 1537, 2772, 2528, 2763, 1749, 1629, 702, + 2501, 2431, 4165, 4190, 1313, 4070, 2472, 1315, 1316, 1317, + 1314, 4018, 1313, 702, 2423, 2469, 2546, 2545, 3926, 1241, + 2746, 696, 788, 2428, 1313, 1389, 3955, 1669, 2355, 2175, + 1313, 3441, 2753, 3954, 2755, 1313, 1568, 232, 1897, 1896, + 2515, 1897, 1896, 2626, 3708, 2521, 1313, 4191, 2522, 2359, + 3940, 3901, 1619, 3686, 1112, 2518, 1522, 2512, 3538, 3529, + 1523, 1115, 3927, 1620, 3521, 3706, 2324, 1640, 2690, 2681, + 2671, 2682, 1750, 2669, 1616, 2673, 2524, 2793, 3509, 3419, + 1333, 1334, 1335, 1336, 1337, 1330, 2853, 2854, 3709, 3149, + 2687, 2688, 1340, 1341, 2559, 2560, 2809, 2565, 2675, 2313, + 985, 3148, 1114, 2520, 2536, 2750, 1629, 2697, 1629, 3707, + 1629, 2982, 3442, 1837, 1538, 1241, 1540, 2923, 957, 958, + 959, 960, 2826, 2828, 2789, 2686, 2287, 2758, 2286, 1834, + 1836, 1833, 2285, 1835, 2083, 2082, 2752, 1243, 962, 1522, + 3569, 2836, 2757, 1523, 1850, 2246, 2352, 2081, 3367, 1629, + 1241, 1674, 1940, 2246, 2860, 1933, 3443, 1390, 3364, 2636, + 2950, 2642, 1315, 1316, 1317, 1314, 1850, 3219, 2007, 2867, + 1317, 1314, 2676, 3572, 1629, 3367, 4248, 4044, 2819, 4043, + 3285, 1314, 3967, 2588, 2703, 3966, 2591, 2592, 2593, 2594, + 2595, 2596, 2597, 3236, 3078, 2600, 2601, 2602, 2603, 2604, + 2605, 2606, 2607, 2608, 2609, 2610, 2691, 2612, 2613, 2614, + 2615, 2616, 3076, 2617, 2694, 3055, 3053, 4410, 2222, 1627, + 3946, 4385, 1315, 1316, 1317, 1314, 3364, 2747, 2981, 2873, + 2874, 2855, 2751, 2767, 2925, 2926, 2805, 2806, 2929, 4384, + 1315, 1316, 1317, 1314, 1627, 702, 702, 702, 2801, 3570, + 3895, 3366, 1153, 1154, 3902, 3903, 2868, 1158, 1315, 1316, + 1317, 1314, 1241, 702, 2844, 4383, 1608, 1610, 1629, 2825, + 962, 1592, 3674, 3129, 2820, 2869, 1368, 1592, 2155, 2905, + 2823, 2906, 4409, 2834, 1769, 212, 3012, 1770, 2840, 1367, + 2840, 4381, 3018, 4380, 2799, 177, 2812, 2810, 4315, 3020, + 3680, 2898, 4283, 2900, 2858, 2902, 2903, 3127, 2909, 2817, + 3896, 4282, 1315, 1316, 1317, 1314, 4192, 3030, 1321, 1322, + 1323, 1324, 1325, 1326, 1327, 1319, 1315, 1316, 1317, 1314, + 2830, 2831, 3675, 3128, 1674, 1241, 1788, 2948, 2833, 1315, + 1316, 1317, 1314, 3052, 3125, 2856, 2846, 4122, 2838, 3114, + 1241, 1241, 1241, 2074, 1912, 4110, 1241, 2994, 3062, 3063, + 3064, 3065, 1241, 3072, 4100, 3073, 3074, 3126, 3075, 1913, + 3077, 2996, 4090, 1315, 1316, 1317, 1314, 4041, 1115, 4009, + 3929, 3072, 2759, 3031, 3928, 3023, 2910, 3722, 3710, 2999, + 3026, 4293, 3673, 2667, 1315, 1316, 1317, 1314, 3659, 2979, + 3299, 3409, 3045, 1675, 3124, 2995, 3685, 3130, 3262, 3113, + 3231, 2374, 2099, 3230, 3138, 3112, 3021, 3111, 1315, 1316, + 1317, 1314, 3110, 3102, 677, 3096, 3095, 2703, 3009, 3094, + 3093, 2866, 2155, 3019, 2919, 2779, 1241, 2175, 2175, 2175, + 2175, 2175, 2175, 1338, 1339, 1331, 1332, 1333, 1334, 1335, + 1336, 1337, 1330, 1241, 2175, 2683, 2961, 2667, 3135, 1340, + 1341, 2977, 2435, 3298, 3033, 3050, 2265, 3853, 3046, 3050, + 2264, 2263, 3034, 3198, 3017, 1629, 3002, 8, 3011, 2259, + 7, 2373, 1223, 3057, 2258, 2214, 702, 702, 1990, 1988, + 1315, 1316, 1317, 1314, 1315, 1316, 1317, 1314, 2021, 1741, + 3047, 2879, 2880, 1457, 3029, 3032, 3850, 2885, 1315, 1316, + 1317, 1314, 3396, 3035, 4406, 3047, 3058, 3059, 3849, 4404, + 3048, 3061, 3141, 4412, 4386, 3054, 3825, 3068, 1315, 1316, + 1317, 1314, 3060, 1315, 1316, 1317, 1314, 1315, 1316, 1317, + 1314, 1222, 3186, 3051, 4373, 1315, 1316, 1317, 1314, 4335, + 232, 3022, 4063, 4064, 2968, 232, 3104, 3839, 3092, 4334, + 3027, 3028, 3199, 3838, 4330, 4258, 4257, 833, 149, 4049, + 3154, 4234, 4177, 149, 3906, 4169, 1611, 1908, 4162, 1908, + 4148, 4139, 3246, 4114, 1315, 1316, 1317, 1314, 4109, 4108, + 1315, 1316, 1317, 1314, 4067, 4053, 4051, 3144, 3261, 4040, + 4361, 3166, 3150, 4010, 1629, 3188, 3948, 3268, 3910, 3899, + 2356, 3167, 3168, 3169, 3170, 3171, 3172, 3886, 3166, 3885, + 3189, 3883, 3878, 3183, 3187, 1329, 1328, 1338, 1339, 1331, + 1332, 1333, 1334, 1335, 1336, 1337, 1330, 3215, 708, 3203, + 3220, 149, 3837, 1340, 1341, 3224, 2385, 3207, 3876, 3206, + 1328, 1338, 1339, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1330, 1967, 3084, 3085, 2366, 3858, 3245, 1340, 1341, 1315, + 1316, 1317, 1314, 3855, 1115, 3852, 3851, 3100, 3101, 3823, + 3821, 3793, 1694, 1701, 1702, 3241, 1115, 3770, 1315, 1316, + 1317, 1314, 1695, 1696, 3790, 3784, 3134, 3253, 3243, 1706, + 3670, 3661, 1710, 1709, 3648, 3631, 3147, 3610, 3221, 3254, + 3145, 3608, 3222, 3604, 1315, 1316, 1317, 1314, 4209, 3356, + 3265, 3602, 702, 1592, 3549, 3527, 3526, 3270, 3337, 3239, + 3237, 3369, 3370, 3371, 3373, 3242, 3375, 3376, 3244, 4360, + 1315, 1316, 1317, 1314, 3524, 3258, 3256, 3523, 1241, 3510, + 3505, 3504, 3255, 3308, 1241, 1315, 1316, 1317, 1314, 3399, + 3420, 1315, 1316, 1317, 1314, 3383, 3377, 3277, 3278, 3413, + 3368, 3357, 3354, 3264, 702, 3352, 2440, 3276, 3273, 1113, + 1315, 1316, 1317, 1314, 149, 3251, 3284, 3302, 3430, 1241, + 3229, 3205, 702, 3142, 702, 1241, 1241, 3293, 3294, 149, + 3139, 149, 3297, 3301, 2175, 2498, 3136, 3449, 3290, 3300, + 3292, 3123, 1318, 3291, 1315, 1316, 1317, 1314, 3115, 3105, + 1350, 3103, 3099, 3098, 3288, 3289, 3097, 3346, 2576, 1360, + 1315, 1316, 1317, 1314, 2951, 2937, 1315, 1316, 1317, 1314, + 3475, 2924, 3478, 3423, 3478, 3478, 2354, 2920, 2800, 1241, + 3426, 3360, 898, 897, 4205, 1369, 2895, 3351, 2462, 3350, + 2449, 4314, 2446, 2268, 2994, 2261, 1978, 3500, 1977, 1742, + 1397, 3496, 1393, 1392, 1226, 1629, 1629, 966, 4046, 4036, + 1112, 3453, 4035, 1315, 1316, 1317, 1314, 1115, 2894, 1115, + 3462, 3464, 3452, 4023, 4019, 1115, 3884, 3454, 3455, 3854, + 3433, 3401, 2893, 3388, 3833, 3803, 3438, 215, 3785, 206, + 176, 3447, 3701, 3386, 3700, 1315, 1316, 1317, 1314, 3047, + 3698, 3668, 702, 3422, 1315, 1316, 1317, 1314, 1114, 1315, + 1316, 1317, 1314, 3627, 2173, 3625, 3399, 3432, 3624, 3444, + 2892, 3621, 3448, 3436, 3437, 1627, 1627, 3620, 3609, 1592, + 3474, 3483, 2155, 2155, 3047, 3607, 3585, 3501, 3502, 3575, + 3047, 3047, 2546, 2545, 3574, 3457, 3560, 1315, 1316, 1317, + 1314, 3559, 3451, 3387, 3479, 3480, 3384, 3344, 3313, 3314, + 211, 3473, 3484, 3304, 3315, 3316, 3317, 3318, 3295, 3319, + 3320, 3321, 3322, 3323, 3324, 3325, 3326, 3327, 3328, 3329, + 2891, 701, 701, 3287, 3286, 1241, 3280, 709, 3213, 2860, + 2774, 3498, 2890, 2770, 3047, 2769, 3506, 3573, 2404, 2397, + 2389, 2889, 2388, 2387, 2386, 2888, 1115, 1315, 1316, 1317, + 1314, 2384, 2380, 2379, 3536, 4101, 2377, 3514, 2368, 1315, + 1316, 1317, 1314, 2365, 2364, 2267, 2887, 3481, 1315, 1316, + 1317, 1314, 1315, 1316, 1317, 1314, 3552, 3534, 3535, 3511, + 3937, 1956, 1955, 3520, 3519, 702, 1954, 1953, 3456, 3522, + 1952, 1911, 3528, 1315, 1316, 1317, 1314, 3532, 1910, 1901, + 1641, 1639, 3525, 4228, 1387, 3545, 215, 3546, 4204, 1329, + 1328, 1338, 1339, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1330, 2886, 4134, 4131, 4116, 4111, 3553, 1340, 1341, 2883, + 3556, 3557, 3558, 2882, 1329, 1328, 1338, 1339, 1331, 1332, + 1333, 1334, 1335, 1336, 1337, 1330, 2881, 3563, 1315, 1316, + 1317, 1314, 1340, 1341, 4004, 4003, 1315, 1316, 1317, 1314, + 1315, 1316, 1317, 1314, 3983, 2240, 3635, 3965, 3961, 3637, + 3939, 3586, 3923, 1315, 1316, 1317, 1314, 2875, 3804, 211, + 1668, 3801, 3649, 3588, 3768, 3589, 3611, 3655, 3590, 3594, + 2703, 2863, 3595, 3767, 4353, 2859, 3764, 709, 3763, 3729, + 3726, 3724, 3645, 3688, 1315, 1316, 1317, 1314, 4221, 3647, + 3656, 3643, 1514, 3600, 3380, 4351, 2835, 3296, 1315, 1316, + 1317, 1314, 1315, 1316, 1317, 1314, 702, 2155, 1689, 3650, + 1700, 3652, 3613, 1691, 3615, 3640, 3617, 1705, 3693, 2840, + 1343, 1708, 1347, 1315, 1316, 1317, 1314, 1697, 3177, 3137, + 3131, 3056, 3005, 3004, 2997, 2667, 2175, 3713, 1344, 1346, + 1342, 2963, 1345, 1329, 1328, 1338, 1339, 1331, 1332, 1333, + 1334, 1335, 1336, 1337, 1330, 3632, 3628, 3634, 2897, 2784, + 3732, 1340, 1341, 1241, 2685, 2618, 2499, 4219, 2427, 1115, + 2471, 2470, 3475, 2434, 1832, 211, 1241, 2228, 1974, 3660, + 3514, 1773, 1723, 149, 149, 149, 1113, 1698, 1241, 3664, + 3779, 1456, 1441, 1437, 1629, 1315, 1316, 1317, 1314, 1436, + 3681, 4298, 2426, 1435, 3692, 1434, 3715, 1433, 1432, 3788, + 1431, 1430, 3683, 3699, 1429, 1428, 1427, 3714, 1426, 1425, + 3665, 1424, 702, 1423, 2155, 1422, 3717, 1421, 1241, 1315, + 1316, 1317, 1314, 1420, 1419, 3762, 1800, 1801, 1802, 1803, + 1804, 1845, 1418, 3712, 1417, 3755, 3711, 1115, 1416, 1415, + 1414, 3723, 1413, 3725, 3718, 1412, 1411, 1410, 3719, 1409, + 1408, 232, 1407, 1406, 1627, 1349, 1405, 1404, 1315, 1316, + 1317, 1314, 3797, 1403, 1241, 3794, 3781, 1400, 3771, 3774, + 1847, 1399, 3769, 1398, 1851, 1852, 1853, 1854, 3809, 3778, + 1396, 1395, 1394, 1391, 1892, 1384, 1383, 1381, 1380, 3783, + 1379, 1378, 1902, 1377, 1376, 1375, 1374, 1373, 3789, 3791, + 1372, 3786, 3935, 1371, 3792, 3799, 3795, 3796, 1370, 1365, + 3798, 1364, 1363, 1362, 3856, 1361, 1279, 1224, 3733, 3541, + 3542, 4217, 4215, 3765, 2037, 2510, 2484, 3870, 1267, 3544, + 3517, 3772, 3143, 2983, 2696, 3880, 3831, 2270, 1520, 1278, + 3175, 3816, 3185, 3068, 132, 1957, 1958, 1959, 1960, 1961, + 1241, 3174, 69, 3826, 1968, 3827, 1329, 1328, 1338, 1339, + 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1330, 3180, 1241, + 1629, 1629, 3178, 3181, 1340, 1341, 3430, 3179, 3877, 3806, + 3879, 3866, 3182, 3166, 2657, 2658, 3551, 3807, 3918, 3550, + 68, 3918, 3689, 3690, 3691, 3547, 3184, 3173, 4247, 3696, + 3697, 4150, 3933, 3944, 3907, 1241, 2798, 1241, 3860, 2787, + 3912, 3913, 2084, 1445, 3418, 704, 3936, 3260, 3938, 3873, + 2538, 2539, 2586, 705, 1629, 3775, 1115, 3891, 3471, 3166, + 3472, 3564, 3890, 3909, 2533, 2534, 2535, 3805, 2136, 2044, + 1627, 1843, 702, 1683, 1241, 1241, 1115, 3900, 1241, 1241, + 2782, 3922, 3908, 3921, 3592, 3593, 3911, 3889, 2284, 1737, + 3715, 706, 3932, 2824, 2645, 2063, 3985, 2456, 3990, 3811, + 2455, 3930, 3931, 3942, 1717, 3980, 2463, 1115, 2230, 3969, + 3970, 2148, 2037, 3981, 3982, 3996, 3949, 3762, 3915, 1273, + 3888, 3882, 3945, 3828, 1843, 2805, 2806, 3755, 4005, 4006, + 3667, 2652, 2656, 2657, 2658, 2653, 2661, 2654, 2659, 3941, + 3458, 2655, 1629, 2660, 3848, 3047, 3006, 2530, 3993, 3947, + 3080, 2494, 2035, 2011, 701, 1230, 4364, 3081, 3082, 3083, + 4113, 1968, 3992, 1897, 1896, 1239, 1968, 1968, 4037, 3994, + 4038, 3503, 702, 1452, 1453, 1450, 1451, 2639, 4029, 3872, + 1448, 1449, 2632, 3986, 1446, 1447, 2156, 1577, 1576, 1268, + 1306, 2288, 3562, 3555, 4012, 2464, 2301, 2039, 1529, 1638, + 1794, 4016, 1794, 708, 1528, 1502, 1552, 2503, 4024, 4050, + 4028, 4052, 1627, 4321, 4319, 4276, 4244, 2247, 4243, 4241, + 2250, 4181, 4135, 2253, 4017, 3999, 2255, 3998, 3934, 3822, + 3840, 3612, 3841, 3582, 4082, 3581, 3567, 4076, 4055, 2296, + 149, 2571, 2832, 2541, 4056, 1739, 3566, 3217, 4033, 4034, + 1241, 1526, 2652, 2656, 2657, 2658, 2653, 2661, 2654, 2659, + 3636, 4099, 2655, 4105, 2660, 4066, 1329, 1328, 1338, 1339, + 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1330, 4355, 4354, + 4354, 4078, 2299, 4079, 1340, 1341, 4091, 3263, 4077, 2932, + 3831, 2931, 2930, 4095, 1241, 2367, 1460, 1263, 4355, 1629, + 3963, 3808, 4126, 957, 958, 959, 960, 1238, 1238, 1544, + 77, 2, 4377, 4378, 1, 149, 2911, 4112, 1972, 1454, + 961, 956, 149, 1605, 2677, 1115, 2209, 1633, 1976, 4121, + 963, 3191, 3192, 3554, 3194, 149, 4074, 2938, 149, 149, + 2320, 3155, 2630, 2474, 3412, 1509, 1015, 1903, 1754, 1255, + 1751, 149, 1254, 1252, 4161, 1848, 1924, 835, 2273, 4156, + 3132, 3106, 3995, 4363, 4136, 4398, 4313, 4366, 4171, 1627, + 1771, 819, 4235, 4140, 4317, 3987, 4142, 4015, 2325, 3988, + 1311, 4123, 3238, 1045, 4166, 878, 4167, 846, 1382, 2348, + 1730, 3311, 3309, 2353, 845, 4182, 3678, 2973, 4000, 3210, + 4084, 2362, 1046, 2256, 4137, 4013, 1684, 1688, 2529, 4092, + 4200, 4168, 3943, 3467, 3042, 1794, 1712, 4195, 3727, 4176, + 3844, 3842, 3843, 4199, 746, 2188, 675, 1241, 4184, 1097, + 3984, 2269, 2509, 4264, 4115, 1629, 4224, 999, 2369, 3662, + 4225, 2483, 4193, 1000, 993, 4232, 2376, 4214, 4216, 4218, + 4220, 4198, 2992, 2991, 1811, 1320, 1830, 4207, 3330, 4233, + 3331, 1359, 4213, 790, 2350, 2970, 3750, 3204, 76, 75, + 74, 73, 240, 837, 2395, 239, 4047, 3904, 4231, 2400, + 2401, 2402, 4368, 816, 2405, 2406, 2407, 2408, 2409, 2410, + 2411, 2412, 2413, 2414, 1629, 4240, 4238, 4082, 4252, 4254, + 815, 814, 4259, 813, 812, 1627, 811, 4256, 4253, 4255, + 2650, 2651, 2649, 4286, 2647, 2646, 2170, 4223, 2169, 4294, + 3216, 3565, 2235, 4277, 2237, 3428, 3071, 4279, 3066, 2088, + 2086, 4280, 4281, 1584, 1596, 4132, 4133, 2566, 2573, 3305, + 2085, 4295, 1598, 3601, 3834, 4210, 4211, 4310, 3960, 3116, + 3830, 2532, 2562, 2105, 4303, 3087, 4304, 2102, 4305, 2101, + 4306, 3079, 4307, 1635, 1627, 4320, 3956, 4322, 4323, 3950, + 2133, 4080, 3917, 3734, 4318, 4316, 4278, 3735, 3741, 2493, + 1167, 1163, 4156, 4326, 1165, 1166, 1164, 1241, 4124, 2845, + 4327, 4329, 4328, 1329, 1328, 1338, 1339, 1331, 1332, 1333, + 1334, 1335, 1336, 1337, 1330, 3530, 4105, 2543, 3390, 4343, + 2957, 1340, 1341, 2956, 4344, 4346, 2954, 4345, 2953, 4349, + 1489, 4170, 4352, 4362, 4350, 4370, 4260, 3887, 4369, 2701, + 2699, 1221, 3543, 4356, 4357, 4358, 4359, 3539, 3361, 2281, + 3548, 3176, 2297, 3259, 2171, 4374, 2167, 4382, 2166, 1138, + 1137, 1665, 3641, 1241, 45, 3157, 2640, 4172, 4058, 2537, + 1580, 2481, 111, 41, 4387, 4199, 4388, 1033, 127, 4390, + 110, 193, 60, 4396, 192, 59, 4183, 4400, 125, 4397, + 190, 4187, 4188, 58, 105, 104, 124, 2174, 1329, 1328, + 1338, 1339, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1330, + 4408, 188, 57, 224, 223, 226, 1340, 1341, 225, 222, + 2760, 2761, 4208, 4370, 4416, 221, 4369, 1672, 4415, 220, + 4245, 3920, 4227, 951, 44, 1968, 4400, 1968, 4417, 43, + 194, 4421, 42, 112, 61, 40, 39, 3739, 2502, 1029, + 1030, 3378, 2038, 3657, 2949, 2467, 1968, 1968, 38, 34, + 1073, 13, 4341, 12, 35, 22, 21, 1758, 20, 26, + 32, 31, 142, 149, 141, 30, 149, 149, 140, 149, + 139, 138, 137, 136, 135, 134, 29, 19, 3751, 1668, + 52, 51, 50, 49, 48, 47, 9, 130, 128, 123, + 121, 3742, 28, 122, 119, 120, 115, 114, 113, 108, + 106, 88, 3737, 87, 86, 101, 100, 3759, 3760, 1113, + 99, 98, 149, 3738, 97, 96, 94, 95, 1794, 1044, + 85, 1113, 84, 83, 82, 81, 116, 103, 2792, 109, + 2795, 107, 758, 757, 764, 754, 1075, 149, 92, 1074, + 102, 93, 91, 90, 89, 761, 762, 80, 763, 767, + 3743, 79, 748, 78, 118, 117, 129, 195, 62, 174, + 173, 172, 772, 171, 4332, 4333, 170, 168, 169, 167, + 166, 4337, 4338, 4339, 4340, 165, 164, 163, 1059, 162, + 53, 54, 55, 56, 184, 183, 185, 1034, 187, 189, + 186, 191, 181, 179, 182, 2837, 180, 178, 2843, 71, + 11, 126, 18, 4, 0, 0, 0, 0, 776, 2861, + 2862, 778, 2347, 0, 1036, 0, 777, 2864, 2865, 0, + 1349, 0, 0, 0, 0, 0, 0, 1995, 1996, 1997, + 0, 0, 0, 2870, 2871, 2872, 1329, 1328, 1338, 1339, + 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1330, 0, 0, + 3758, 0, 2552, 0, 1340, 1341, 0, 2027, 0, 0, + 0, 0, 2032, 0, 0, 0, 2899, 0, 2901, 0, + 0, 2904, 0, 1800, 1968, 0, 0, 3747, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1058, 1056, 0, 0, 0, 0, 0, 3744, + 3748, 3746, 3745, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1881, 0, 0, 0, 0, 1055, + 0, 0, 0, 0, 758, 757, 764, 754, 0, 0, + 0, 1028, 0, 2080, 0, 0, 0, 761, 762, 0, + 763, 767, 1035, 1068, 748, 0, 0, 0, 0, 0, + 0, 0, 3753, 3754, 772, 0, 0, 0, 749, 751, + 750, 3024, 3025, 0, 0, 0, 1064, 0, 0, 756, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 760, 0, 0, 0, 0, 0, 0, 775, 0, + 0, 0, 0, 0, 0, 753, 0, 0, 0, 743, + 2217, 0, 1065, 1069, 0, 3761, 2217, 2217, 2217, 0, + 0, 0, 0, 0, 0, 0, 0, 3740, 0, 0, + 0, 0, 1052, 3752, 1050, 1054, 1072, 0, 0, 0, + 1051, 1048, 1047, 0, 1053, 1038, 1039, 1037, 0, 1027, + 1040, 1041, 1042, 1043, 1024, 0, 0, 1070, 0, 1071, + 0, 0, 758, 757, 764, 754, 0, 0, 0, 0, + 1066, 1067, 0, 0, 0, 761, 762, 0, 763, 767, + 0, 0, 748, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 772, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1062, 0, + 1877, 0, 0, 0, 1061, 0, 0, 1874, 1025, 0, + 0, 1876, 1873, 1875, 1879, 1880, 0, 0, 1968, 1878, + 0, 0, 1057, 0, 0, 755, 759, 765, 776, 766, + 768, 778, 2134, 769, 770, 771, 777, 2095, 773, 774, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 749, 751, 750, 0, 0, 0, 0, 0, 3757, 0, + 2670, 756, 0, 0, 0, 0, 0, 0, 2136, 2104, + 0, 0, 0, 760, 0, 0, 0, 0, 2137, 2138, + 775, 0, 0, 0, 0, 0, 0, 753, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2103, 0, 3223, 1060, 3225, 0, + 0, 0, 0, 1031, 1032, 0, 1023, 0, 0, 0, + 0, 1026, 2111, 0, 0, 0, 2174, 1968, 0, 0, + 0, 0, 1968, 0, 149, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3756, 0, 2299, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1862, 1863, 1864, + 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1884, 1885, + 1886, 1887, 1888, 1889, 1882, 1883, 0, 0, 749, 751, + 750, 3279, 0, 0, 0, 0, 0, 0, 0, 756, + 0, 0, 2127, 0, 0, 0, 0, 0, 0, 0, + 0, 760, 752, 0, 0, 0, 2134, 0, 775, 3303, + 0, 0, 0, 0, 0, 753, 0, 755, 759, 765, + 0, 766, 768, 0, 0, 769, 770, 771, 0, 0, + 773, 774, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2136, 0, 0, 0, 2450, 0, 2452, 779, + 780, 781, 782, 783, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2094, 2096, 2093, 0, + 2473, 2090, 0, 0, 0, 0, 2115, 0, 0, 0, + 0, 0, 0, 2489, 2490, 2491, 2492, 2121, 0, 0, + 0, 0, 0, 0, 0, 2106, 2111, 2089, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2109, 2143, 0, + 0, 2110, 2112, 2114, 0, 2116, 2117, 2118, 2122, 2123, + 2124, 2126, 2129, 2130, 2131, 0, 0, 0, 0, 0, + 0, 0, 2119, 2128, 2120, 0, 2531, 0, 0, 0, + 0, 0, 0, 0, 2098, 755, 759, 765, 0, 766, + 768, 0, 0, 769, 770, 771, 0, 0, 773, 774, + 0, 0, 4075, 0, 0, 0, 2127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, + 0, 2135, 0, 0, 0, 0, 0, 149, 0, 0, + 0, 0, 0, 0, 752, 0, 0, 0, 0, 3482, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2091, 2092, 0, 1598, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2132, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2108, 0, + 2115, 0, 0, 0, 0, 2107, 0, 0, 0, 0, + 0, 2121, 0, 1635, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2217, 0, 2125, + 3513, 2109, 2143, 0, 0, 2110, 2112, 2114, 2113, 2116, + 2117, 2118, 2122, 2123, 2124, 2126, 2129, 2130, 2131, 0, + 0, 2140, 2139, 0, 0, 0, 2119, 2128, 2120, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 752, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 779, 780, 781, 782, - 783, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1591, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2174, 2174, 2174, 2174, 2174, 2174, + 0, 0, 0, 0, 0, 0, 0, 2134, 0, 0, + 0, 2174, 2095, 0, 0, 2135, 0, 0, 2100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 779, 780, 781, 782, 783, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2087, 2089, 2086, 0, - 3499, 2083, 0, 0, 0, 0, 2108, 0, 0, 0, - 1628, 0, 0, 0, 0, 0, 0, 2114, 0, 0, - 0, 0, 0, 0, 2210, 2099, 0, 2082, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2102, 2136, 0, - 0, 2103, 2105, 2107, 0, 2109, 2110, 2111, 2115, 2116, - 2117, 2119, 2122, 2123, 2124, 2663, 0, 0, 0, 0, - 0, 0, 2112, 2121, 2113, 0, 2127, 0, 0, 0, - 0, 2088, 0, 0, 2091, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2827, 2828, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2129, 2097, 0, 0, 0, 0, 0, 0, - 0, 2128, 2130, 2131, 0, 0, 0, 0, 0, 0, - 0, 2167, 0, 0, 0, 0, 0, 0, 0, 149, - 0, 0, 0, 0, 0, 0, 0, 0, 2096, 0, - 0, 0, 0, 2084, 2085, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2104, 0, 0, 0, - 0, 2125, 3589, 758, 757, 764, 754, 0, 0, 3591, - 3592, 0, 0, 0, 0, 0, 761, 762, 2101, 763, - 767, 0, 0, 748, 0, 2100, 0, 0, 0, 0, - 0, 0, 0, 772, 0, 0, 0, 3600, 0, 3602, - 0, 0, 0, 0, 0, 0, 0, 0, 3612, 2118, - 0, 0, 0, 0, 0, 0, 0, 0, 2106, 0, - 0, 0, 0, 0, 0, 0, 2120, 0, 0, 0, - 0, 2133, 2132, 0, 0, 0, 1196, 0, 0, 0, - 0, 0, 0, 3499, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2919, 2920, 2921, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2948, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2093, 0, - 0, 0, 0, 0, 0, 0, 0, 2996, 0, 0, - 2087, 3023, 2086, 0, 0, 3022, 0, 0, 0, 0, - 2108, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2114, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2135, 0, 0, 2134, 0, 0, - 0, 2102, 2136, 0, 0, 2103, 2105, 2107, 0, 2109, - 2110, 2111, 2115, 2116, 2117, 2119, 2122, 2123, 2124, 0, - 0, 0, 0, 0, 0, 0, 2112, 2121, 2113, 0, - 0, 0, 149, 0, 0, 0, 0, 0, 2091, 0, - 0, 0, 149, 0, 0, 1961, 0, 0, 0, 749, - 751, 750, 0, 0, 0, 0, 0, 0, 0, 0, - 756, 1961, 0, 0, 3786, 0, 0, 3788, 0, 0, - 0, 0, 760, 0, 0, 2128, 0, 0, 0, 775, - 0, 0, 0, 0, 1186, 0, 753, 0, 0, 3796, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2084, 2085, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2125, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2101, 0, 0, 0, 0, 0, 0, 2100, - 0, 0, 0, 0, 0, 0, 0, 3194, 3195, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2118, 0, 0, 0, 0, 0, 1186, - 0, 0, 2106, 0, 0, 0, 0, 0, 0, 2167, - 2167, 2167, 2167, 2167, 2167, 2133, 2132, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2167, 0, 1171, 1874, - 0, 0, 0, 0, 1161, 0, 755, 759, 765, 0, - 766, 768, 0, 0, 769, 770, 771, 0, 0, 773, - 774, 1194, 1198, 1200, 1202, 1204, 1205, 1207, 0, 1212, - 1208, 1209, 1210, 1211, 0, 1189, 1190, 1191, 1192, 1169, - 1170, 1195, 2093, 1172, 0, 1174, 1175, 1176, 1177, 1173, - 1178, 1179, 1180, 1181, 1182, 1185, 1187, 1183, 1184, 1193, - 0, 0, 0, 0, 0, 0, 0, 1197, 1199, 1201, - 1203, 1206, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 149, 0, 0, 2135, 0, - 149, 2134, 0, 1171, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1188, 0, 0, - 0, 149, 0, 0, 0, 0, 1194, 1198, 1200, 1202, - 1204, 1205, 1207, 149, 1212, 1208, 1209, 1210, 1211, 0, - 1189, 1190, 1191, 1192, 1169, 1170, 1195, 0, 1172, 0, - 1174, 1175, 1176, 1177, 1173, 1178, 1179, 1180, 1181, 1182, - 1185, 1187, 1183, 1184, 1193, 2127, 0, 0, 0, 0, - 0, 0, 1197, 1199, 1201, 1203, 1206, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3345, 0, 0, 0, - 0, 0, 0, 752, 0, 1870, 0, 0, 0, 0, - 0, 2129, 1867, 0, 0, 0, 1869, 1866, 1868, 1872, - 1873, 0, 1188, 0, 1871, 0, 2127, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3407, 0, - 0, 0, 0, 0, 0, 4090, 0, 0, 0, 0, - 0, 0, 2129, 0, 0, 2104, 3420, 0, 3421, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2104, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2120, 0, 0, 0, 0, - 0, 0, 0, 0, 1113, 0, 149, 0, 0, 0, - 0, 0, 149, 0, 0, 0, 0, 0, 0, 2167, - 0, 0, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, - 1863, 1864, 1865, 1877, 1878, 1879, 1880, 1881, 1882, 1875, - 1876, 0, 4061, 0, 0, 0, 2120, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2210, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2127, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2108, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2114, 0, 0, 0, 0, 0, 0, 0, 1196, 0, - 0, 0, 0, 0, 4192, 2129, 0, 0, 0, 0, - 2102, 2136, 0, 0, 2103, 2105, 2107, 0, 2109, 2110, - 2111, 2115, 2116, 2117, 2119, 2122, 2123, 2124, 0, 0, - 2108, 0, 0, 0, 0, 2112, 2121, 2113, 0, 0, - 0, 2114, 0, 3501, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2104, - 0, 2102, 2136, 0, 0, 2103, 2105, 2107, 0, 2109, - 2110, 2111, 2115, 2116, 2117, 2119, 2122, 2123, 2124, 0, - 0, 0, 0, 0, 2128, 0, 2112, 2121, 2113, 0, - 0, 0, 0, 1196, 0, 0, 0, 4277, 0, 3583, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2120, - 0, 0, 0, 0, 2125, 2128, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2101, 0, 0, 0, 0, 0, 0, 2100, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4277, 2118, 0, 0, 2125, 0, 0, 0, 0, - 0, 2106, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2101, 0, 0, 0, 0, 0, 0, 2100, + 0, 0, 1186, 2136, 2104, 0, 0, 0, 0, 0, + 0, 0, 0, 2137, 2138, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2142, 2132, 0, 2141, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2103, + 0, 0, 2108, 0, 0, 0, 0, 0, 0, 2107, + 0, 0, 0, 0, 0, 0, 0, 2111, 0, 0, + 0, 0, 3603, 0, 0, 0, 0, 149, 0, 3605, + 3606, 0, 149, 2125, 0, 0, 0, 0, 0, 0, + 0, 0, 2113, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 149, 0, 0, 0, 3614, 0, 3616, + 0, 0, 0, 0, 0, 149, 0, 0, 3626, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1171, 2127, 0, 2933, + 2934, 2935, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3513, 0, 0, 0, 2962, 0, 1201, + 1205, 1207, 1209, 1211, 1212, 1214, 0, 1219, 1215, 1216, + 1217, 1218, 0, 1189, 1190, 1191, 1192, 1169, 1170, 1202, + 3010, 1172, 0, 1174, 1175, 1176, 1177, 1173, 1178, 1179, + 1180, 1181, 1182, 1185, 1187, 1183, 1184, 1193, 1194, 1195, + 1196, 1197, 1198, 1199, 1200, 1204, 1206, 1208, 1210, 1213, + 0, 2094, 3037, 2093, 0, 0, 3036, 0, 0, 0, + 0, 2115, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2121, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1188, 0, 0, 0, 0, + 0, 0, 2109, 2143, 0, 0, 2110, 2112, 2114, 0, + 2116, 2117, 2118, 2122, 2123, 2124, 2126, 2129, 2130, 2131, + 0, 0, 0, 0, 0, 0, 0, 2119, 2128, 2120, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2098, + 0, 0, 0, 0, 0, 1968, 0, 0, 0, 0, + 0, 1186, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1968, 0, 0, 3800, 0, 1113, 3802, 149, 0, + 0, 0, 0, 0, 149, 0, 2135, 0, 0, 0, + 0, 2174, 0, 0, 0, 0, 0, 0, 0, 3810, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1315, 1316, 1317, 1314, 0, 0, 2091, 2092, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2132, 0, 0, 0, + 3208, 3209, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2108, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2114, 0, 0, 0, 0, 0, - 0, 0, 0, 2118, 0, 0, 0, 0, 0, 0, - 2210, 4277, 2106, 0, 2102, 2136, 0, 0, 2103, 2105, - 2107, 0, 2109, 2110, 2111, 2115, 2116, 2117, 2119, 2122, - 2123, 2124, 0, 0, 0, 0, 0, 0, 0, 2112, - 2121, 2113, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3501, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4405, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2128, 0, + 2107, 0, 0, 0, 2841, 2842, 0, 0, 0, 0, + 0, 1186, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2125, 1171, 0, 0, 0, 0, + 0, 1161, 0, 2113, 1881, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2140, 2139, 1201, 1205, + 1207, 1209, 1211, 1212, 1214, 3515, 1219, 1215, 1216, 1217, + 1218, 0, 1189, 1190, 1191, 1192, 1169, 1170, 1202, 0, + 1172, 0, 1174, 1175, 1176, 1177, 1173, 1178, 1179, 1180, + 1181, 1182, 1185, 1187, 1183, 1184, 1193, 1194, 1195, 1196, + 1197, 1198, 1199, 1200, 1204, 1206, 1208, 1210, 1213, 0, + 0, 0, 0, 2100, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1188, 1171, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2142, + 0, 0, 2141, 0, 0, 0, 1203, 0, 1201, 1205, + 1207, 1209, 1211, 1212, 1214, 0, 1219, 1215, 1216, 1217, + 1218, 0, 1189, 1190, 1191, 1192, 1169, 1170, 1202, 0, + 1172, 0, 1174, 1175, 1176, 1177, 1173, 1178, 1179, 1180, + 1181, 1182, 1185, 1187, 1183, 1184, 1193, 1194, 1195, 1196, + 1197, 1198, 1199, 1200, 1204, 1206, 1208, 1210, 1213, 0, + 0, 2134, 0, 0, 0, 0, 3359, 0, 215, 0, + 1877, 0, 0, 0, 0, 0, 0, 1874, 0, 0, + 0, 1876, 1873, 1875, 1879, 1880, 0, 0, 0, 1878, + 0, 3916, 0, 0, 1188, 0, 0, 2136, 0, 2134, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3421, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2136, 3434, 0, 3435, 0, + 0, 211, 0, 0, 0, 0, 0, 0, 3515, 0, + 0, 2111, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4104, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2111, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2174, 0, 0, 0, 0, 0, 0, + 0, 2127, 0, 0, 0, 0, 149, 1862, 1863, 1864, + 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1884, 1885, + 1886, 1887, 1888, 1889, 1882, 1883, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2127, + 0, 0, 0, 0, 0, 0, 2217, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1203, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2115, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2167, 0, 0, 0, 0, 2210, 0, 0, 0, - 0, 0, 0, 0, 149, 0, 0, 0, 2125, 0, + 0, 0, 0, 0, 4206, 0, 2109, 2143, 149, 0, + 2110, 2112, 2114, 2115, 2116, 2117, 2118, 2122, 2123, 2124, + 2126, 2129, 2130, 2131, 2121, 0, 0, 0, 0, 0, + 0, 2119, 2128, 2120, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2109, 2143, 0, 0, 2110, 2112, + 2114, 0, 2116, 2117, 2118, 2122, 2123, 2124, 2126, 2129, + 2130, 2131, 0, 0, 0, 0, 0, 0, 0, 2119, + 2128, 2120, 0, 0, 0, 1203, 0, 0, 0, 3597, + 2135, 0, 0, 0, 0, 3874, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 4291, 0, 0, + 0, 0, 0, 0, 0, 149, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2101, 0, 0, 0, 0, - 0, 0, 2100, 0, 0, 0, 0, 0, 0, 0, + 2132, 0, 0, 0, 0, 0, 149, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2108, 0, 0, + 0, 0, 0, 0, 2107, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2132, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2125, 0, + 0, 4291, 0, 0, 0, 2108, 0, 2113, 0, 0, + 0, 0, 2107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2118, 0, 0, 0, - 0, 0, 0, 0, 0, 2106, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2125, 0, 0, 0, + 2217, 0, 0, 0, 0, 2113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 177, 0, 0, 0, 4419, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2217, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 853, 0, 149, 0, 0, 0, 0, 0, + 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, + 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, + 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, + 844, 590, 541, 457, 403, 608, 607, 0, 0, 922, + 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, + 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, + 821, 831, 0, 0, 323, 238, 536, 656, 538, 537, + 822, 0, 823, 827, 830, 826, 824, 825, 0, 913, + 0, 0, 0, 0, 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3860, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 798, 799, 0, 0, 0, 0, 854, + 0, 800, 0, 0, 849, 828, 832, 0, 0, 0, + 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, + 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, + 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, + 829, 852, 856, 348, 936, 850, 490, 315, 0, 489, + 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, + 381, 358, 937, 382, 383, 372, 430, 391, 431, 373, + 405, 404, 406, 0, 0, 0, 3968, 0, 518, 519, + 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 649, 847, 0, 653, 0, 492, + 0, 0, 920, 0, 0, 0, 463, 0, 0, 384, + 0, 0, 0, 851, 0, 446, 421, 933, 0, 0, + 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, + 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, + 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, + 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, + 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, + 472, 321, 499, 505, 506, 595, 4039, 511, 690, 691, + 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, + 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, + 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, + 547, 551, 552, 375, 616, 1905, 1904, 1906, 504, 385, + 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, + 917, 417, 618, 651, 652, 543, 0, 932, 912, 914, + 915, 919, 923, 924, 925, 926, 927, 929, 931, 935, + 684, 0, 597, 612, 688, 611, 681, 423, 0, 450, + 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, + 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, + 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, + 634, 934, 578, 555, 581, 496, 558, 557, 0, 0, + 592, 855, 593, 594, 407, 408, 409, 410, 921, 619, + 328, 515, 436, 0, 579, 0, 0, 0, 0, 0, + 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, + 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, + 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, + 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, + 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, + 599, 943, 916, 942, 944, 945, 941, 946, 947, 928, + 810, 0, 862, 863, 939, 938, 940, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, + 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, + 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, + 0, 0, 817, 305, 549, 388, 0, 435, 361, 614, + 615, 0, 666, 905, 871, 872, 873, 807, 874, 868, + 869, 808, 870, 906, 860, 902, 903, 836, 865, 875, + 901, 876, 904, 907, 908, 948, 949, 882, 866, 267, + 950, 879, 909, 900, 899, 877, 861, 910, 911, 843, + 838, 880, 881, 867, 886, 887, 888, 809, 891, 892, + 893, 894, 895, 889, 890, 857, 858, 859, 883, 884, + 864, 839, 840, 841, 842, 0, 0, 500, 501, 502, + 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, + 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, + 896, 661, 461, 462, 668, 0, 885, 664, 665, 662, + 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, + 0, 802, 215, 853, 0, 0, 0, 0, 0, 0, + 0, 0, 419, 0, 0, 554, 587, 576, 660, 542, + 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, + 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, + 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, + 567, 844, 590, 541, 457, 403, 608, 607, 0, 0, + 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, + 918, 0, 0, 0, 0, 797, 0, 0, 834, 898, + 897, 821, 831, 0, 0, 323, 238, 536, 656, 538, + 537, 822, 0, 823, 827, 830, 826, 824, 825, 0, + 913, 0, 0, 0, 0, 0, 0, 789, 801, 0, + 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 798, 799, 0, 0, 0, 0, + 854, 0, 800, 0, 0, 849, 828, 832, 0, 0, + 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, + 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, + 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, + 416, 829, 852, 856, 348, 936, 850, 490, 315, 0, + 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, + 393, 381, 358, 937, 382, 383, 372, 430, 391, 431, + 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, + 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 649, 847, 0, 653, 0, + 492, 0, 0, 920, 0, 0, 0, 463, 0, 0, + 384, 0, 0, 0, 851, 0, 446, 421, 933, 0, + 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, + 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, + 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, + 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, + 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, + 473, 472, 321, 499, 505, 506, 595, 0, 511, 690, + 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, + 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, + 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, + 604, 547, 551, 552, 375, 616, 0, 0, 0, 504, + 385, 386, 0, 357, 356, 398, 437, 363, 303, 304, + 685, 917, 417, 618, 651, 652, 543, 0, 932, 912, + 914, 915, 919, 923, 924, 925, 926, 927, 929, 931, + 935, 684, 0, 597, 612, 688, 611, 681, 423, 0, + 450, 609, 556, 0, 601, 575, 0, 602, 571, 606, + 0, 545, 0, 458, 485, 497, 514, 517, 546, 631, + 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, + 641, 634, 934, 578, 555, 581, 496, 558, 557, 0, + 0, 592, 855, 593, 594, 407, 408, 409, 410, 921, + 619, 328, 515, 436, 0, 579, 0, 0, 0, 0, + 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, + 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, + 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, + 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, + 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, + 572, 599, 943, 916, 942, 944, 945, 941, 946, 947, + 928, 810, 0, 862, 863, 939, 938, 940, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, + 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, + 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, + 0, 0, 0, 817, 305, 549, 388, 177, 435, 361, + 614, 615, 0, 666, 905, 871, 872, 873, 807, 874, + 868, 869, 808, 870, 906, 860, 902, 903, 836, 865, + 875, 901, 876, 904, 907, 908, 948, 949, 882, 866, + 267, 950, 879, 909, 900, 899, 877, 861, 910, 911, + 843, 838, 880, 881, 867, 886, 887, 888, 809, 891, + 892, 893, 894, 895, 889, 890, 857, 858, 859, 883, + 884, 864, 839, 840, 841, 842, 0, 0, 500, 501, + 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, + 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, + 659, 896, 661, 461, 462, 668, 0, 885, 664, 665, + 662, 392, 448, 467, 455, 853, 686, 539, 540, 687, + 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, + 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, + 0, 0, 354, 1969, 0, 387, 591, 573, 583, 574, + 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, + 535, 566, 567, 844, 590, 541, 457, 403, 608, 607, + 0, 0, 922, 930, 0, 0, 0, 0, 0, 0, + 0, 0, 918, 0, 2200, 0, 0, 797, 0, 0, + 834, 898, 897, 821, 831, 0, 0, 323, 238, 536, + 656, 538, 537, 822, 0, 823, 827, 830, 826, 824, + 825, 0, 913, 0, 0, 0, 0, 0, 0, 789, + 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 798, 799, 0, 0, + 0, 0, 854, 0, 800, 0, 0, 2201, 828, 832, + 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, + 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, + 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, + 368, 349, 416, 829, 852, 856, 348, 936, 850, 490, + 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, + 478, 399, 393, 381, 358, 937, 382, 383, 372, 430, + 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, + 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 649, 847, 0, + 653, 0, 492, 0, 0, 920, 0, 0, 0, 463, + 0, 0, 384, 0, 0, 0, 851, 0, 446, 421, + 933, 0, 0, 444, 389, 477, 432, 483, 465, 491, + 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, + 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, + 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, + 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, + 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, + 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, + 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, + 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, + 550, 513, 604, 547, 551, 552, 375, 616, 0, 0, + 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, + 303, 304, 685, 917, 417, 618, 651, 652, 543, 0, + 932, 912, 914, 915, 919, 923, 924, 925, 926, 927, + 929, 931, 935, 684, 0, 597, 612, 688, 611, 681, + 423, 0, 450, 609, 556, 0, 601, 575, 0, 602, + 571, 606, 0, 545, 0, 458, 485, 497, 514, 517, + 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, + 639, 640, 641, 634, 934, 578, 555, 581, 496, 558, + 557, 0, 0, 592, 855, 593, 594, 407, 408, 409, + 410, 921, 619, 328, 515, 436, 0, 579, 0, 0, + 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, + 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, + 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, + 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, + 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, + 456, 395, 572, 599, 943, 916, 942, 944, 945, 941, + 946, 947, 928, 810, 0, 862, 863, 939, 938, 940, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 149, 0, 0, 853, 0, 0, 0, - 0, 0, 0, 0, 0, 419, 3954, 0, 554, 587, + 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, + 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, + 674, 683, 0, 0, 0, 817, 305, 549, 388, 0, + 435, 361, 614, 615, 0, 666, 905, 871, 872, 873, + 807, 874, 868, 869, 808, 870, 906, 860, 902, 903, + 836, 865, 875, 901, 876, 904, 907, 908, 948, 949, + 882, 866, 267, 950, 879, 909, 900, 899, 877, 861, + 910, 911, 843, 838, 880, 881, 867, 886, 887, 888, + 809, 891, 892, 893, 894, 895, 889, 890, 857, 858, + 859, 883, 884, 864, 839, 840, 841, 842, 0, 0, + 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, + 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, + 655, 657, 659, 896, 661, 461, 462, 668, 0, 885, + 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, + 540, 687, 650, 0, 802, 215, 853, 0, 0, 0, + 0, 0, 0, 0, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, - 0, 0, 0, 354, 149, 0, 387, 591, 573, 583, + 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, + 565, 535, 566, 567, 1352, 590, 541, 457, 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, 323, 238, 536, 656, 538, 537, 822, 0, 823, 827, 830, 826, 824, 825, 0, 913, 0, 0, 0, 0, 0, 0, - 789, 801, 0, 806, 0, 0, 4025, 0, 0, 0, + 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, 799, 0, 0, 0, 0, 854, 0, 800, 0, 0, 849, 828, @@ -2604,7 +2811,7 @@ var yyAct = [...]int{ 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, 0, 0, - 463, 0, 149, 384, 0, 0, 0, 851, 0, 446, + 463, 0, 0, 384, 0, 0, 0, 851, 0, 446, 421, 933, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, @@ -2614,8 +2821,8 @@ var yyAct = [...]int{ 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 1898, - 1897, 1899, 504, 385, 386, 0, 357, 356, 398, 437, + 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, + 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, 917, 417, 618, 651, 652, 543, 0, 932, 912, 914, 915, 919, 923, 924, 925, 926, 927, 929, 931, 935, 684, 0, 597, 612, 688, 611, @@ -2636,7 +2843,7 @@ var yyAct = [...]int{ 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, 817, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 905, 871, 872, + 177, 435, 361, 614, 615, 0, 666, 905, 871, 872, 873, 807, 874, 868, 869, 808, 870, 906, 860, 902, 903, 836, 865, 875, 901, 876, 904, 907, 908, 948, 949, 882, 866, 267, 950, 879, 909, 900, 899, 877, @@ -2646,148 +2853,79 @@ var yyAct = [...]int{ 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, 668, 0, - 885, 664, 665, 662, 392, 448, 467, 455, 0, 686, - 539, 540, 687, 650, 0, 802, 215, 853, 0, 0, - 0, 0, 0, 0, 0, 0, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, - 805, 0, 0, 0, 354, 0, 0, 387, 591, 573, - 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, - 534, 565, 535, 566, 567, 844, 590, 541, 457, 403, - 608, 607, 0, 0, 922, 930, 0, 0, 0, 0, - 0, 0, 0, 0, 918, 0, 0, 0, 0, 797, - 0, 0, 834, 898, 897, 821, 831, 0, 0, 323, - 238, 536, 656, 538, 537, 822, 0, 823, 827, 830, - 826, 824, 825, 0, 913, 0, 0, 0, 0, 0, - 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 798, 799, - 0, 0, 0, 0, 854, 0, 800, 0, 0, 849, - 828, 832, 0, 0, 0, 0, 0, 0, 311, 464, - 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, - 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, - 443, 352, 368, 349, 416, 829, 852, 856, 348, 936, - 850, 490, 315, 0, 489, 415, 476, 481, 401, 394, - 0, 314, 478, 399, 393, 381, 358, 937, 382, 383, - 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, - 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, - 847, 0, 653, 0, 492, 0, 0, 920, 0, 0, - 0, 463, 0, 0, 384, 0, 0, 0, 851, 0, - 446, 421, 933, 0, 0, 444, 389, 477, 432, 483, - 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, - 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, - 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, - 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, - 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, - 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, - 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, - 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, - 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, - 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, - 437, 363, 303, 304, 685, 917, 417, 618, 651, 652, - 543, 0, 932, 912, 914, 915, 919, 923, 924, 925, - 926, 927, 929, 931, 935, 684, 0, 597, 612, 688, - 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, - 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, - 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, - 637, 638, 639, 640, 641, 634, 934, 578, 555, 581, - 496, 558, 557, 0, 0, 592, 855, 593, 594, 407, - 408, 409, 410, 921, 619, 328, 515, 436, 0, 579, - 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, - 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, - 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, - 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, - 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, - 325, 484, 456, 395, 572, 599, 943, 916, 942, 944, - 945, 941, 946, 947, 928, 810, 0, 862, 863, 939, - 938, 940, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, - 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, - 682, 678, 674, 683, 0, 0, 0, 817, 305, 549, - 388, 177, 435, 361, 614, 615, 0, 666, 905, 871, - 872, 873, 807, 874, 868, 869, 808, 870, 906, 860, - 902, 903, 836, 865, 875, 901, 876, 904, 907, 908, - 948, 949, 882, 866, 267, 950, 879, 909, 900, 899, - 877, 861, 910, 911, 843, 838, 880, 881, 867, 886, - 887, 888, 809, 891, 892, 893, 894, 895, 889, 890, - 857, 858, 859, 883, 884, 864, 839, 840, 841, 842, - 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, - 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, - 0, 654, 655, 657, 659, 896, 661, 461, 462, 668, - 0, 885, 664, 665, 662, 392, 448, 467, 455, 853, - 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, - 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, - 0, 0, 805, 0, 0, 0, 354, 1962, 0, 387, - 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, - 563, 564, 534, 565, 535, 566, 567, 844, 590, 541, - 457, 403, 608, 607, 0, 0, 922, 930, 0, 0, - 0, 0, 0, 0, 0, 0, 918, 0, 2193, 0, - 0, 797, 0, 0, 834, 898, 897, 821, 831, 0, - 0, 323, 238, 536, 656, 538, 537, 822, 0, 823, - 827, 830, 826, 824, 825, 0, 913, 0, 0, 0, - 0, 0, 0, 789, 801, 0, 806, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 885, 664, 665, 662, 392, 448, 467, 455, 853, 686, + 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, + 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, + 0, 805, 0, 0, 0, 354, 4418, 0, 387, 591, + 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, + 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, + 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, + 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, + 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, + 323, 238, 536, 656, 538, 537, 822, 0, 823, 827, + 830, 826, 824, 825, 0, 913, 0, 0, 0, 0, + 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 798, 799, 0, 0, 0, 0, 854, 0, 800, 0, - 0, 2194, 828, 832, 0, 0, 0, 0, 0, 0, - 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, - 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, - 312, 0, 443, 352, 368, 349, 416, 829, 852, 856, - 348, 936, 850, 490, 315, 0, 489, 415, 476, 481, - 401, 394, 0, 314, 478, 399, 393, 381, 358, 937, - 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, - 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, + 799, 0, 0, 0, 0, 854, 0, 800, 0, 0, + 849, 828, 832, 0, 0, 0, 0, 0, 0, 311, + 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, + 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, + 0, 443, 352, 368, 349, 416, 829, 852, 856, 348, + 936, 850, 490, 315, 0, 489, 415, 476, 481, 401, + 394, 0, 314, 478, 399, 393, 381, 358, 937, 382, + 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, + 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 649, 847, 0, 653, 0, 492, 0, 0, 920, - 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, - 851, 0, 446, 421, 933, 0, 0, 444, 389, 477, - 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, - 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, - 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, - 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, - 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, - 505, 506, 595, 0, 511, 690, 691, 692, 520, 0, - 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, - 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, - 532, 596, 613, 580, 550, 513, 604, 547, 551, 552, - 375, 616, 0, 0, 0, 504, 385, 386, 0, 357, - 356, 398, 437, 363, 303, 304, 685, 917, 417, 618, - 651, 652, 543, 0, 932, 912, 914, 915, 919, 923, - 924, 925, 926, 927, 929, 931, 935, 684, 0, 597, - 612, 688, 611, 681, 423, 0, 450, 609, 556, 0, - 601, 575, 0, 602, 571, 606, 0, 545, 0, 458, - 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, - 635, 636, 637, 638, 639, 640, 641, 634, 934, 578, - 555, 581, 496, 558, 557, 0, 0, 592, 855, 593, - 594, 407, 408, 409, 410, 921, 619, 328, 515, 436, - 0, 579, 0, 0, 0, 0, 0, 0, 0, 0, - 584, 585, 582, 693, 0, 642, 643, 0, 0, 509, - 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, - 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, - 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, - 420, 447, 325, 484, 456, 395, 572, 599, 943, 916, - 942, 944, 945, 941, 946, 947, 928, 810, 0, 862, - 863, 939, 938, 940, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, - 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, - 338, 345, 682, 678, 674, 683, 0, 0, 0, 817, - 305, 549, 388, 0, 435, 361, 614, 615, 0, 666, - 905, 871, 872, 873, 807, 874, 868, 869, 808, 870, - 906, 860, 902, 903, 836, 865, 875, 901, 876, 904, - 907, 908, 948, 949, 882, 866, 267, 950, 879, 909, - 900, 899, 877, 861, 910, 911, 843, 838, 880, 881, - 867, 886, 887, 888, 809, 891, 892, 893, 894, 895, - 889, 890, 857, 858, 859, 883, 884, 864, 839, 840, - 841, 842, 0, 0, 500, 501, 502, 524, 0, 486, - 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, - 610, 644, 0, 654, 655, 657, 659, 896, 661, 461, - 462, 668, 0, 885, 664, 665, 662, 392, 448, 467, - 455, 0, 686, 539, 540, 687, 650, 0, 802, 215, - 853, 0, 0, 0, 0, 0, 0, 0, 0, 419, + 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, + 0, 0, 463, 0, 0, 384, 0, 0, 0, 851, + 0, 446, 421, 933, 0, 0, 444, 389, 477, 432, + 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, + 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, + 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, + 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, + 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, + 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, + 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, + 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, + 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, + 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, + 398, 437, 363, 303, 304, 685, 917, 417, 618, 651, + 652, 543, 0, 932, 912, 914, 915, 919, 923, 924, + 925, 926, 927, 929, 931, 935, 684, 0, 597, 612, + 688, 611, 681, 423, 0, 450, 609, 556, 0, 601, + 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, + 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, + 636, 637, 638, 639, 640, 641, 634, 934, 578, 555, + 581, 496, 558, 557, 0, 0, 592, 855, 593, 594, + 407, 408, 409, 410, 921, 619, 328, 515, 436, 0, + 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, + 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, + 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, + 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, + 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, + 447, 325, 484, 456, 395, 572, 599, 943, 916, 942, + 944, 945, 941, 946, 947, 928, 810, 0, 862, 863, + 939, 938, 940, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, + 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, + 345, 682, 678, 674, 683, 0, 0, 0, 817, 305, + 549, 388, 0, 435, 361, 614, 615, 0, 666, 905, + 871, 872, 873, 807, 874, 868, 869, 808, 870, 906, + 860, 902, 903, 836, 865, 875, 901, 876, 904, 907, + 908, 948, 949, 882, 866, 267, 950, 879, 909, 900, + 899, 877, 861, 910, 911, 843, 838, 880, 881, 867, + 886, 887, 888, 809, 891, 892, 893, 894, 895, 889, + 890, 857, 858, 859, 883, 884, 864, 839, 840, 841, + 842, 0, 0, 500, 501, 502, 524, 0, 486, 548, + 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, + 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, + 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, + 853, 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, - 562, 563, 564, 534, 565, 535, 566, 567, 1345, 590, + 562, 563, 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, 821, 831, @@ -2808,7 +2946,7 @@ var yyAct = [...]int{ 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, 0, 0, 463, 0, 0, 384, 0, 0, - 0, 851, 0, 446, 421, 933, 0, 0, 444, 389, + 0, 851, 0, 446, 421, 933, 4292, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, @@ -2839,7 +2977,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, - 817, 305, 549, 388, 177, 435, 361, 614, 615, 0, + 817, 305, 549, 388, 0, 435, 361, 614, 615, 0, 666, 905, 871, 872, 873, 807, 874, 868, 869, 808, 870, 906, 860, 902, 903, 836, 865, 875, 901, 876, 904, 907, 908, 948, 949, 882, 866, 267, 950, 879, @@ -2853,7 +2991,7 @@ var yyAct = [...]int{ 467, 455, 853, 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, - 4404, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 1969, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, @@ -2930,7 +3068,7 @@ var yyAct = [...]int{ 0, 913, 0, 0, 0, 0, 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 798, 799, 0, 0, 0, + 0, 0, 0, 0, 0, 798, 799, 1667, 0, 0, 0, 854, 0, 800, 0, 0, 849, 828, 832, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, @@ -2943,7 +3081,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 851, 0, 446, 421, 933, - 4278, 0, 444, 389, 477, 432, 483, 465, 491, 438, + 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, @@ -2984,143 +3122,143 @@ var yyAct = [...]int{ 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, 668, 0, 885, 664, - 665, 662, 392, 448, 467, 455, 853, 686, 539, 540, - 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, - 0, 0, 0, 354, 1962, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, - 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, - 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, - 0, 834, 898, 897, 821, 831, 0, 0, 323, 238, - 536, 656, 538, 537, 822, 0, 823, 827, 830, 826, - 824, 825, 0, 913, 0, 0, 0, 0, 0, 0, - 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 798, 799, 0, - 0, 0, 0, 854, 0, 800, 0, 0, 849, 828, - 832, 0, 0, 0, 0, 0, 0, 311, 464, 482, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 829, 852, 856, 348, 936, 850, - 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 937, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 649, 847, - 0, 653, 0, 492, 0, 0, 920, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 851, 0, 446, - 421, 933, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, - 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 917, 417, 618, 651, 652, 543, - 0, 932, 912, 914, 915, 919, 923, 924, 925, 926, - 927, 929, 931, 935, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 641, 634, 934, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 855, 593, 594, 407, 408, - 409, 410, 921, 619, 328, 515, 436, 0, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, - 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 395, 572, 599, 943, 916, 942, 944, 945, - 941, 946, 947, 928, 810, 0, 862, 863, 939, 938, - 940, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 817, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 905, 871, 872, - 873, 807, 874, 868, 869, 808, 870, 906, 860, 902, - 903, 836, 865, 875, 901, 876, 904, 907, 908, 948, - 949, 882, 866, 267, 950, 879, 909, 900, 899, 877, - 861, 910, 911, 843, 838, 880, 881, 867, 886, 887, - 888, 809, 891, 892, 893, 894, 895, 889, 890, 857, - 858, 859, 883, 884, 864, 839, 840, 841, 842, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 896, 661, 461, 462, 668, 0, - 885, 664, 665, 662, 392, 448, 467, 455, 853, 686, - 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, - 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, - 0, 805, 0, 0, 0, 354, 0, 0, 387, 591, - 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, - 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, - 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, - 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, - 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, - 323, 238, 536, 656, 538, 537, 822, 0, 823, 827, - 830, 826, 824, 825, 0, 913, 0, 0, 0, 0, - 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, + 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, + 687, 650, 853, 802, 0, 2375, 0, 0, 0, 0, + 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, + 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, + 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, + 844, 590, 541, 457, 403, 608, 607, 0, 0, 922, + 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, + 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, + 821, 831, 0, 0, 323, 238, 536, 656, 538, 537, + 822, 0, 823, 827, 830, 826, 824, 825, 0, 913, + 0, 0, 0, 0, 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, - 799, 1660, 0, 0, 0, 854, 0, 800, 0, 0, - 849, 828, 832, 0, 0, 0, 0, 0, 0, 311, - 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, - 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, - 0, 443, 352, 368, 349, 416, 829, 852, 856, 348, - 936, 850, 490, 315, 0, 489, 415, 476, 481, 401, - 394, 0, 314, 478, 399, 393, 381, 358, 937, 382, - 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, - 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, - 0, 0, 463, 0, 0, 384, 0, 0, 0, 851, - 0, 446, 421, 933, 0, 0, 444, 389, 477, 432, - 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, - 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, - 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, - 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, - 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, - 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, - 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, - 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, - 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, - 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, - 398, 437, 363, 303, 304, 685, 917, 417, 618, 651, - 652, 543, 0, 932, 912, 914, 915, 919, 923, 924, - 925, 926, 927, 929, 931, 935, 684, 0, 597, 612, - 688, 611, 681, 423, 0, 450, 609, 556, 0, 601, - 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, - 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, - 636, 637, 638, 639, 640, 641, 634, 934, 578, 555, - 581, 496, 558, 557, 0, 0, 592, 855, 593, 594, - 407, 408, 409, 410, 921, 619, 328, 515, 436, 0, - 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, - 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, - 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, - 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, - 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, - 447, 325, 484, 456, 395, 572, 599, 943, 916, 942, - 944, 945, 941, 946, 947, 928, 810, 0, 862, 863, - 939, 938, 940, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, - 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, - 345, 682, 678, 674, 683, 0, 0, 0, 817, 305, - 549, 388, 0, 435, 361, 614, 615, 0, 666, 905, - 871, 872, 873, 807, 874, 868, 869, 808, 870, 906, - 860, 902, 903, 836, 865, 875, 901, 876, 904, 907, - 908, 948, 949, 882, 866, 267, 950, 879, 909, 900, - 899, 877, 861, 910, 911, 843, 838, 880, 881, 867, - 886, 887, 888, 809, 891, 892, 893, 894, 895, 889, - 890, 857, 858, 859, 883, 884, 864, 839, 840, 841, - 842, 0, 0, 500, 501, 502, 524, 0, 486, 548, - 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, - 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, - 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, - 0, 686, 539, 540, 687, 650, 853, 802, 0, 2368, - 0, 0, 0, 0, 0, 419, 0, 0, 554, 587, + 0, 0, 0, 798, 799, 0, 0, 0, 0, 854, + 0, 800, 0, 0, 849, 828, 832, 0, 0, 0, + 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, + 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, + 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, + 829, 852, 856, 348, 936, 850, 490, 315, 0, 489, + 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, + 381, 358, 937, 382, 383, 372, 430, 391, 431, 373, + 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, + 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 649, 847, 0, 653, 0, 492, + 0, 0, 920, 0, 0, 0, 463, 0, 0, 384, + 0, 0, 0, 851, 0, 446, 421, 933, 0, 0, + 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, + 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, + 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, + 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, + 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, + 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, + 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, + 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, + 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, + 547, 551, 552, 375, 616, 0, 0, 0, 504, 385, + 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, + 917, 417, 618, 651, 652, 543, 0, 932, 912, 914, + 915, 919, 923, 924, 925, 926, 927, 929, 931, 935, + 684, 0, 597, 612, 688, 611, 681, 423, 0, 450, + 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, + 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, + 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, + 634, 934, 578, 555, 581, 496, 558, 557, 0, 0, + 592, 855, 593, 594, 407, 408, 409, 410, 921, 619, + 328, 515, 436, 0, 579, 0, 0, 0, 0, 0, + 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, + 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, + 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, + 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, + 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, + 599, 943, 916, 942, 944, 945, 941, 946, 947, 928, + 810, 0, 862, 863, 939, 938, 940, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, + 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, + 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, + 0, 0, 817, 305, 549, 388, 0, 435, 361, 614, + 615, 0, 666, 905, 871, 872, 873, 807, 874, 868, + 869, 808, 870, 906, 860, 902, 903, 836, 865, 875, + 901, 876, 904, 907, 908, 948, 949, 882, 866, 267, + 950, 879, 909, 900, 899, 877, 861, 910, 911, 843, + 838, 880, 881, 867, 886, 887, 888, 809, 891, 892, + 893, 894, 895, 889, 890, 857, 858, 859, 883, 884, + 864, 839, 840, 841, 842, 0, 0, 500, 501, 502, + 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, + 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, + 896, 661, 461, 462, 668, 0, 885, 664, 665, 662, + 392, 448, 467, 455, 853, 686, 539, 540, 687, 650, + 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, + 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, + 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, + 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, + 566, 567, 844, 590, 541, 457, 403, 608, 607, 0, + 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, + 0, 918, 0, 0, 0, 0, 797, 0, 0, 834, + 898, 897, 821, 831, 0, 0, 323, 238, 536, 656, + 538, 537, 822, 0, 823, 827, 830, 826, 824, 825, + 0, 913, 0, 0, 0, 0, 0, 0, 789, 801, + 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 798, 799, 1962, 0, 0, + 0, 854, 0, 800, 0, 0, 849, 828, 832, 0, + 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, + 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, + 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, + 349, 416, 829, 852, 856, 348, 936, 850, 490, 315, + 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, + 399, 393, 381, 358, 937, 382, 383, 372, 430, 391, + 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, + 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 649, 847, 0, 653, + 0, 492, 0, 0, 920, 0, 0, 0, 463, 0, + 0, 384, 0, 0, 0, 851, 0, 446, 421, 933, + 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, + 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, + 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, + 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, + 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, + 428, 473, 472, 321, 499, 505, 506, 595, 0, 511, + 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, + 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, + 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, + 513, 604, 547, 551, 552, 375, 616, 0, 0, 0, + 504, 385, 386, 0, 357, 356, 398, 437, 363, 303, + 304, 685, 917, 417, 618, 651, 652, 543, 0, 932, + 912, 914, 915, 919, 923, 924, 925, 926, 927, 929, + 931, 935, 684, 0, 597, 612, 688, 611, 681, 423, + 0, 450, 609, 556, 0, 601, 575, 0, 602, 571, + 606, 0, 545, 0, 458, 485, 497, 514, 517, 546, + 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, + 640, 641, 634, 934, 578, 555, 581, 496, 558, 557, + 0, 0, 592, 855, 593, 594, 407, 408, 409, 410, + 921, 619, 328, 515, 436, 0, 579, 0, 0, 0, + 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, + 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, + 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, + 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, + 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, + 395, 572, 599, 943, 916, 942, 944, 945, 941, 946, + 947, 928, 810, 0, 862, 863, 939, 938, 940, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, + 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, + 683, 0, 0, 0, 817, 305, 549, 388, 0, 435, + 361, 614, 615, 0, 666, 905, 871, 872, 873, 807, + 874, 868, 869, 808, 870, 906, 860, 902, 903, 836, + 865, 875, 901, 876, 904, 907, 908, 948, 949, 882, + 866, 267, 950, 879, 909, 900, 899, 877, 861, 910, + 911, 843, 838, 880, 881, 867, 886, 887, 888, 809, + 891, 892, 893, 894, 895, 889, 890, 857, 858, 859, + 883, 884, 864, 839, 840, 841, 842, 0, 0, 500, + 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, + 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, + 657, 659, 896, 661, 461, 462, 668, 0, 885, 664, + 665, 662, 392, 448, 467, 455, 853, 686, 539, 540, + 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, @@ -3200,7 +3338,7 @@ var yyAct = [...]int{ 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, - 799, 1955, 0, 0, 0, 854, 0, 800, 0, 0, + 799, 0, 0, 0, 0, 854, 0, 800, 0, 0, 849, 828, 832, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, @@ -3253,7 +3391,7 @@ var yyAct = [...]int{ 842, 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, - 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, + 668, 0, 3812, 664, 3813, 3814, 392, 448, 467, 455, 853, 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, 0, 0, @@ -3262,8 +3400,8 @@ var yyAct = [...]int{ 541, 457, 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, 821, 831, - 0, 0, 323, 238, 536, 656, 538, 537, 822, 0, - 823, 827, 830, 826, 824, 825, 0, 913, 0, 0, + 0, 0, 323, 238, 536, 656, 538, 537, 2907, 0, + 2908, 827, 830, 826, 824, 825, 0, 913, 0, 0, 0, 0, 0, 0, 789, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3323,7 +3461,7 @@ var yyAct = [...]int{ 461, 462, 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, 853, 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, - 0, 0, 0, 0, 0, 805, 0, 0, 0, 354, + 0, 1812, 0, 0, 0, 805, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, 607, 0, 0, 922, @@ -3331,7 +3469,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, 323, 238, 536, 656, 538, 537, 822, 0, 823, 827, 830, 826, 824, 825, 0, 913, - 0, 0, 0, 0, 0, 0, 789, 801, 0, 806, + 0, 0, 0, 0, 0, 0, 0, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, 799, 0, 0, 0, 0, 854, @@ -3352,7 +3490,7 @@ var yyAct = [...]int{ 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, - 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, + 472, 321, 499, 1813, 1814, 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, @@ -3387,7 +3525,7 @@ var yyAct = [...]int{ 864, 839, 840, 841, 842, 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, - 896, 661, 461, 462, 668, 0, 3798, 664, 3799, 3800, + 896, 661, 461, 462, 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, 853, 686, 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 805, 0, 0, @@ -3397,8 +3535,8 @@ var yyAct = [...]int{ 0, 922, 930, 0, 0, 0, 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, 323, 238, 536, 656, - 538, 537, 2893, 0, 2894, 827, 830, 826, 824, 825, - 0, 913, 0, 0, 0, 0, 0, 0, 789, 801, + 538, 537, 822, 0, 823, 827, 830, 826, 824, 825, + 0, 913, 0, 0, 0, 0, 0, 0, 0, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, 799, 0, 0, 0, @@ -3455,489 +3593,86 @@ var yyAct = [...]int{ 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, 668, 0, 885, 664, - 665, 662, 392, 448, 467, 455, 853, 686, 539, 540, - 687, 650, 0, 802, 0, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 1805, 0, 0, 0, 805, - 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 844, 590, 541, 457, 403, 608, - 607, 0, 0, 922, 930, 0, 0, 0, 0, 0, - 0, 0, 0, 918, 0, 0, 0, 0, 797, 0, - 0, 834, 898, 897, 821, 831, 0, 0, 323, 238, - 536, 656, 538, 537, 822, 0, 823, 827, 830, 826, - 824, 825, 0, 913, 0, 0, 0, 0, 0, 0, - 0, 801, 0, 806, 0, 0, 0, 0, 0, 0, + 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, + 687, 650, 0, 802, 215, 66, 206, 176, 0, 0, + 0, 0, 0, 0, 419, 0, 0, 554, 587, 576, + 660, 542, 0, 207, 0, 0, 0, 0, 0, 0, + 198, 0, 354, 0, 208, 387, 591, 573, 583, 574, + 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, + 535, 566, 567, 147, 590, 541, 457, 403, 608, 607, + 0, 0, 0, 0, 0, 0, 0, 0, 133, 0, + 0, 0, 0, 0, 0, 0, 0, 211, 0, 0, + 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, + 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 798, 799, 0, - 0, 0, 0, 854, 0, 800, 0, 0, 849, 828, - 832, 0, 0, 0, 0, 0, 0, 311, 464, 482, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 829, 852, 856, 348, 936, 850, - 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 937, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 649, 847, - 0, 653, 0, 492, 0, 0, 920, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 851, 0, 446, - 421, 933, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, - 310, 396, 428, 473, 472, 321, 499, 1806, 1807, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 917, 417, 618, 651, 652, 543, - 0, 932, 912, 914, 915, 919, 923, 924, 925, 926, - 927, 929, 931, 935, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 641, 634, 934, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 855, 593, 594, 407, 408, - 409, 410, 921, 619, 328, 515, 436, 0, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, - 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 395, 572, 599, 943, 916, 942, 944, 945, - 941, 946, 947, 928, 810, 0, 862, 863, 939, 938, - 940, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 817, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 905, 871, 872, - 873, 807, 874, 868, 869, 808, 870, 906, 860, 902, - 903, 836, 865, 875, 901, 876, 904, 907, 908, 948, - 949, 882, 866, 267, 950, 879, 909, 900, 899, 877, - 861, 910, 911, 843, 838, 880, 881, 867, 886, 887, - 888, 809, 891, 892, 893, 894, 895, 889, 890, 857, - 858, 859, 883, 884, 864, 839, 840, 841, 842, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 896, 661, 461, 462, 668, 0, - 885, 664, 665, 662, 392, 448, 467, 455, 853, 686, - 539, 540, 687, 650, 0, 802, 0, 419, 0, 0, - 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, - 0, 805, 0, 0, 0, 354, 0, 0, 387, 591, - 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, - 564, 534, 565, 535, 566, 567, 844, 590, 541, 457, - 403, 608, 607, 0, 0, 922, 930, 0, 0, 0, - 0, 0, 0, 0, 0, 918, 0, 0, 0, 0, - 797, 0, 0, 834, 898, 897, 821, 831, 0, 0, - 323, 238, 536, 656, 538, 537, 822, 0, 823, 827, - 830, 826, 824, 825, 0, 913, 0, 0, 0, 0, - 0, 0, 0, 801, 0, 806, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 798, - 799, 0, 0, 0, 0, 854, 0, 800, 0, 0, - 849, 828, 832, 0, 0, 0, 0, 0, 0, 311, - 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, - 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, - 0, 443, 352, 368, 349, 416, 829, 852, 856, 348, - 936, 850, 490, 315, 0, 489, 415, 476, 481, 401, - 394, 0, 314, 478, 399, 393, 381, 358, 937, 382, - 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, - 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 649, 847, 0, 653, 0, 492, 0, 0, 920, 0, - 0, 0, 463, 0, 0, 384, 0, 0, 0, 851, - 0, 446, 421, 933, 0, 0, 444, 389, 477, 432, - 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, - 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, - 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, - 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, - 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, - 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, - 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, - 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, - 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, - 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, - 398, 437, 363, 303, 304, 685, 917, 417, 618, 651, - 652, 543, 0, 932, 912, 914, 915, 919, 923, 924, - 925, 926, 927, 929, 931, 935, 684, 0, 597, 612, - 688, 611, 681, 423, 0, 450, 609, 556, 0, 601, - 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, - 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, - 636, 637, 638, 639, 640, 641, 634, 934, 578, 555, - 581, 496, 558, 557, 0, 0, 592, 855, 593, 594, - 407, 408, 409, 410, 921, 619, 328, 515, 436, 0, - 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, - 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, - 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, - 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, - 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, - 447, 325, 484, 456, 395, 572, 599, 943, 916, 942, - 944, 945, 941, 946, 947, 928, 810, 0, 862, 863, - 939, 938, 940, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, - 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, - 345, 682, 678, 674, 683, 0, 0, 0, 817, 305, - 549, 388, 0, 435, 361, 614, 615, 0, 666, 905, - 871, 872, 873, 807, 874, 868, 869, 808, 870, 906, - 860, 902, 903, 836, 865, 875, 901, 876, 904, 907, - 908, 948, 949, 882, 866, 267, 950, 879, 909, 900, - 899, 877, 861, 910, 911, 843, 838, 880, 881, 867, - 886, 887, 888, 809, 891, 892, 893, 894, 895, 889, - 890, 857, 858, 859, 883, 884, 864, 839, 840, 841, - 842, 0, 0, 500, 501, 502, 524, 0, 486, 548, - 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, - 644, 0, 654, 655, 657, 659, 896, 661, 461, 462, - 668, 0, 885, 664, 665, 662, 392, 448, 467, 455, - 0, 686, 539, 540, 687, 650, 0, 802, 215, 66, - 206, 176, 0, 0, 0, 0, 0, 0, 419, 0, - 0, 554, 587, 576, 660, 542, 0, 207, 0, 0, - 0, 0, 0, 0, 198, 0, 354, 0, 208, 387, - 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, - 563, 564, 534, 565, 535, 566, 567, 147, 590, 541, - 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, - 0, 0, 133, 0, 0, 0, 0, 0, 0, 0, - 0, 211, 0, 0, 237, 0, 0, 0, 0, 0, - 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 229, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, - 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, - 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, - 348, 498, 0, 490, 315, 0, 489, 415, 476, 481, - 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, - 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, - 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, - 0, 0, 0, 0, 175, 204, 213, 205, 131, 0, - 0, 649, 0, 0, 653, 0, 492, 0, 0, 230, - 0, 0, 0, 463, 0, 0, 384, 203, 197, 196, - 508, 0, 446, 421, 242, 0, 0, 444, 389, 477, - 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, - 320, 322, 250, 353, 355, 359, 360, 411, 412, 426, - 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, - 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, - 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, - 505, 506, 595, 0, 511, 628, 629, 630, 520, 0, - 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, - 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, - 532, 596, 613, 580, 550, 513, 604, 547, 551, 552, - 375, 616, 0, 0, 0, 504, 385, 386, 0, 357, - 356, 398, 437, 363, 303, 304, 487, 347, 417, 618, - 651, 652, 543, 0, 605, 544, 553, 339, 577, 589, - 588, 413, 503, 233, 600, 603, 533, 243, 0, 597, - 612, 570, 611, 244, 423, 0, 450, 609, 556, 0, - 601, 575, 0, 602, 571, 606, 0, 545, 0, 458, - 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, - 635, 636, 637, 638, 639, 640, 641, 634, 488, 578, - 555, 581, 496, 558, 557, 0, 0, 592, 512, 593, - 594, 407, 408, 409, 410, 367, 619, 328, 515, 436, - 145, 579, 0, 0, 0, 0, 0, 0, 0, 0, - 584, 585, 582, 241, 0, 642, 643, 0, 0, 509, - 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, - 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, - 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, - 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, - 0, 0, 0, 0, 0, 0, 67, 0, 0, 290, - 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, - 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, - 338, 345, 248, 318, 674, 249, 0, 0, 0, 0, - 305, 549, 388, 177, 435, 361, 614, 615, 63, 666, - 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, - 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, - 272, 273, 274, 275, 617, 266, 267, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 0, 0, 0, 299, 669, 670, 671, 672, 673, - 0, 0, 300, 301, 302, 0, 0, 292, 293, 294, - 295, 296, 0, 0, 500, 501, 502, 524, 0, 486, - 548, 245, 46, 231, 234, 236, 235, 0, 64, 598, - 610, 644, 5, 654, 655, 657, 659, 658, 661, 461, - 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, - 455, 150, 246, 539, 540, 247, 650, 215, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 419, 0, 0, - 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, - 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, - 564, 534, 565, 535, 566, 567, 147, 590, 541, 457, - 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 211, 0, 0, 237, 0, 0, 0, 0, 0, 0, - 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 326, 2547, 2550, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, - 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, - 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, - 0, 443, 352, 368, 349, 416, 0, 479, 507, 348, - 498, 0, 490, 315, 0, 489, 415, 476, 481, 401, - 394, 0, 314, 478, 399, 393, 381, 358, 523, 382, - 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, - 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 649, 0, 0, 653, 2551, 492, 0, 0, 0, 2546, - 0, 2545, 463, 2543, 2548, 384, 0, 0, 0, 508, - 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, - 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, - 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, - 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, - 342, 340, 343, 453, 344, 309, 427, 474, 2549, 365, - 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, - 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, - 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, - 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, - 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, - 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, - 398, 437, 363, 303, 304, 685, 347, 417, 618, 651, - 652, 543, 0, 605, 544, 553, 339, 577, 589, 588, - 413, 503, 0, 600, 603, 533, 684, 0, 597, 612, - 688, 611, 681, 423, 0, 450, 609, 556, 0, 601, - 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, - 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, - 636, 637, 638, 639, 640, 641, 634, 488, 578, 555, - 581, 496, 558, 557, 0, 0, 592, 512, 593, 594, - 407, 408, 409, 410, 367, 619, 328, 515, 436, 0, - 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, - 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, - 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, - 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, - 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, - 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, - 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, - 345, 682, 678, 674, 683, 0, 0, 0, 0, 305, - 549, 388, 177, 435, 361, 614, 615, 0, 666, 251, - 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, - 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, - 273, 274, 275, 617, 266, 267, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 0, 0, 0, 299, 669, 670, 671, 672, 673, 0, - 0, 300, 301, 302, 0, 0, 292, 293, 294, 295, - 296, 0, 0, 500, 501, 502, 524, 0, 486, 548, - 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, - 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, - 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, - 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, - 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, - 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, - 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1381, - 0, 0, 237, 0, 0, 821, 831, 0, 0, 323, - 238, 536, 656, 538, 537, 822, 0, 823, 827, 830, - 826, 824, 825, 0, 326, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 828, 0, 0, 0, 0, 0, 0, 0, 311, 464, - 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, - 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, - 443, 352, 368, 349, 416, 829, 479, 507, 348, 498, - 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, - 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, - 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, - 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, - 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, - 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, - 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, - 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, - 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, - 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, - 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, - 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, - 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, - 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, - 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, - 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, - 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, - 437, 363, 303, 304, 685, 347, 417, 618, 651, 652, - 543, 0, 605, 544, 553, 339, 577, 589, 588, 413, - 503, 0, 600, 603, 533, 684, 0, 597, 612, 688, - 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, - 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, - 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, - 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, - 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, - 408, 409, 410, 367, 619, 328, 515, 436, 0, 579, - 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, - 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, - 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, - 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, - 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, - 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, - 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, - 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, - 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, - 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, - 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, - 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, - 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, - 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, - 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, - 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, - 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, - 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, - 686, 539, 540, 687, 650, 215, 66, 206, 176, 0, - 0, 0, 0, 0, 0, 419, 712, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, - 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 719, 0, 0, 0, 0, 0, 0, 0, 718, 0, - 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, - 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 0, 479, 507, 348, 498, 0, - 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 716, 717, 0, 649, 0, - 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, - 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, - 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, - 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, - 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, - 409, 410, 713, 715, 328, 515, 436, 727, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, - 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, - 0, 0, 0, 67, 0, 0, 290, 291, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, - 177, 435, 361, 614, 615, 0, 666, 251, 252, 253, - 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, - 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, - 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, - 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, - 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, - 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, - 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, - 660, 542, 0, 1186, 0, 0, 0, 0, 0, 0, - 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, - 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, - 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, - 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1171, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, - 2718, 2721, 2722, 2723, 2724, 2725, 2726, 0, 2731, 2727, - 2728, 2729, 2730, 0, 2713, 2714, 2715, 2716, 1169, 2697, - 2719, 0, 2698, 415, 2699, 2700, 2701, 2702, 1173, 2703, - 2704, 2705, 2706, 2707, 2710, 2711, 2708, 2709, 2717, 430, - 391, 431, 373, 405, 404, 406, 1197, 1199, 1201, 1203, - 1206, 518, 519, 0, 0, 667, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, - 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, - 0, 0, 384, 0, 0, 0, 2712, 0, 446, 421, - 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, - 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, + 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, + 368, 349, 416, 0, 479, 507, 348, 498, 0, 490, + 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, + 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, + 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, + 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, + 175, 204, 213, 205, 131, 0, 0, 649, 0, 0, + 653, 0, 492, 0, 0, 230, 0, 0, 0, 463, + 0, 0, 384, 203, 197, 196, 508, 0, 446, 421, + 242, 0, 0, 444, 389, 477, 432, 483, 465, 491, + 438, 433, 306, 466, 351, 402, 320, 322, 250, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, - 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, + 511, 628, 629, 630, 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, - 303, 304, 685, 347, 417, 618, 651, 652, 543, 0, - 605, 544, 553, 339, 577, 589, 588, 413, 503, 0, - 600, 603, 533, 684, 0, 597, 612, 688, 611, 681, + 303, 304, 487, 347, 417, 618, 651, 652, 543, 0, + 605, 544, 553, 339, 577, 589, 588, 413, 503, 233, + 600, 603, 533, 243, 0, 597, 612, 570, 611, 244, 423, 0, 450, 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, 409, - 410, 367, 619, 328, 515, 436, 0, 579, 0, 0, - 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, + 410, 367, 619, 328, 515, 436, 145, 579, 0, 0, + 0, 0, 0, 0, 0, 0, 584, 585, 582, 241, 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, + 0, 0, 67, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, - 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, - 674, 683, 0, 0, 0, 0, 305, 2720, 388, 0, - 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, + 0, 569, 471, 341, 297, 337, 338, 345, 248, 318, + 674, 249, 0, 0, 0, 0, 305, 549, 388, 177, + 435, 361, 614, 615, 63, 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, 0, - 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, - 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, + 500, 501, 502, 524, 0, 486, 548, 245, 46, 231, + 234, 236, 235, 0, 64, 598, 610, 644, 5, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, - 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, - 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, + 664, 665, 662, 392, 448, 467, 455, 150, 246, 539, + 540, 247, 650, 215, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, - 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, + 566, 567, 147, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, + 0, 0, 0, 0, 0, 0, 211, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 326, 2547, 2550, 0, 0, 0, 0, 0, 0, + 0, 326, 2554, 2557, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3951,13 +3686,13 @@ var yyAct = [...]int{ 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, - 2551, 492, 0, 0, 0, 2546, 0, 2545, 463, 2543, - 2548, 384, 0, 0, 0, 508, 0, 446, 421, 689, + 2558, 492, 0, 0, 0, 2553, 0, 2552, 463, 2550, + 2555, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, - 344, 309, 427, 474, 2549, 365, 441, 397, 310, 396, + 344, 309, 427, 474, 2556, 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, @@ -3983,7 +3718,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, - 683, 0, 0, 0, 0, 305, 549, 388, 0, 435, + 683, 0, 0, 0, 0, 305, 549, 388, 177, 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, @@ -4001,26 +3736,26 @@ var yyAct = [...]int{ 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, - 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, - 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 326, 0, 2568, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1388, 0, 0, 237, 0, + 0, 821, 831, 0, 0, 323, 238, 536, 656, 538, + 537, 822, 0, 823, 827, 830, 826, 824, 825, 0, + 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 828, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, - 416, 0, 479, 507, 348, 498, 0, 490, 315, 0, + 416, 829, 479, 507, 348, 498, 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 649, 0, 0, 653, 2567, - 492, 0, 0, 0, 2573, 2570, 2572, 463, 0, 2571, + 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, + 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, - 2565, 444, 389, 477, 432, 483, 465, 491, 438, 433, + 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, @@ -4062,16 +3797,17 @@ var yyAct = [...]int{ 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, - 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, + 650, 215, 66, 206, 176, 0, 0, 0, 0, 0, + 0, 419, 712, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 0, 0, 0, 0, 0, 0, 719, 0, 0, 0, + 0, 0, 0, 0, 718, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, - 0, 2568, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4084,8 +3820,8 @@ var yyAct = [...]int{ 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 649, 0, 0, 653, 2567, 492, - 0, 0, 0, 2573, 2570, 2572, 463, 0, 2571, 384, + 0, 716, 717, 0, 649, 0, 0, 653, 0, 492, + 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, @@ -4105,19 +3841,19 @@ var yyAct = [...]int{ 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, 558, 557, 0, 0, - 592, 512, 593, 594, 407, 408, 409, 410, 367, 619, - 328, 515, 436, 0, 579, 0, 0, 0, 0, 0, + 592, 512, 593, 594, 407, 408, 409, 410, 713, 715, + 328, 515, 436, 727, 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, - 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 599, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, - 0, 0, 0, 305, 549, 388, 0, 435, 361, 614, + 0, 0, 0, 305, 549, 388, 177, 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, @@ -4129,284 +3865,149 @@ var yyAct = [...]int{ 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, - 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, - 0, 0, 0, 2234, 0, 0, 0, 0, 354, 0, + 419, 0, 0, 554, 587, 576, 660, 542, 0, 1186, + 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 237, 0, 0, 2235, - 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, - 0, 1308, 1309, 1310, 1307, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, - 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, - 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, - 479, 507, 348, 498, 0, 490, 315, 0, 489, 415, - 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, - 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, - 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, - 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, - 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, - 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, - 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, - 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, - 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, - 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, - 474, 0, 365, 441, 397, 310, 396, 428, 473, 472, - 321, 499, 505, 506, 595, 0, 511, 690, 691, 692, - 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, - 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, - 530, 531, 532, 596, 613, 580, 550, 513, 604, 547, - 551, 552, 375, 616, 0, 0, 0, 504, 385, 386, - 0, 357, 356, 398, 437, 363, 303, 304, 685, 347, - 417, 618, 651, 652, 543, 0, 605, 544, 553, 339, - 577, 589, 588, 413, 503, 0, 600, 603, 533, 684, - 0, 597, 612, 688, 611, 681, 423, 0, 450, 609, - 556, 0, 601, 575, 0, 602, 571, 606, 0, 545, - 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, - 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, - 488, 578, 555, 581, 496, 558, 557, 0, 0, 592, - 512, 593, 594, 407, 408, 409, 410, 367, 619, 328, - 515, 436, 0, 579, 0, 0, 0, 0, 0, 0, - 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, - 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, - 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, - 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, - 442, 493, 420, 447, 325, 484, 456, 395, 572, 599, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, - 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, - 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, - 0, 0, 305, 549, 388, 0, 435, 361, 614, 615, - 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, - 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, - 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 0, 0, 0, 299, 669, 670, 671, - 672, 673, 0, 0, 300, 301, 302, 0, 0, 292, - 293, 294, 295, 296, 0, 0, 500, 501, 502, 524, - 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, - 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, - 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, - 448, 467, 455, 215, 686, 539, 540, 687, 650, 0, - 0, 0, 0, 419, 0, 0, 554, 587, 576, 660, - 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, - 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, - 566, 567, 147, 590, 541, 457, 403, 608, 607, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 211, 2284, 0, 237, - 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, - 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, - 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, - 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, - 349, 416, 0, 479, 507, 348, 498, 0, 490, 315, - 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, - 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, - 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, - 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, - 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, - 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, - 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, - 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, - 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, - 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, - 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, - 428, 473, 472, 321, 499, 505, 506, 595, 0, 511, - 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, - 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, - 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, - 513, 604, 547, 551, 552, 375, 616, 0, 0, 0, - 504, 385, 386, 0, 357, 356, 398, 437, 363, 303, - 304, 685, 347, 417, 618, 651, 652, 543, 0, 605, - 544, 553, 339, 577, 589, 588, 413, 503, 0, 600, - 603, 533, 684, 0, 597, 612, 688, 611, 681, 423, - 0, 450, 609, 556, 0, 601, 575, 0, 602, 571, - 606, 0, 545, 0, 458, 485, 497, 514, 517, 546, - 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, - 640, 641, 634, 488, 578, 555, 581, 496, 558, 557, - 0, 0, 592, 512, 593, 594, 407, 408, 409, 410, - 367, 619, 328, 515, 436, 0, 579, 0, 0, 0, - 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, - 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, - 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, - 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, - 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, - 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, - 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, - 683, 0, 0, 0, 0, 305, 549, 388, 177, 435, - 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, - 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, - 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, - 266, 267, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 0, 0, 0, 299, - 669, 670, 671, 672, 673, 0, 0, 300, 301, 302, - 0, 0, 292, 293, 294, 295, 296, 0, 0, 500, - 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, - 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, - 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, - 665, 662, 392, 448, 467, 455, 215, 686, 539, 540, - 687, 650, 0, 0, 0, 0, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, - 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, - 534, 565, 535, 566, 567, 147, 590, 541, 457, 403, - 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 211, - 2269, 0, 237, 0, 0, 0, 0, 0, 0, 323, - 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, - 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, - 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, - 443, 352, 368, 349, 416, 0, 479, 507, 348, 498, - 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, - 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, - 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, - 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, - 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, - 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, - 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, - 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, - 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, - 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, - 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, - 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, - 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, - 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, - 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, - 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, - 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, - 437, 363, 303, 304, 685, 347, 417, 618, 651, 652, - 543, 0, 605, 544, 553, 339, 577, 589, 588, 413, - 503, 0, 600, 603, 533, 684, 0, 597, 612, 688, - 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, - 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, - 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, - 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, - 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, - 408, 409, 410, 367, 619, 328, 515, 436, 0, 579, - 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, - 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, - 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, - 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, - 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, - 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, + 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, + 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, - 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, - 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, - 388, 177, 435, 361, 614, 615, 0, 666, 251, 252, - 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, - 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, - 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, - 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, - 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, - 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, - 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, - 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, - 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, - 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 1096, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, - 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 237, 1103, 1104, 0, 0, 0, 0, 323, 238, - 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1171, 0, 0, 0, 0, 0, 0, + 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, + 475, 319, 418, 449, 0, 0, 2732, 2735, 2736, 2737, + 2738, 2739, 2740, 0, 2745, 2741, 2742, 2743, 2744, 0, + 2720, 2721, 2722, 2723, 1169, 2704, 2733, 0, 2705, 415, + 2706, 2707, 2708, 2709, 1173, 2710, 2711, 2712, 2713, 2714, + 2717, 2718, 2715, 2716, 2724, 2725, 2726, 2727, 2728, 2729, + 2730, 2731, 1204, 1206, 1208, 1210, 1213, 518, 519, 0, + 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, + 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, + 0, 0, 2719, 0, 446, 421, 689, 0, 0, 444, + 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, + 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, + 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, + 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, + 474, 0, 365, 441, 397, 310, 396, 428, 473, 472, + 321, 499, 505, 506, 595, 0, 511, 690, 691, 692, + 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, + 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, + 530, 531, 532, 596, 613, 580, 550, 513, 604, 547, + 551, 552, 375, 616, 0, 0, 0, 504, 385, 386, + 0, 357, 356, 398, 437, 363, 303, 304, 685, 347, + 417, 618, 651, 652, 543, 0, 605, 544, 553, 339, + 577, 589, 588, 413, 503, 0, 600, 603, 533, 684, + 0, 597, 612, 688, 611, 681, 423, 0, 450, 609, + 556, 0, 601, 575, 0, 602, 571, 606, 0, 545, + 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, + 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, + 488, 578, 555, 581, 496, 558, 557, 0, 0, 592, + 512, 593, 594, 407, 408, 409, 410, 367, 619, 328, + 515, 436, 0, 579, 0, 0, 0, 0, 0, 0, + 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, + 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, + 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, + 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, + 442, 493, 420, 447, 325, 484, 456, 395, 572, 599, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, + 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, + 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, + 0, 0, 305, 2734, 388, 0, 435, 361, 614, 615, + 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, + 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, + 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 0, 0, 0, 299, 669, 670, 671, + 672, 673, 0, 0, 300, 301, 302, 0, 0, 292, + 293, 294, 295, 296, 0, 0, 500, 501, 502, 524, + 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, + 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, + 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, + 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, + 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, + 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, + 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, + 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, + 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 326, 2554, 2557, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 311, 464, 1090, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 0, 479, 507, 348, 498, 1075, - 490, 315, 1074, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, - 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, - 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 1094, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, - 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, - 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, - 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 1095, 634, 488, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 1098, 593, 594, 407, 408, - 409, 410, 367, 619, 1093, 515, 436, 0, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 1105, - 1091, 1101, 1092, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 1102, 572, 599, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, - 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, - 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, - 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, - 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, - 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, - 663, 664, 665, 662, 1089, 448, 467, 455, 215, 686, - 539, 540, 687, 650, 0, 0, 0, 0, 419, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, + 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, + 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, + 507, 348, 498, 0, 490, 315, 0, 489, 415, 476, + 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, + 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, + 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, + 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 649, 0, 0, 653, 2558, 492, 0, 0, + 0, 2553, 0, 2552, 463, 2550, 2555, 384, 0, 0, + 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, + 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, + 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, + 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, + 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, + 2556, 365, 441, 397, 310, 396, 428, 473, 472, 321, + 499, 505, 506, 595, 0, 511, 690, 691, 692, 520, + 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, + 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, + 531, 532, 596, 613, 580, 550, 513, 604, 547, 551, + 552, 375, 616, 0, 0, 0, 504, 385, 386, 0, + 357, 356, 398, 437, 363, 303, 304, 685, 347, 417, + 618, 651, 652, 543, 0, 605, 544, 553, 339, 577, + 589, 588, 413, 503, 0, 600, 603, 533, 684, 0, + 597, 612, 688, 611, 681, 423, 0, 450, 609, 556, + 0, 601, 575, 0, 602, 571, 606, 0, 545, 0, + 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, + 516, 635, 636, 637, 638, 639, 640, 641, 634, 488, + 578, 555, 581, 496, 558, 557, 0, 0, 592, 512, + 593, 594, 407, 408, 409, 410, 367, 619, 328, 515, + 436, 0, 579, 0, 0, 0, 0, 0, 0, 0, + 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, + 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, + 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, + 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, + 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, + 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, + 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, + 0, 305, 549, 388, 0, 435, 361, 614, 615, 0, + 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, + 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, + 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 0, 0, 0, 299, 669, 670, 671, 672, + 673, 0, 0, 300, 301, 302, 0, 0, 292, 293, + 294, 295, 296, 0, 0, 500, 501, 502, 524, 0, + 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, + 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, + 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, + 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, - 563, 564, 534, 565, 535, 566, 567, 147, 590, 541, + 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2165, 0, 0, 237, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 326, 0, 2575, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4420,9 +4021,9 @@ var yyAct = [...]int{ 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, - 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, - 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, + 0, 649, 0, 0, 653, 2574, 492, 0, 0, 0, + 2580, 2577, 2579, 463, 0, 2578, 384, 0, 0, 0, + 508, 0, 446, 421, 689, 0, 2572, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, @@ -4453,7 +4054,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, 0, - 305, 549, 388, 177, 435, 361, 614, 615, 0, 666, + 305, 549, 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, 278, @@ -4471,9 +4072,9 @@ var yyAct = [...]int{ 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 1103, 1104, 0, 0, 0, 0, + 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1107, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 326, 0, 2575, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4482,13 +4083,13 @@ var yyAct = [...]int{ 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, 348, - 498, 1075, 490, 315, 1074, 489, 415, 476, 481, 401, + 498, 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, - 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, + 649, 0, 0, 653, 2574, 492, 0, 0, 0, 2580, + 2577, 2579, 463, 0, 2578, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, @@ -4513,8 +4114,8 @@ var yyAct = [...]int{ 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, - 0, 1105, 2186, 1101, 2187, 380, 390, 442, 493, 420, - 447, 325, 484, 456, 1102, 572, 599, 0, 0, 0, + 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, + 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, @@ -4532,16 +4133,16 @@ var yyAct = [...]int{ 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 3145, 0, 0, 0, + 587, 576, 660, 542, 0, 0, 0, 0, 0, 2241, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 0, 0, 237, 0, 0, 2242, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 326, 0, 0, 1315, 1316, 1317, + 1314, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4553,7 +4154,7 @@ var yyAct = [...]int{ 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, - 0, 0, 0, 0, 3148, 0, 0, 0, 3147, 649, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, @@ -4584,101 +4185,236 @@ var yyAct = [...]int{ 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, - 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, - 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, - 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, - 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, - 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, - 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, - 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, - 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, - 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, - 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, - 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, - 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, - 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 1625, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, - 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, + 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, + 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, + 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, + 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, + 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, + 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, + 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, + 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, + 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, + 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, + 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, + 0, 663, 664, 665, 662, 392, 448, 467, 455, 215, + 686, 539, 540, 687, 650, 0, 0, 0, 0, 419, + 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, + 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, + 562, 563, 564, 534, 565, 535, 566, 567, 147, 590, + 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 211, 2291, 0, 237, 0, 0, 0, 0, + 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, + 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, + 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, + 507, 348, 498, 0, 490, 315, 0, 489, 415, 476, + 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, + 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, + 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, + 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, + 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, + 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, + 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, + 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, + 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, + 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, + 0, 365, 441, 397, 310, 396, 428, 473, 472, 321, + 499, 505, 506, 595, 0, 511, 690, 691, 692, 520, + 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, + 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, + 531, 532, 596, 613, 580, 550, 513, 604, 547, 551, + 552, 375, 616, 0, 0, 0, 504, 385, 386, 0, + 357, 356, 398, 437, 363, 303, 304, 685, 347, 417, + 618, 651, 652, 543, 0, 605, 544, 553, 339, 577, + 589, 588, 413, 503, 0, 600, 603, 533, 684, 0, + 597, 612, 688, 611, 681, 423, 0, 450, 609, 556, + 0, 601, 575, 0, 602, 571, 606, 0, 545, 0, + 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, + 516, 635, 636, 637, 638, 639, 640, 641, 634, 488, + 578, 555, 581, 496, 558, 557, 0, 0, 592, 512, + 593, 594, 407, 408, 409, 410, 367, 619, 328, 515, + 436, 0, 579, 0, 0, 0, 0, 0, 0, 0, + 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, + 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, + 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, + 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, + 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, + 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, + 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, + 0, 305, 549, 388, 177, 435, 361, 614, 615, 0, + 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, + 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, + 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 0, 0, 0, 299, 669, 670, 671, 672, + 673, 0, 0, 300, 301, 302, 0, 0, 292, 293, + 294, 295, 296, 0, 0, 500, 501, 502, 524, 0, + 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, + 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, + 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, + 467, 455, 215, 686, 539, 540, 687, 650, 0, 0, + 0, 0, 419, 0, 0, 554, 587, 576, 660, 542, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, + 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, + 567, 147, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 237, 0, 0, 1623, 0, 0, 0, 323, 238, - 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 211, 2276, 0, 237, 0, + 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, + 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1621, 0, - 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 0, 479, 507, 348, 498, 0, - 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, - 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, - 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, - 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, - 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, - 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, - 409, 410, 367, 619, 328, 515, 436, 0, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, - 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, - 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, - 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, - 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, - 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, - 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, - 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, - 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, + 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, + 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, + 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, + 416, 0, 479, 507, 348, 498, 0, 490, 315, 0, + 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, + 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, + 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, + 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, + 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, + 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, + 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, + 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, + 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, + 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, + 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, + 473, 472, 321, 499, 505, 506, 595, 0, 511, 690, + 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, + 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, + 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, + 604, 547, 551, 552, 375, 616, 0, 0, 0, 504, + 385, 386, 0, 357, 356, 398, 437, 363, 303, 304, + 685, 347, 417, 618, 651, 652, 543, 0, 605, 544, + 553, 339, 577, 589, 588, 413, 503, 0, 600, 603, + 533, 684, 0, 597, 612, 688, 611, 681, 423, 0, + 450, 609, 556, 0, 601, 575, 0, 602, 571, 606, + 0, 545, 0, 458, 485, 497, 514, 517, 546, 631, + 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, + 641, 634, 488, 578, 555, 581, 496, 558, 557, 0, + 0, 592, 512, 593, 594, 407, 408, 409, 410, 367, + 619, 328, 515, 436, 0, 579, 0, 0, 0, 0, + 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, + 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, + 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, + 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, + 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, + 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, + 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, + 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, + 0, 0, 0, 0, 305, 549, 388, 177, 435, 361, + 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, + 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, + 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, + 267, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 0, 0, 0, 299, 669, + 670, 671, 672, 673, 0, 0, 300, 301, 302, 0, + 0, 292, 293, 294, 295, 296, 0, 0, 500, 501, + 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, + 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, + 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, + 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, + 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, + 1096, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, + 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 1103, 1104, + 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1107, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 311, 464, 1090, 324, 452, 495, 329, + 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, + 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, + 0, 479, 507, 348, 498, 1075, 490, 315, 1074, 489, + 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, + 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, + 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, + 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, + 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, + 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, + 444, 389, 477, 432, 483, 465, 491, 1094, 433, 306, + 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, + 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, + 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, + 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, + 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, + 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, + 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, + 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, + 547, 551, 552, 375, 616, 0, 0, 0, 504, 385, + 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, + 347, 417, 618, 651, 652, 543, 0, 605, 544, 553, + 339, 577, 589, 588, 413, 503, 0, 600, 603, 533, + 684, 0, 597, 612, 688, 611, 681, 423, 0, 450, + 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, + 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, + 633, 308, 516, 635, 636, 637, 638, 639, 640, 1095, + 634, 488, 578, 555, 581, 496, 558, 557, 0, 0, + 592, 1098, 593, 594, 407, 408, 409, 410, 367, 619, + 1093, 515, 436, 0, 579, 0, 0, 0, 0, 0, + 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, + 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, + 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, + 648, 646, 647, 0, 0, 1105, 1091, 1101, 1092, 380, + 390, 442, 493, 420, 447, 325, 484, 456, 1102, 572, + 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, + 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, + 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, + 0, 0, 0, 305, 549, 388, 0, 435, 361, 614, + 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, + 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, + 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 0, 0, 0, 299, 669, 670, + 671, 672, 673, 0, 0, 300, 301, 302, 0, 0, + 292, 293, 294, 295, 296, 0, 0, 500, 501, 502, + 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, + 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, + 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, + 1089, 448, 467, 455, 215, 686, 539, 540, 687, 650, + 0, 0, 0, 0, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 354, 1619, 0, 387, 591, 573, 583, 574, + 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, - 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 535, 566, 567, 147, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 237, 0, 0, 1623, 0, 0, 0, 323, 238, 536, + 0, 0, 0, 0, 0, 0, 0, 2172, 0, 0, + 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1621, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, @@ -4720,7 +4456,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, - 674, 683, 0, 0, 0, 0, 305, 549, 388, 0, + 674, 683, 0, 0, 0, 0, 305, 549, 388, 177, 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, @@ -4738,10 +4474,10 @@ var yyAct = [...]int{ 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4351, 0, 237, - 898, 0, 0, 0, 0, 0, 323, 238, 536, 656, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, + 1103, 1104, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4749,8 +4485,8 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, - 349, 416, 0, 479, 507, 348, 498, 0, 490, 315, - 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, + 349, 416, 0, 479, 507, 348, 498, 1075, 490, 315, + 1074, 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, @@ -4780,9 +4516,9 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, - 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, - 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, - 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, + 440, 645, 648, 646, 647, 0, 0, 1105, 2193, 1101, + 2194, 380, 390, 442, 493, 420, 447, 325, 484, 456, + 1102, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, @@ -4800,19 +4536,19 @@ var yyAct = [...]int{ 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3159, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, - 0, 1623, 0, 0, 0, 323, 238, 536, 656, 538, + 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1621, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, @@ -4821,7 +4557,7 @@ var yyAct = [...]int{ 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, + 3162, 0, 0, 0, 3161, 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, @@ -4868,18 +4604,18 @@ var yyAct = [...]int{ 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, - 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 1632, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, - 1623, 0, 0, 0, 323, 238, 536, 656, 538, 537, + 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1837, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1628, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, @@ -4934,19 +4670,19 @@ var yyAct = [...]int{ 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, - 0, 0, 0, 2659, 0, 0, 0, 0, 354, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 354, 1626, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 237, 0, 0, 2661, + 0, 0, 0, 0, 0, 0, 237, 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1628, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, @@ -5001,12 +4737,12 @@ var yyAct = [...]int{ 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, - 0, 0, 2234, 0, 0, 0, 0, 354, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 237, 0, 0, 2235, 0, + 0, 0, 0, 4365, 0, 237, 898, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5073,14 +4809,14 @@ var yyAct = [...]int{ 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 3384, 3386, 0, + 0, 0, 0, 0, 237, 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1628, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, @@ -5135,19 +4871,19 @@ var yyAct = [...]int{ 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 354, 2682, 0, 387, 591, + 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 0, 0, 1623, 0, 0, 0, + 0, 0, 0, 237, 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, + 1844, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, 348, @@ -5201,13 +4937,13 @@ var yyAct = [...]int{ 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 700, 354, 0, 0, 387, 591, 573, + 587, 576, 660, 542, 0, 0, 0, 0, 0, 2666, + 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 0, 0, 237, 0, 0, 2668, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5223,7 +4959,7 @@ var yyAct = [...]int{ 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, - 0, 0, 653, 0, 492, 0, 699, 0, 0, 0, + 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, @@ -5268,13 +5004,13 @@ var yyAct = [...]int{ 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, + 576, 660, 542, 0, 0, 0, 0, 0, 2241, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 237, 898, 0, 0, 0, 0, 0, 323, 238, + 0, 237, 0, 0, 2242, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5340,8 +5076,8 @@ var yyAct = [...]int{ 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4328, 0, 0, - 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 3398, 3400, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5403,12 +5139,12 @@ var yyAct = [...]int{ 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, + 0, 354, 2689, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 4069, 0, 0, 0, 323, 238, 536, 656, + 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5469,7 +5205,7 @@ var yyAct = [...]int{ 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 700, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, @@ -5491,7 +5227,7 @@ var yyAct = [...]int{ 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, - 492, 0, 0, 0, 4212, 0, 0, 463, 0, 0, + 492, 0, 699, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, @@ -5541,7 +5277,7 @@ var yyAct = [...]int{ 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1851, 0, 0, 237, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 898, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5608,7 +5344,7 @@ var yyAct = [...]int{ 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 4084, 0, 237, 0, 0, 0, + 0, 0, 0, 4342, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5675,7 +5411,7 @@ var yyAct = [...]int{ 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 237, 0, 0, 4083, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5692,7 +5428,7 @@ var yyAct = [...]int{ 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, - 0, 3983, 0, 0, 463, 0, 0, 384, 0, 0, + 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, @@ -5742,7 +5478,7 @@ var yyAct = [...]int{ 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 3417, 0, 0, + 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5759,7 +5495,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, - 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, + 4226, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, @@ -5809,7 +5545,7 @@ var yyAct = [...]int{ 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 0, 0, 3857, 0, 0, 0, + 1858, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5876,13 +5612,13 @@ var yyAct = [...]int{ 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 4098, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3436, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, @@ -5942,7 +5678,7 @@ var yyAct = [...]int{ 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2165, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, @@ -5959,7 +5695,7 @@ var yyAct = [...]int{ 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, - 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, + 0, 653, 0, 492, 0, 0, 0, 3997, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, @@ -6004,13 +5740,13 @@ var yyAct = [...]int{ 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, - 660, 542, 0, 0, 3668, 0, 0, 0, 0, 0, + 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, + 237, 0, 0, 3431, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6077,12 +5813,12 @@ var yyAct = [...]int{ 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, + 0, 0, 3871, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3554, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, @@ -6149,7 +5885,7 @@ var yyAct = [...]int{ 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3253, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3450, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, @@ -6210,8 +5946,8 @@ var yyAct = [...]int{ 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, - 1623, 0, 0, 0, 323, 238, 536, 656, 538, 537, + 0, 0, 0, 0, 2172, 0, 0, 237, 0, 0, + 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6272,12 +6008,12 @@ var yyAct = [...]int{ 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, + 3682, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 237, 0, 0, 2661, + 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6338,7 +6074,7 @@ var yyAct = [...]int{ 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, - 0, 0, 554, 587, 576, 660, 542, 0, 0, 3056, + 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, @@ -6350,7 +6086,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3568, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, @@ -6417,7 +6153,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2305, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3267, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, @@ -6478,7 +6214,7 @@ var yyAct = [...]int{ 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 0, 0, 2780, 0, 0, 0, + 0, 0, 0, 237, 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6545,13 +6281,13 @@ var yyAct = [...]int{ 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 0, 0, 237, 0, 0, 2668, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2742, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, @@ -6606,13 +6342,13 @@ var yyAct = [...]int{ 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, + 576, 660, 542, 0, 0, 3070, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 237, 0, 0, 2740, 0, 0, 0, 323, 238, + 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6671,7 +6407,7 @@ var yyAct = [...]int{ 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, - 663, 664, 665, 662, 392, 448, 467, 455, 2488, 686, + 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, @@ -6684,7 +6420,7 @@ var yyAct = [...]int{ 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2312, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, @@ -6746,7 +6482,7 @@ var yyAct = [...]int{ 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 0, 2011, 0, 0, 323, 238, 536, 656, + 0, 0, 2794, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6807,7 +6543,7 @@ var yyAct = [...]int{ 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, - 0, 2147, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, @@ -6818,7 +6554,7 @@ var yyAct = [...]int{ 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2756, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, @@ -6880,7 +6616,7 @@ var yyAct = [...]int{ 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, - 1623, 0, 0, 0, 323, 238, 536, 656, 538, 537, + 2754, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6898,7 +6634,7 @@ var yyAct = [...]int{ 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, - 444, 389, 477, 432, 483, 465, 491, 2042, 433, 306, + 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, @@ -6939,7 +6675,7 @@ var yyAct = [...]int{ 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, - 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, + 392, 448, 467, 455, 2495, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, @@ -6963,7 +6699,7 @@ var yyAct = [...]int{ 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, - 0, 1653, 0, 0, 0, 463, 0, 0, 384, 0, + 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, @@ -7008,12 +6744,12 @@ var yyAct = [...]int{ 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 700, 354, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 237, 0, 0, 0, 2018, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -7074,7 +6810,7 @@ var yyAct = [...]int{ 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, - 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, + 0, 554, 587, 576, 660, 542, 0, 2154, 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, @@ -7096,7 +6832,7 @@ var yyAct = [...]int{ 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 649, 0, 710, 653, 0, 492, 0, 0, 0, + 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, @@ -7147,7 +6883,7 @@ var yyAct = [...]int{ 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 237, 0, 0, 1630, 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -7166,7 +6902,7 @@ var yyAct = [...]int{ 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, - 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, + 483, 465, 491, 2049, 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, @@ -7193,658 +6929,959 @@ var yyAct = [...]int{ 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, - 621, 620, 1020, 0, 569, 471, 341, 297, 337, 338, - 345, 682, 678, 674, 683, 0, 0, 0, 0, 305, - 549, 388, 0, 435, 361, 614, 615, 0, 666, 251, - 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, - 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, - 273, 274, 275, 617, 266, 267, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 0, 0, 0, 299, 669, 670, 671, 672, 673, 0, - 0, 300, 301, 302, 0, 0, 292, 293, 294, 295, - 296, 0, 0, 500, 501, 502, 524, 0, 486, 548, - 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, - 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, - 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, - 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, - 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, - 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, - 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, - 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, + 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, + 345, 682, 678, 674, 683, 0, 0, 0, 0, 305, + 549, 388, 0, 435, 361, 614, 615, 0, 666, 251, + 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, + 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, + 273, 274, 275, 617, 266, 267, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 0, 0, 0, 299, 669, 670, 671, 672, 673, 0, + 0, 300, 301, 302, 0, 0, 292, 293, 294, 295, + 296, 0, 0, 500, 501, 502, 524, 0, 486, 548, + 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, + 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, + 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, + 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, + 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, + 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, + 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, + 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, + 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, + 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, + 443, 352, 368, 349, 416, 0, 479, 507, 348, 498, + 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, + 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, + 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, + 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, + 0, 0, 653, 0, 492, 0, 0, 1660, 0, 0, + 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, + 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, + 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, + 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, + 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, + 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, + 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, + 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, + 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, + 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, + 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, + 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, + 437, 363, 303, 304, 685, 347, 417, 618, 651, 652, + 543, 0, 605, 544, 553, 339, 577, 589, 588, 413, + 503, 0, 600, 603, 533, 684, 0, 597, 612, 688, + 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, + 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, + 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, + 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, + 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, + 408, 409, 410, 367, 619, 328, 515, 436, 0, 579, + 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, + 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, + 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, + 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, + 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, + 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, + 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, + 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, + 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, + 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, + 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, + 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, + 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, + 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, + 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, + 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, + 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, + 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, + 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, + 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 700, 354, 0, 0, 387, 591, 573, 583, + 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, + 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, + 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, + 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, + 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, + 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, + 352, 368, 349, 416, 0, 479, 507, 348, 498, 0, + 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, + 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, + 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, + 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, + 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, + 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, + 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, + 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, + 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, + 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, + 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, + 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, + 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, + 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, + 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, + 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, + 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, + 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, + 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, + 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, + 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, + 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, + 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, + 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, + 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, + 409, 410, 367, 619, 328, 515, 436, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, + 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, + 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, + 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, + 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, + 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, + 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, + 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, + 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, + 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, + 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, + 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, + 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, + 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, + 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, + 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, + 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, + 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, + 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, + 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, + 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, + 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, + 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, + 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, + 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, + 368, 349, 416, 0, 479, 507, 348, 498, 0, 490, + 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, + 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, + 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, + 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 649, 0, 710, + 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, + 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, + 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, + 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, + 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, + 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, + 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, + 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, + 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, + 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, + 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, + 550, 513, 604, 547, 551, 552, 375, 616, 0, 0, + 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, + 303, 304, 685, 347, 417, 618, 651, 652, 543, 0, + 605, 544, 553, 339, 577, 589, 588, 413, 503, 0, + 600, 603, 533, 684, 0, 597, 612, 688, 611, 681, + 423, 0, 450, 609, 556, 0, 601, 575, 0, 602, + 571, 606, 0, 545, 0, 458, 485, 497, 514, 517, + 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, + 639, 640, 641, 634, 488, 578, 555, 581, 496, 558, + 557, 0, 0, 592, 512, 593, 594, 407, 408, 409, + 410, 367, 619, 328, 515, 436, 0, 579, 0, 0, + 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, + 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, + 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, + 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, + 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, + 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, + 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, + 674, 683, 0, 0, 0, 0, 305, 549, 388, 0, + 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, + 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, + 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, + 617, 266, 267, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 0, 0, 0, + 299, 669, 670, 671, 672, 673, 0, 0, 300, 301, + 302, 0, 0, 292, 293, 294, 295, 296, 0, 0, + 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, + 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, + 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, + 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, + 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, + 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, + 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, + 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, + 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, + 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 311, 464, 482, 324, 452, + 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, + 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, + 349, 416, 0, 479, 507, 348, 498, 0, 490, 315, + 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, + 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, + 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, + 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, + 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, + 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, + 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, + 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, + 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, + 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, + 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, + 428, 473, 472, 321, 499, 505, 506, 595, 0, 511, + 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, + 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, + 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, + 513, 604, 547, 551, 552, 375, 616, 0, 0, 0, + 504, 385, 386, 0, 357, 356, 398, 437, 363, 303, + 304, 685, 347, 417, 618, 651, 652, 543, 0, 605, + 544, 553, 339, 577, 589, 588, 413, 503, 0, 600, + 603, 533, 684, 0, 597, 612, 688, 611, 681, 423, + 0, 450, 609, 556, 0, 601, 575, 0, 602, 571, + 606, 0, 545, 0, 458, 485, 497, 514, 517, 546, + 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, + 640, 641, 634, 488, 578, 555, 581, 496, 558, 557, + 0, 0, 592, 512, 593, 594, 407, 408, 409, 410, + 367, 619, 328, 515, 436, 0, 579, 0, 0, 0, + 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, + 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, + 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, + 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, + 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, + 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 627, 626, 625, 624, 623, 622, 621, 620, 1020, 0, + 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, + 683, 0, 0, 0, 0, 305, 549, 388, 0, 435, + 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, + 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, + 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, + 266, 267, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 0, 0, 0, 299, + 669, 670, 671, 672, 673, 0, 0, 300, 301, 302, + 0, 0, 292, 293, 294, 295, 296, 0, 0, 500, + 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, + 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, + 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, + 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, + 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, - 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, + 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, + 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, + 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, + 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, + 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, - 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, - 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, - 443, 352, 368, 349, 416, 0, 479, 507, 348, 498, - 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, - 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, - 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, - 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, - 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, - 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, - 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, - 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, - 679, 353, 355, 359, 360, 411, 412, 426, 451, 468, - 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, - 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, - 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, - 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, - 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, - 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, - 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, - 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, - 437, 363, 303, 304, 685, 347, 417, 618, 651, 652, - 543, 0, 605, 544, 553, 339, 577, 589, 588, 413, - 503, 0, 600, 603, 533, 684, 0, 597, 612, 688, - 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, - 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, - 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, - 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, - 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, - 408, 409, 410, 367, 619, 328, 515, 436, 0, 579, - 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, - 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, - 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, - 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, - 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, - 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, - 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, - 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, - 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, - 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, - 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, - 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, - 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, - 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, - 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, - 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, - 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, - 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, - 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, - 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, - 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, - 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, - 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 311, 464, 482, 324, 452, 495, + 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, + 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, + 416, 0, 479, 507, 348, 498, 0, 490, 315, 0, + 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, + 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, + 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, + 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, + 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, + 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, + 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, + 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, + 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, + 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, + 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, + 473, 472, 321, 499, 505, 506, 595, 0, 511, 690, + 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, + 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, + 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, + 604, 547, 551, 552, 375, 616, 0, 0, 0, 504, + 385, 386, 0, 357, 356, 398, 437, 363, 303, 304, + 685, 347, 417, 618, 651, 652, 543, 0, 605, 544, + 553, 339, 577, 589, 588, 413, 503, 0, 600, 603, + 533, 684, 0, 597, 612, 688, 611, 681, 423, 0, + 450, 609, 556, 0, 601, 575, 0, 602, 571, 606, + 0, 545, 0, 458, 485, 497, 514, 517, 546, 631, + 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, + 641, 634, 488, 578, 555, 581, 496, 558, 557, 0, + 0, 592, 512, 593, 594, 407, 408, 409, 410, 367, + 619, 328, 515, 436, 0, 579, 0, 0, 0, 0, + 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, + 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, + 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, + 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, + 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, + 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, + 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, + 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, + 0, 0, 0, 0, 305, 549, 388, 0, 435, 361, + 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, + 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, + 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, + 267, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 0, 0, 0, 299, 669, + 670, 671, 672, 673, 0, 0, 300, 301, 302, 0, + 0, 292, 293, 294, 295, 296, 0, 0, 500, 501, + 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, + 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, + 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, + 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, + 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, + 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, + 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, + 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, - 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, - 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, - 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, - 352, 368, 349, 416, 0, 479, 507, 348, 498, 0, - 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, - 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, - 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, - 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, - 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, - 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, - 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, - 491, 438, 433, 306, 466, 351, 402, 320, 322, 679, - 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, - 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, - 343, 453, 344, 309, 427, 474, 0, 365, 3358, 397, - 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, - 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, - 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, - 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, - 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, - 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, - 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, - 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, - 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, - 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, - 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, - 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, - 638, 639, 640, 641, 634, 488, 578, 555, 581, 496, - 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, - 409, 410, 367, 619, 328, 515, 436, 0, 579, 0, - 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, - 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, - 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, - 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, - 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, - 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, - 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, - 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, - 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, - 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, - 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, - 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, - 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, - 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, - 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, - 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, - 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, - 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, - 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, - 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, - 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, - 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, + 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, + 460, 475, 319, 418, 449, 0, 0, 313, 480, 459, + 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, + 0, 479, 507, 348, 498, 0, 490, 315, 0, 489, + 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, + 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, + 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, + 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, + 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, + 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, + 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, + 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, + 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, + 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, + 427, 474, 0, 365, 3372, 397, 310, 396, 428, 473, + 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, + 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, + 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, + 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, + 547, 551, 552, 375, 616, 0, 0, 0, 504, 385, + 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, + 347, 417, 618, 651, 652, 543, 0, 605, 544, 553, + 339, 577, 589, 588, 413, 503, 0, 600, 603, 533, + 684, 0, 597, 612, 688, 611, 681, 423, 0, 450, + 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, + 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, + 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, + 634, 488, 578, 555, 581, 496, 558, 557, 0, 0, + 592, 512, 593, 594, 407, 408, 409, 410, 367, 619, + 328, 515, 436, 0, 579, 0, 0, 0, 0, 0, + 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, + 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, + 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, + 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, + 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, + 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, + 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, + 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, + 0, 0, 0, 305, 549, 388, 0, 435, 361, 614, + 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, + 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, + 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 0, 0, 0, 299, 669, 670, + 671, 672, 673, 0, 0, 300, 301, 302, 0, 0, + 292, 293, 294, 295, 296, 0, 0, 500, 501, 502, + 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, + 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, + 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, + 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, + 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, + 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, + 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, + 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, + 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, - 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, + 2004, 319, 418, 449, 0, 0, 313, 480, 459, 400, + 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, + 479, 507, 348, 498, 0, 490, 315, 0, 489, 415, + 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, + 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, + 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, + 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, + 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, + 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, + 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, + 351, 402, 320, 322, 679, 353, 355, 359, 360, 411, + 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, + 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, + 474, 0, 365, 441, 397, 310, 396, 428, 473, 472, + 321, 499, 505, 506, 595, 0, 511, 690, 691, 692, + 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, + 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, + 530, 531, 532, 596, 613, 580, 550, 513, 604, 547, + 551, 552, 375, 616, 0, 0, 0, 504, 385, 386, + 0, 357, 356, 398, 437, 363, 303, 304, 685, 347, + 417, 618, 651, 652, 543, 0, 605, 544, 553, 339, + 577, 589, 588, 413, 503, 0, 600, 603, 533, 684, + 0, 597, 612, 688, 611, 681, 423, 0, 450, 609, + 556, 0, 601, 575, 0, 602, 571, 606, 0, 545, + 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, + 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, + 488, 578, 555, 581, 496, 558, 557, 0, 0, 592, + 512, 593, 594, 407, 408, 409, 410, 367, 619, 328, + 515, 436, 0, 579, 0, 0, 0, 0, 0, 0, + 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, + 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, + 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, + 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, + 442, 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, - 452, 495, 329, 460, 1997, 319, 418, 449, 0, 0, - 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, - 368, 349, 416, 0, 479, 507, 348, 498, 0, 490, - 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, - 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, - 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, - 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, - 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, - 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, - 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, - 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, - 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, - 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, - 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, - 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, - 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, - 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, - 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, - 550, 513, 604, 547, 551, 552, 375, 616, 0, 0, - 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, - 303, 304, 685, 347, 417, 618, 651, 652, 543, 0, - 605, 544, 553, 339, 577, 589, 588, 413, 503, 0, - 600, 603, 533, 684, 0, 597, 612, 688, 611, 681, - 423, 0, 450, 609, 556, 0, 601, 575, 0, 602, - 571, 606, 0, 545, 0, 458, 485, 497, 514, 517, - 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, - 639, 640, 641, 634, 488, 578, 555, 581, 496, 558, - 557, 0, 0, 592, 512, 593, 594, 407, 408, 409, - 410, 367, 619, 328, 515, 436, 0, 579, 0, 0, - 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, - 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, - 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, - 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, - 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, - 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, + 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, + 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, + 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, + 0, 0, 305, 549, 388, 0, 435, 361, 614, 615, + 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, + 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, + 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 0, 0, 0, 299, 669, 670, 671, + 672, 673, 0, 0, 300, 301, 302, 0, 0, 292, + 293, 294, 295, 296, 0, 0, 500, 501, 502, 524, + 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, + 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, + 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, + 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, + 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, + 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, + 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, + 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, - 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, - 674, 683, 0, 0, 0, 0, 305, 549, 388, 0, - 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, - 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, - 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, - 617, 266, 267, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 0, 0, 0, - 299, 669, 670, 671, 672, 673, 0, 0, 300, 301, - 302, 0, 0, 292, 293, 294, 295, 296, 0, 0, - 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, - 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, - 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, - 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, - 540, 687, 650, 419, 0, 0, 554, 587, 576, 660, - 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 354, 0, 0, 387, 591, 573, 583, 574, 559, - 560, 561, 568, 366, 562, 563, 564, 534, 565, 535, - 566, 567, 0, 590, 541, 457, 403, 608, 607, 0, + 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, + 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 0, 0, 0, 0, 323, 238, 536, 656, - 538, 537, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 311, 464, 1602, 324, 452, - 495, 329, 460, 475, 319, 418, 449, 0, 0, 313, - 480, 459, 400, 377, 378, 312, 0, 443, 352, 368, - 349, 416, 0, 479, 507, 348, 498, 0, 490, 315, - 0, 489, 415, 476, 481, 401, 394, 0, 314, 478, - 399, 393, 381, 358, 523, 382, 383, 372, 430, 391, - 431, 373, 405, 404, 406, 0, 0, 0, 0, 0, - 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 649, 0, 0, 653, - 0, 492, 0, 0, 0, 0, 0, 0, 463, 0, - 0, 384, 0, 0, 0, 508, 0, 446, 421, 689, - 0, 0, 444, 389, 477, 432, 483, 465, 491, 438, - 433, 306, 466, 351, 402, 320, 322, 679, 353, 355, - 359, 360, 411, 412, 426, 451, 468, 469, 470, 350, - 334, 445, 335, 370, 336, 307, 342, 340, 343, 453, - 344, 309, 427, 474, 0, 365, 441, 397, 310, 396, - 428, 473, 472, 321, 499, 505, 506, 595, 0, 511, - 690, 691, 692, 520, 0, 434, 317, 316, 0, 0, - 0, 346, 429, 330, 332, 333, 331, 424, 425, 525, - 526, 527, 529, 530, 531, 532, 596, 613, 580, 550, - 513, 604, 547, 551, 552, 375, 616, 0, 0, 0, - 504, 385, 386, 0, 357, 356, 398, 437, 363, 303, - 304, 685, 347, 417, 618, 651, 652, 543, 0, 605, - 544, 553, 339, 577, 589, 588, 413, 503, 0, 600, - 603, 533, 684, 0, 597, 612, 688, 611, 681, 423, - 0, 450, 609, 556, 0, 601, 575, 0, 602, 571, - 606, 0, 545, 0, 458, 485, 497, 514, 517, 546, - 631, 632, 633, 308, 516, 635, 636, 637, 638, 639, - 640, 641, 634, 488, 578, 555, 581, 496, 558, 557, - 0, 0, 592, 512, 593, 594, 407, 408, 409, 410, - 367, 619, 328, 515, 436, 0, 579, 0, 0, 0, - 0, 0, 0, 0, 0, 584, 585, 582, 693, 0, - 642, 643, 0, 0, 509, 510, 362, 369, 528, 371, - 327, 422, 364, 494, 379, 0, 521, 586, 522, 439, - 440, 645, 648, 646, 647, 0, 0, 414, 374, 376, - 454, 380, 390, 442, 493, 420, 447, 325, 484, 456, - 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, + 0, 311, 464, 1609, 324, 452, 495, 329, 460, 475, + 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, + 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, + 507, 348, 498, 0, 490, 315, 0, 489, 415, 476, + 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, + 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, + 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, + 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, + 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, + 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, + 477, 432, 483, 465, 491, 438, 433, 306, 466, 351, + 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, + 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, + 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, + 0, 365, 441, 397, 310, 396, 428, 473, 472, 321, + 499, 505, 506, 595, 0, 511, 690, 691, 692, 520, + 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, + 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, + 531, 532, 596, 613, 580, 550, 513, 604, 547, 551, + 552, 375, 616, 0, 0, 0, 504, 385, 386, 0, + 357, 356, 398, 437, 363, 303, 304, 685, 347, 417, + 618, 651, 652, 543, 0, 605, 544, 553, 339, 577, + 589, 588, 413, 503, 0, 600, 603, 533, 684, 0, + 597, 612, 688, 611, 681, 423, 0, 450, 609, 556, + 0, 601, 575, 0, 602, 571, 606, 0, 545, 0, + 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, + 516, 635, 636, 637, 638, 639, 640, 641, 634, 488, + 578, 555, 581, 496, 558, 557, 0, 0, 592, 512, + 593, 594, 407, 408, 409, 410, 367, 619, 328, 515, + 436, 0, 579, 0, 0, 0, 0, 0, 0, 0, + 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, + 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, + 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, + 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, + 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, + 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, + 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, + 0, 305, 549, 388, 0, 435, 361, 614, 615, 0, + 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, + 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, + 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 0, 0, 0, 299, 669, 670, 671, 672, + 673, 0, 0, 300, 301, 302, 0, 0, 292, 293, + 294, 295, 296, 0, 0, 500, 501, 502, 524, 0, + 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, + 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, + 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, + 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, + 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, + 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, + 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, + 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, + 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 627, 626, 625, 624, 623, 622, 621, 620, 0, 0, - 569, 471, 341, 297, 337, 338, 345, 682, 678, 674, - 683, 0, 0, 0, 0, 305, 549, 388, 0, 435, - 361, 614, 615, 0, 666, 251, 252, 253, 254, 255, - 256, 257, 258, 298, 259, 260, 261, 262, 263, 264, - 265, 268, 269, 270, 271, 272, 273, 274, 275, 617, - 266, 267, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 0, 0, 0, 299, - 669, 670, 671, 672, 673, 0, 0, 300, 301, 302, - 0, 0, 292, 293, 294, 295, 296, 0, 0, 500, - 501, 502, 524, 0, 486, 548, 680, 0, 0, 0, - 0, 0, 0, 0, 598, 610, 644, 0, 654, 655, - 657, 659, 658, 661, 461, 462, 668, 0, 663, 664, - 665, 662, 392, 448, 467, 455, 0, 686, 539, 540, - 687, 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 354, 0, 0, 387, 591, 573, 583, 574, 559, 560, - 561, 568, 366, 562, 563, 564, 534, 565, 535, 566, - 567, 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, - 0, 0, 0, 0, 0, 323, 238, 536, 656, 538, - 537, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 311, 464, 1607, 324, 452, 495, 329, 460, 475, 319, + 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, + 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, + 348, 498, 0, 490, 315, 0, 489, 415, 476, 481, + 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, + 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, + 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, + 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, + 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, + 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, + 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, + 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, + 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, + 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, + 505, 506, 595, 0, 511, 690, 691, 692, 520, 0, + 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, + 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, + 532, 596, 613, 580, 550, 513, 604, 547, 551, 552, + 375, 616, 0, 0, 0, 504, 385, 386, 0, 357, + 356, 398, 437, 363, 303, 304, 685, 347, 417, 618, + 651, 652, 543, 0, 605, 544, 553, 339, 577, 589, + 588, 413, 503, 0, 600, 603, 533, 684, 0, 597, + 612, 688, 611, 681, 423, 0, 450, 609, 556, 0, + 601, 575, 0, 602, 571, 606, 0, 545, 0, 458, + 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, + 635, 636, 637, 638, 639, 640, 641, 634, 488, 578, + 555, 581, 496, 558, 557, 0, 0, 592, 512, 593, + 594, 407, 408, 409, 410, 367, 619, 328, 515, 436, + 0, 579, 0, 0, 0, 0, 0, 0, 0, 0, + 584, 585, 582, 693, 0, 642, 643, 0, 0, 509, + 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, + 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, + 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, + 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, + 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, + 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, + 338, 345, 682, 678, 674, 683, 0, 0, 0, 0, + 305, 549, 388, 0, 435, 361, 614, 615, 0, 666, + 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, + 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, + 272, 273, 274, 275, 617, 266, 267, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 0, 0, 0, 299, 669, 670, 671, 672, 673, + 0, 0, 300, 301, 302, 0, 0, 292, 293, 294, + 295, 296, 0, 0, 500, 501, 502, 524, 0, 486, + 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, + 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, + 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, + 455, 0, 686, 539, 540, 687, 650, 419, 0, 0, + 554, 587, 576, 660, 542, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 354, 0, 0, 387, 591, + 573, 583, 574, 559, 560, 561, 568, 366, 562, 563, + 564, 534, 565, 535, 566, 567, 0, 590, 541, 457, + 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 311, 464, 1600, 324, 452, 495, - 329, 460, 475, 319, 418, 449, 0, 0, 313, 480, - 459, 400, 377, 378, 312, 0, 443, 352, 368, 349, - 416, 0, 479, 507, 348, 498, 0, 490, 315, 0, - 489, 415, 476, 481, 401, 394, 0, 314, 478, 399, - 393, 381, 358, 523, 382, 383, 372, 430, 391, 431, - 373, 405, 404, 406, 0, 0, 0, 0, 0, 518, - 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 649, 0, 0, 653, 0, - 492, 0, 0, 0, 0, 0, 0, 463, 0, 0, - 384, 0, 0, 0, 508, 0, 446, 421, 689, 0, - 0, 444, 389, 477, 432, 483, 465, 491, 438, 433, - 306, 466, 351, 402, 320, 322, 679, 353, 355, 359, - 360, 411, 412, 426, 451, 468, 469, 470, 350, 334, - 445, 335, 370, 336, 307, 342, 340, 343, 453, 344, - 309, 427, 474, 0, 365, 441, 397, 310, 396, 428, - 473, 472, 321, 499, 505, 506, 595, 0, 511, 690, - 691, 692, 520, 0, 434, 317, 316, 0, 0, 0, - 346, 429, 330, 332, 333, 331, 424, 425, 525, 526, - 527, 529, 530, 531, 532, 596, 613, 580, 550, 513, - 604, 547, 551, 552, 375, 616, 0, 0, 0, 504, - 385, 386, 0, 357, 356, 398, 437, 363, 303, 304, - 685, 347, 417, 618, 651, 652, 543, 0, 605, 544, - 553, 339, 577, 589, 588, 413, 503, 0, 600, 603, - 533, 684, 0, 597, 612, 688, 611, 681, 423, 0, - 450, 609, 556, 0, 601, 575, 0, 602, 571, 606, - 0, 545, 0, 458, 485, 497, 514, 517, 546, 631, - 632, 633, 308, 516, 635, 636, 637, 638, 639, 640, - 641, 634, 488, 578, 555, 581, 496, 558, 557, 0, - 0, 592, 512, 593, 594, 407, 408, 409, 410, 367, - 619, 328, 515, 436, 0, 579, 0, 0, 0, 0, - 0, 0, 0, 0, 584, 585, 582, 693, 0, 642, - 643, 0, 0, 509, 510, 362, 369, 528, 371, 327, - 422, 364, 494, 379, 0, 521, 586, 522, 439, 440, - 645, 648, 646, 647, 0, 0, 414, 374, 376, 454, - 380, 390, 442, 493, 420, 447, 325, 484, 456, 395, - 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 627, - 626, 625, 624, 623, 622, 621, 620, 0, 0, 569, - 471, 341, 297, 337, 338, 345, 682, 678, 674, 683, - 0, 0, 0, 0, 305, 549, 388, 0, 435, 361, - 614, 615, 0, 666, 251, 252, 253, 254, 255, 256, - 257, 258, 298, 259, 260, 261, 262, 263, 264, 265, - 268, 269, 270, 271, 272, 273, 274, 275, 617, 266, - 267, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 0, 0, 0, 299, 669, - 670, 671, 672, 673, 0, 0, 300, 301, 302, 0, - 0, 292, 293, 294, 295, 296, 0, 0, 500, 501, - 502, 524, 0, 486, 548, 680, 0, 0, 0, 0, - 0, 0, 0, 598, 610, 644, 0, 654, 655, 657, - 659, 658, 661, 461, 462, 668, 0, 663, 664, 665, - 662, 392, 448, 467, 455, 0, 686, 539, 540, 687, - 650, 419, 0, 0, 554, 587, 576, 660, 542, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, - 0, 0, 387, 591, 573, 583, 574, 559, 560, 561, - 568, 366, 562, 563, 564, 534, 565, 535, 566, 567, - 0, 590, 541, 457, 403, 608, 607, 0, 0, 0, + 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, + 323, 238, 536, 656, 538, 537, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, - 0, 0, 0, 0, 323, 238, 536, 656, 538, 537, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 311, + 464, 482, 324, 452, 495, 329, 460, 1481, 319, 418, + 449, 0, 0, 313, 480, 459, 400, 377, 378, 312, + 0, 443, 352, 368, 349, 416, 0, 479, 507, 348, + 498, 0, 490, 315, 0, 489, 415, 476, 481, 401, + 394, 0, 314, 478, 399, 393, 381, 358, 523, 382, + 383, 372, 430, 391, 431, 373, 405, 404, 406, 0, + 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 649, 0, 0, 653, 0, 492, 0, 0, 0, 0, + 0, 0, 463, 0, 0, 384, 0, 0, 0, 508, + 0, 446, 421, 689, 0, 0, 444, 389, 477, 432, + 483, 465, 491, 438, 433, 306, 466, 351, 402, 320, + 322, 679, 353, 355, 359, 360, 411, 412, 426, 451, + 468, 469, 470, 350, 334, 445, 335, 370, 336, 307, + 342, 340, 343, 453, 344, 309, 427, 474, 0, 365, + 441, 397, 310, 396, 428, 473, 472, 321, 499, 505, + 506, 595, 0, 511, 690, 691, 692, 520, 0, 434, + 317, 316, 0, 0, 0, 346, 429, 330, 332, 333, + 331, 424, 425, 525, 526, 527, 529, 530, 531, 532, + 596, 613, 580, 550, 513, 604, 547, 551, 552, 375, + 616, 0, 0, 0, 504, 385, 386, 0, 357, 356, + 398, 437, 363, 303, 304, 685, 347, 417, 618, 651, + 652, 543, 0, 605, 544, 553, 339, 577, 589, 588, + 413, 503, 0, 600, 603, 533, 684, 0, 597, 612, + 688, 611, 681, 423, 0, 450, 609, 556, 0, 601, + 575, 0, 602, 571, 606, 0, 545, 0, 458, 485, + 497, 514, 517, 546, 631, 632, 633, 308, 516, 635, + 636, 637, 638, 639, 640, 641, 634, 488, 578, 555, + 581, 496, 558, 557, 0, 0, 592, 512, 593, 594, + 407, 408, 409, 410, 367, 619, 328, 515, 436, 0, + 579, 0, 0, 0, 0, 0, 0, 0, 0, 584, + 585, 582, 693, 0, 642, 643, 0, 0, 509, 510, + 362, 369, 528, 371, 327, 422, 364, 494, 379, 0, + 521, 586, 522, 439, 440, 645, 648, 646, 647, 0, + 0, 414, 374, 376, 454, 380, 390, 442, 493, 420, + 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 311, 464, 482, 324, 452, 495, 329, - 460, 1474, 319, 418, 449, 0, 0, 313, 480, 459, - 400, 377, 378, 312, 0, 443, 352, 368, 349, 416, - 0, 479, 507, 348, 498, 0, 490, 315, 0, 489, - 415, 476, 481, 401, 394, 0, 314, 478, 399, 393, - 381, 358, 523, 382, 383, 372, 430, 391, 431, 373, - 405, 404, 406, 0, 0, 0, 0, 0, 518, 519, - 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 649, 0, 0, 653, 0, 492, - 0, 0, 0, 0, 0, 0, 463, 0, 0, 384, - 0, 0, 0, 508, 0, 446, 421, 689, 0, 0, - 444, 389, 477, 432, 483, 465, 491, 438, 433, 306, - 466, 351, 402, 320, 322, 679, 353, 355, 359, 360, - 411, 412, 426, 451, 468, 469, 470, 350, 334, 445, - 335, 370, 336, 307, 342, 340, 343, 453, 344, 309, - 427, 474, 0, 365, 441, 397, 310, 396, 428, 473, - 472, 321, 499, 505, 506, 595, 0, 511, 690, 691, - 692, 520, 0, 434, 317, 316, 0, 0, 0, 346, - 429, 330, 332, 333, 331, 424, 425, 525, 526, 527, - 529, 530, 531, 532, 596, 613, 580, 550, 513, 604, - 547, 551, 552, 375, 616, 0, 0, 0, 504, 385, - 386, 0, 357, 356, 398, 437, 363, 303, 304, 685, - 347, 417, 618, 651, 652, 543, 0, 605, 544, 553, - 339, 577, 589, 588, 413, 503, 0, 600, 603, 533, - 684, 0, 597, 612, 688, 611, 681, 423, 0, 450, - 609, 556, 0, 601, 575, 0, 602, 571, 606, 0, - 545, 0, 458, 485, 497, 514, 517, 546, 631, 632, - 633, 308, 516, 635, 636, 637, 638, 639, 640, 641, - 634, 488, 578, 555, 581, 496, 558, 557, 0, 0, - 592, 512, 593, 594, 407, 408, 409, 410, 367, 619, - 328, 515, 436, 0, 579, 0, 0, 0, 0, 0, - 0, 0, 0, 584, 585, 582, 693, 0, 642, 643, - 0, 0, 509, 510, 362, 369, 528, 371, 327, 422, - 364, 494, 379, 0, 521, 586, 522, 439, 440, 645, - 648, 646, 647, 0, 0, 414, 374, 376, 454, 380, - 390, 442, 493, 420, 447, 325, 484, 456, 395, 572, - 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 627, 626, - 625, 624, 623, 622, 621, 620, 0, 0, 569, 471, - 341, 297, 337, 338, 345, 682, 678, 674, 683, 0, - 0, 0, 0, 305, 549, 388, 0, 435, 361, 614, - 615, 0, 666, 251, 252, 253, 254, 255, 256, 257, - 258, 298, 259, 260, 261, 262, 263, 264, 265, 268, - 269, 270, 271, 272, 273, 274, 275, 617, 266, 267, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 0, 0, 0, 299, 669, 670, - 671, 672, 673, 0, 0, 300, 301, 302, 0, 0, - 292, 293, 294, 295, 296, 0, 0, 500, 501, 502, - 524, 0, 486, 548, 680, 0, 0, 0, 0, 0, - 0, 0, 598, 610, 644, 0, 654, 655, 657, 659, - 658, 661, 461, 462, 668, 0, 663, 664, 665, 662, - 392, 448, 467, 455, 0, 686, 539, 540, 687, 650, - 419, 0, 0, 554, 587, 576, 660, 542, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 354, 0, - 0, 387, 591, 573, 583, 574, 559, 560, 561, 568, - 366, 562, 563, 564, 534, 565, 535, 566, 567, 0, - 590, 541, 457, 403, 608, 607, 0, 0, 0, 0, + 0, 0, 0, 0, 627, 626, 625, 624, 623, 622, + 621, 620, 0, 0, 569, 471, 341, 297, 337, 338, + 345, 682, 678, 674, 683, 0, 0, 0, 0, 305, + 549, 388, 0, 435, 361, 614, 615, 0, 666, 251, + 252, 253, 254, 255, 256, 257, 258, 298, 259, 260, + 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, + 273, 274, 275, 617, 266, 267, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 0, 0, 0, 299, 669, 670, 671, 672, 673, 0, + 0, 300, 301, 302, 0, 0, 292, 293, 294, 295, + 296, 0, 0, 500, 501, 502, 524, 0, 486, 548, + 680, 0, 0, 0, 0, 0, 0, 0, 598, 610, + 644, 0, 654, 655, 657, 659, 658, 661, 461, 462, + 668, 0, 663, 664, 665, 662, 392, 448, 467, 455, + 0, 686, 539, 540, 687, 650, 419, 0, 0, 554, + 587, 576, 660, 542, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 354, 0, 0, 387, 591, 573, + 583, 574, 559, 560, 561, 568, 366, 562, 563, 564, + 534, 565, 535, 566, 567, 0, 590, 541, 457, 403, + 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 0, 0, 0, 0, 323, + 238, 536, 656, 538, 537, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, - 0, 0, 0, 323, 238, 536, 656, 538, 537, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 311, 464, + 482, 324, 452, 495, 329, 460, 475, 319, 418, 449, + 0, 0, 313, 480, 459, 400, 377, 378, 312, 0, + 443, 352, 368, 349, 416, 0, 479, 507, 348, 498, + 0, 490, 315, 0, 489, 415, 476, 481, 401, 394, + 0, 314, 478, 399, 393, 381, 358, 523, 382, 383, + 372, 430, 391, 431, 373, 405, 404, 406, 0, 0, + 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 649, + 0, 0, 653, 0, 492, 0, 0, 0, 0, 0, + 0, 463, 0, 0, 384, 0, 0, 0, 508, 0, + 446, 421, 689, 0, 0, 444, 389, 477, 432, 483, + 465, 491, 438, 433, 306, 466, 351, 402, 320, 322, + 784, 353, 355, 359, 360, 411, 412, 426, 451, 468, + 469, 470, 350, 334, 445, 335, 370, 336, 307, 342, + 340, 343, 453, 344, 309, 427, 474, 0, 365, 441, + 397, 310, 396, 428, 473, 472, 321, 499, 505, 506, + 595, 0, 511, 690, 691, 692, 520, 0, 434, 317, + 316, 0, 0, 0, 346, 429, 330, 332, 333, 331, + 424, 425, 525, 526, 527, 529, 530, 531, 532, 596, + 613, 580, 550, 513, 604, 547, 551, 552, 375, 616, + 0, 0, 0, 504, 385, 386, 0, 357, 356, 398, + 437, 363, 303, 304, 685, 347, 417, 618, 651, 652, + 543, 0, 605, 544, 553, 339, 577, 589, 588, 413, + 503, 0, 600, 603, 533, 684, 0, 597, 612, 688, + 611, 681, 423, 0, 450, 609, 556, 0, 601, 575, + 0, 602, 571, 606, 0, 545, 0, 458, 485, 497, + 514, 517, 546, 631, 632, 633, 308, 516, 635, 636, + 637, 638, 639, 640, 641, 634, 488, 578, 555, 581, + 496, 558, 557, 0, 0, 592, 512, 593, 594, 407, + 408, 409, 410, 367, 619, 328, 515, 436, 0, 579, + 0, 0, 0, 0, 0, 0, 0, 0, 584, 585, + 582, 693, 0, 642, 643, 0, 0, 509, 510, 362, + 369, 528, 371, 327, 422, 364, 494, 379, 0, 521, + 586, 522, 439, 440, 645, 648, 646, 647, 0, 0, + 414, 374, 376, 454, 380, 390, 442, 493, 420, 447, + 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 627, 626, 625, 624, 623, 622, 621, + 620, 0, 0, 569, 471, 341, 297, 337, 338, 345, + 682, 678, 674, 683, 0, 0, 0, 0, 305, 549, + 388, 0, 435, 361, 614, 615, 0, 666, 251, 252, + 253, 254, 255, 256, 257, 258, 298, 259, 260, 261, + 262, 263, 264, 265, 268, 269, 270, 271, 272, 273, + 274, 275, 617, 266, 267, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 0, + 0, 0, 299, 669, 670, 671, 672, 673, 0, 0, + 300, 301, 302, 0, 0, 292, 293, 294, 295, 296, + 0, 0, 500, 501, 502, 524, 0, 486, 548, 680, + 0, 0, 0, 0, 0, 0, 0, 598, 610, 644, + 0, 654, 655, 657, 659, 658, 661, 461, 462, 668, + 0, 663, 664, 665, 662, 392, 448, 467, 455, 0, + 686, 539, 540, 687, 650, 419, 0, 0, 554, 587, + 576, 660, 542, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 354, 0, 0, 387, 591, 573, 583, + 574, 559, 560, 561, 568, 366, 562, 563, 564, 534, + 565, 535, 566, 567, 0, 590, 541, 457, 403, 608, + 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 311, 464, 482, 324, 452, 495, 329, 460, - 475, 319, 418, 449, 0, 0, 313, 480, 459, 400, - 377, 378, 312, 0, 443, 352, 368, 349, 416, 0, - 479, 507, 348, 498, 0, 490, 315, 0, 489, 415, - 476, 481, 401, 394, 0, 314, 478, 399, 393, 381, - 358, 523, 382, 383, 372, 430, 391, 431, 373, 405, - 404, 406, 0, 0, 0, 0, 0, 518, 519, 0, - 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 649, 0, 0, 653, 0, 492, 0, - 0, 0, 0, 0, 0, 463, 0, 0, 384, 0, - 0, 0, 508, 0, 446, 421, 689, 0, 0, 444, - 389, 477, 432, 483, 465, 491, 438, 433, 306, 466, - 351, 402, 320, 322, 784, 353, 355, 359, 360, 411, - 412, 426, 451, 468, 469, 470, 350, 334, 445, 335, - 370, 336, 307, 342, 340, 343, 453, 344, 309, 427, - 474, 0, 365, 441, 397, 310, 396, 428, 473, 472, - 321, 499, 505, 506, 595, 0, 511, 690, 691, 692, - 520, 0, 434, 317, 316, 0, 0, 0, 346, 429, - 330, 332, 333, 331, 424, 425, 525, 526, 527, 529, - 530, 531, 532, 596, 613, 580, 550, 513, 604, 547, - 551, 552, 375, 616, 0, 0, 0, 504, 385, 386, - 0, 357, 356, 398, 437, 363, 303, 304, 685, 347, - 417, 618, 651, 652, 543, 0, 605, 544, 553, 339, - 577, 589, 588, 413, 503, 0, 600, 603, 533, 684, - 0, 597, 612, 688, 611, 681, 423, 0, 450, 609, - 556, 0, 601, 575, 0, 602, 571, 606, 0, 545, - 0, 458, 485, 497, 514, 517, 546, 631, 632, 633, - 308, 516, 635, 636, 637, 638, 639, 640, 641, 634, - 488, 578, 555, 581, 496, 558, 557, 0, 0, 592, - 512, 593, 594, 407, 408, 409, 410, 367, 619, 328, - 515, 436, 0, 579, 0, 0, 0, 0, 0, 0, - 0, 0, 584, 585, 582, 693, 0, 642, 643, 0, - 0, 509, 510, 362, 369, 528, 371, 327, 422, 364, - 494, 379, 0, 521, 586, 522, 439, 440, 645, 648, - 646, 647, 0, 0, 414, 374, 376, 454, 380, 390, - 442, 493, 420, 447, 325, 484, 456, 395, 572, 599, + 0, 237, 0, 0, 0, 0, 0, 0, 323, 238, + 536, 656, 538, 537, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 290, 291, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 627, 626, 625, - 624, 623, 622, 621, 620, 0, 0, 569, 471, 341, - 297, 337, 338, 345, 682, 678, 674, 683, 0, 0, - 0, 0, 305, 549, 388, 0, 435, 361, 614, 615, - 0, 666, 251, 252, 253, 254, 255, 256, 257, 258, - 298, 259, 260, 261, 262, 263, 264, 265, 268, 269, - 270, 271, 272, 273, 274, 275, 617, 266, 267, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 0, 0, 0, 299, 669, 670, 671, - 672, 673, 0, 0, 300, 301, 302, 0, 0, 292, - 293, 294, 295, 296, 0, 0, 500, 501, 502, 524, - 0, 486, 548, 680, 0, 0, 0, 0, 0, 0, - 0, 598, 610, 644, 0, 654, 655, 657, 659, 658, - 661, 461, 462, 668, 0, 663, 664, 665, 662, 392, - 448, 467, 455, 0, 686, 539, 540, 687, 650, 419, - 0, 0, 554, 587, 576, 660, 542, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 354, 0, 0, - 387, 591, 573, 583, 574, 559, 560, 561, 568, 366, - 562, 563, 564, 534, 565, 535, 566, 567, 0, 590, - 541, 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, - 0, 0, 323, 238, 536, 656, 538, 537, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 311, 464, 482, + 324, 452, 495, 329, 460, 475, 319, 418, 449, 0, + 0, 313, 480, 459, 400, 377, 378, 312, 0, 443, + 352, 368, 349, 416, 0, 479, 507, 348, 498, 0, + 490, 315, 0, 489, 415, 476, 481, 401, 394, 0, + 314, 478, 399, 393, 381, 358, 523, 382, 383, 372, + 430, 391, 431, 373, 405, 404, 406, 0, 0, 0, + 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 649, 0, + 0, 653, 0, 492, 0, 0, 0, 0, 0, 0, + 463, 0, 0, 384, 0, 0, 0, 508, 0, 446, + 421, 689, 0, 0, 444, 389, 477, 432, 483, 465, + 491, 736, 433, 306, 466, 351, 402, 320, 322, 679, + 353, 355, 359, 360, 411, 412, 426, 451, 468, 469, + 470, 350, 334, 445, 335, 370, 336, 307, 342, 340, + 343, 453, 344, 309, 427, 474, 0, 365, 441, 397, + 310, 396, 428, 473, 472, 321, 499, 505, 506, 595, + 0, 511, 690, 691, 692, 520, 0, 434, 317, 316, + 0, 0, 0, 346, 429, 330, 332, 333, 331, 424, + 425, 525, 526, 527, 529, 530, 531, 532, 596, 613, + 580, 550, 513, 604, 547, 551, 552, 375, 616, 0, + 0, 0, 504, 385, 386, 0, 357, 356, 398, 437, + 363, 303, 304, 685, 347, 417, 618, 651, 652, 543, + 0, 605, 544, 553, 339, 577, 589, 588, 413, 503, + 0, 600, 603, 533, 684, 0, 597, 612, 688, 611, + 681, 423, 0, 450, 609, 556, 0, 601, 575, 0, + 602, 571, 606, 0, 545, 0, 458, 485, 497, 514, + 517, 546, 631, 632, 633, 308, 516, 635, 636, 637, + 638, 639, 640, 737, 634, 488, 578, 555, 581, 496, + 558, 557, 0, 0, 592, 512, 593, 594, 407, 408, + 409, 410, 367, 619, 328, 515, 436, 0, 579, 0, + 0, 0, 0, 0, 0, 0, 0, 584, 585, 582, + 693, 0, 642, 643, 0, 0, 509, 510, 362, 369, + 528, 371, 327, 422, 364, 494, 379, 0, 521, 586, + 522, 439, 440, 645, 648, 646, 647, 0, 0, 414, + 374, 376, 454, 380, 390, 442, 493, 420, 447, 325, + 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 290, 291, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 627, 626, 625, 624, 623, 622, 621, 620, + 0, 0, 569, 471, 341, 297, 337, 338, 345, 682, + 678, 674, 683, 0, 0, 0, 0, 305, 549, 388, + 0, 435, 361, 614, 615, 0, 666, 251, 252, 253, + 254, 255, 256, 257, 258, 298, 259, 260, 261, 262, + 263, 264, 265, 268, 269, 270, 271, 272, 273, 274, + 275, 617, 266, 267, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 0, 0, + 0, 299, 669, 670, 671, 672, 673, 0, 0, 300, + 301, 302, 0, 0, 292, 293, 294, 295, 296, 0, + 0, 500, 501, 502, 524, 0, 486, 548, 680, 0, + 0, 0, 0, 0, 0, 0, 598, 610, 644, 0, + 654, 655, 657, 659, 658, 661, 461, 462, 668, 0, + 663, 664, 665, 662, 392, 448, 467, 455, 0, 686, + 539, 540, 687, 650, 419, 0, 0, 554, 587, 576, + 660, 542, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 354, 0, 0, 387, 591, 573, 583, 574, + 559, 560, 561, 568, 366, 562, 563, 564, 534, 565, + 535, 566, 567, 0, 590, 541, 457, 403, 608, 607, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 0, 0, 0, 323, 238, 536, + 656, 538, 537, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 326, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 311, 464, 482, 324, 452, 495, 329, 460, 475, - 319, 418, 449, 0, 0, 313, 480, 459, 400, 377, - 378, 312, 0, 443, 352, 368, 349, 416, 0, 479, - 507, 348, 498, 0, 490, 315, 0, 489, 415, 476, - 481, 401, 394, 0, 314, 478, 399, 393, 381, 358, - 523, 382, 383, 372, 430, 391, 431, 373, 405, 404, - 406, 0, 0, 0, 0, 0, 518, 519, 0, 0, - 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 649, 0, 0, 653, 0, 492, 0, 0, - 0, 0, 0, 0, 463, 0, 0, 384, 0, 0, - 0, 508, 0, 446, 421, 689, 0, 0, 444, 389, - 477, 432, 483, 465, 491, 736, 433, 306, 466, 351, - 402, 320, 322, 679, 353, 355, 359, 360, 411, 412, - 426, 451, 468, 469, 470, 350, 334, 445, 335, 370, - 336, 307, 342, 340, 343, 453, 344, 309, 427, 474, - 0, 365, 441, 397, 310, 396, 428, 473, 472, 321, - 499, 505, 506, 595, 0, 511, 690, 691, 692, 520, - 0, 434, 317, 316, 0, 0, 0, 346, 429, 330, - 332, 333, 331, 424, 425, 525, 526, 527, 529, 530, - 531, 532, 596, 613, 580, 550, 513, 604, 547, 551, - 552, 375, 616, 0, 0, 0, 504, 385, 386, 0, - 357, 356, 398, 437, 363, 303, 304, 685, 347, 417, - 618, 651, 652, 543, 0, 605, 544, 553, 339, 577, - 589, 588, 413, 503, 0, 600, 603, 533, 684, 0, - 597, 612, 688, 611, 681, 423, 0, 450, 609, 556, - 0, 601, 575, 0, 602, 571, 606, 0, 545, 0, - 458, 485, 497, 514, 517, 546, 631, 632, 633, 308, - 516, 635, 636, 637, 638, 639, 640, 737, 634, 488, - 578, 555, 581, 496, 558, 557, 0, 0, 592, 512, - 593, 594, 407, 408, 409, 410, 367, 619, 328, 515, - 436, 0, 579, 0, 0, 0, 0, 0, 0, 0, - 0, 584, 585, 582, 693, 0, 642, 643, 0, 0, - 509, 510, 362, 369, 528, 371, 327, 422, 364, 494, - 379, 0, 521, 586, 522, 439, 440, 645, 648, 646, - 647, 0, 0, 414, 374, 376, 454, 380, 390, 442, - 493, 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 290, 291, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 627, 626, 625, 624, - 623, 622, 621, 620, 0, 0, 569, 471, 341, 297, - 337, 338, 345, 682, 678, 674, 683, 0, 0, 0, - 0, 305, 549, 388, 0, 435, 361, 614, 615, 0, - 666, 251, 252, 253, 254, 255, 256, 257, 258, 298, - 259, 260, 261, 262, 263, 264, 265, 268, 269, 270, - 271, 272, 273, 274, 275, 617, 266, 267, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 0, 0, 0, 299, 669, 670, 671, 672, - 673, 0, 0, 300, 301, 302, 0, 0, 292, 293, - 294, 295, 296, 0, 0, 500, 501, 502, 524, 0, - 486, 548, 680, 0, 0, 0, 0, 0, 0, 0, - 598, 610, 644, 0, 654, 655, 657, 659, 658, 661, - 461, 462, 668, 0, 663, 664, 665, 662, 392, 448, - 467, 455, 0, 686, 539, 540, 687, 650, 419, 0, - 0, 554, 587, 576, 660, 542, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 354, 0, 0, 387, - 591, 573, 583, 574, 559, 560, 561, 568, 366, 562, - 563, 564, 534, 565, 535, 566, 567, 0, 590, 541, - 457, 403, 608, 607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, - 0, 323, 238, 536, 656, 538, 537, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 326, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 311, 464, 482, 324, + 452, 495, 329, 460, 475, 319, 418, 449, 0, 0, + 313, 480, 459, 400, 377, 378, 312, 0, 443, 352, + 368, 349, 416, 0, 479, 507, 348, 498, 0, 490, + 315, 0, 489, 415, 476, 481, 401, 394, 0, 314, + 478, 399, 393, 381, 358, 523, 382, 383, 372, 430, + 391, 431, 373, 405, 404, 406, 0, 0, 0, 0, + 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 649, 0, 0, + 653, 0, 492, 0, 0, 0, 0, 0, 0, 463, + 0, 0, 384, 0, 0, 0, 508, 0, 446, 421, + 689, 0, 0, 444, 389, 477, 432, 483, 465, 491, + 438, 433, 306, 466, 351, 402, 320, 322, 679, 353, + 355, 359, 360, 411, 412, 426, 451, 468, 469, 470, + 350, 334, 445, 335, 370, 336, 307, 342, 340, 343, + 453, 344, 309, 427, 474, 0, 365, 441, 397, 310, + 396, 428, 473, 472, 321, 499, 505, 506, 595, 0, + 511, 690, 691, 692, 520, 0, 434, 317, 316, 0, + 0, 0, 346, 429, 330, 332, 333, 331, 424, 425, + 525, 526, 527, 529, 530, 531, 532, 596, 613, 580, + 550, 513, 604, 547, 551, 552, 375, 616, 0, 0, + 0, 504, 385, 386, 0, 357, 356, 398, 437, 363, + 303, 304, 685, 347, 417, 618, 651, 652, 543, 0, + 605, 544, 553, 339, 577, 589, 588, 413, 503, 0, + 600, 603, 533, 684, 0, 597, 612, 688, 611, 681, + 423, 0, 450, 609, 556, 0, 601, 575, 0, 602, + 571, 606, 0, 545, 0, 458, 485, 497, 514, 517, + 546, 631, 632, 633, 308, 516, 635, 636, 637, 638, + 639, 640, 641, 634, 488, 578, 555, 581, 496, 558, + 557, 0, 0, 592, 512, 593, 594, 407, 408, 409, + 410, 367, 619, 328, 515, 436, 0, 579, 0, 0, + 0, 0, 0, 0, 0, 0, 584, 585, 582, 693, + 0, 642, 643, 0, 0, 509, 510, 362, 369, 528, + 371, 327, 422, 364, 494, 379, 0, 521, 586, 522, + 439, 440, 645, 648, 646, 647, 0, 0, 414, 374, + 376, 454, 380, 390, 442, 493, 420, 447, 325, 484, + 456, 395, 572, 599, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 290, 291, 2134, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 627, 626, 625, 624, 623, 622, 621, 620, 0, + 0, 569, 471, 341, 297, 337, 338, 345, 682, 678, + 732, 683, 0, 2136, 0, 0, 305, 549, 388, 0, + 435, 361, 614, 615, 0, 666, 251, 252, 253, 254, + 255, 256, 257, 258, 298, 259, 260, 261, 262, 263, + 264, 265, 268, 269, 270, 271, 272, 273, 274, 275, + 617, 266, 267, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 2111, 0, 0, + 299, 669, 670, 671, 672, 673, 0, 0, 300, 301, + 302, 0, 0, 292, 293, 294, 295, 296, 0, 0, + 500, 501, 502, 524, 0, 486, 548, 680, 0, 0, + 0, 0, 0, 0, 0, 598, 610, 644, 0, 654, + 655, 657, 659, 658, 661, 461, 462, 668, 0, 663, + 664, 665, 662, 392, 448, 467, 455, 0, 686, 539, + 540, 687, 650, 0, 0, 0, 0, 2127, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 311, 464, 482, 324, 452, 495, 329, 460, 475, 319, - 418, 449, 0, 0, 313, 480, 459, 400, 377, 378, - 312, 0, 443, 352, 368, 349, 416, 0, 479, 507, - 348, 498, 0, 490, 315, 0, 489, 415, 476, 481, - 401, 394, 0, 314, 478, 399, 393, 381, 358, 523, - 382, 383, 372, 430, 391, 431, 373, 405, 404, 406, - 0, 0, 0, 0, 0, 518, 519, 0, 0, 667, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 649, 0, 0, 653, 0, 492, 0, 0, 0, - 0, 0, 0, 463, 0, 0, 384, 0, 0, 0, - 508, 0, 446, 421, 689, 0, 0, 444, 389, 477, - 432, 483, 465, 491, 438, 433, 306, 466, 351, 402, - 320, 322, 679, 353, 355, 359, 360, 411, 412, 426, - 451, 468, 469, 470, 350, 334, 445, 335, 370, 336, - 307, 342, 340, 343, 453, 344, 309, 427, 474, 0, - 365, 441, 397, 310, 396, 428, 473, 472, 321, 499, - 505, 506, 595, 0, 511, 690, 691, 692, 520, 0, - 434, 317, 316, 0, 0, 0, 346, 429, 330, 332, - 333, 331, 424, 425, 525, 526, 527, 529, 530, 531, - 532, 596, 613, 580, 550, 513, 604, 547, 551, 552, - 375, 616, 0, 0, 0, 504, 385, 386, 0, 357, - 356, 398, 437, 363, 303, 304, 685, 347, 417, 618, - 651, 652, 543, 0, 605, 544, 553, 339, 577, 589, - 588, 413, 503, 0, 600, 603, 533, 684, 0, 597, - 612, 688, 611, 681, 423, 0, 450, 609, 556, 0, - 601, 575, 0, 602, 571, 606, 0, 545, 0, 458, - 485, 497, 514, 517, 546, 631, 632, 633, 308, 516, - 635, 636, 637, 638, 639, 640, 641, 634, 488, 578, - 555, 581, 496, 558, 557, 0, 0, 592, 512, 593, - 594, 407, 408, 409, 410, 367, 619, 328, 515, 436, - 0, 579, 0, 0, 0, 0, 0, 0, 0, 0, - 584, 585, 582, 693, 0, 642, 643, 0, 0, 509, - 510, 362, 369, 528, 371, 327, 422, 364, 494, 379, - 0, 521, 586, 522, 439, 440, 645, 648, 646, 647, - 0, 0, 414, 374, 376, 454, 380, 390, 442, 493, - 420, 447, 325, 484, 456, 395, 572, 599, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 290, - 291, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 627, 626, 625, 624, 623, - 622, 621, 620, 0, 0, 569, 471, 341, 297, 337, - 338, 345, 682, 678, 732, 683, 0, 0, 0, 0, - 305, 549, 388, 0, 435, 361, 614, 615, 0, 666, - 251, 252, 253, 254, 255, 256, 257, 258, 298, 259, - 260, 261, 262, 263, 264, 265, 268, 269, 270, 271, - 272, 273, 274, 275, 617, 266, 267, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 0, 0, 0, 299, 669, 670, 671, 672, 673, - 0, 0, 300, 301, 302, 0, 0, 292, 293, 294, - 295, 296, 0, 0, 500, 501, 502, 524, 0, 486, - 548, 680, 0, 0, 0, 0, 0, 0, 0, 598, - 610, 644, 0, 654, 655, 657, 659, 658, 661, 461, - 462, 668, 0, 663, 664, 665, 662, 392, 448, 467, - 455, 0, 686, 539, 540, 687, 650, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2115, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2121, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2109, 2143, 0, 0, 2110, 2112, 2114, 0, + 2116, 2117, 2118, 2122, 2123, 2124, 2126, 2129, 2130, 2131, + 0, 0, 0, 0, 0, 0, 0, 2119, 2128, 2120, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2135, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2132, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2108, 0, 0, 0, 0, 0, 0, + 2107, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2125, 0, 0, 0, 0, 0, + 0, 0, 0, 2113, } var yyPact = [...]int{ - 269, -1000, -1000, -1000, -345, 17035, -1000, -1000, -1000, -1000, + 276, -1000, -1000, -1000, -349, 16791, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 52949, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 529, 52949, -347, 32879, 50942, -1000, -1000, + 3104, -1000, 51611, 18818, 52949, 721, 715, 58301, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 53193, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 534, 53193, -342, 33123, 51186, -1000, -1000, - 3108, -1000, 51855, 19062, 53193, 628, 624, 58545, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 1103, -1000, 57632, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 1017, 4509, 56963, 13422, -227, -1000, 2322, + -31, 2995, 593, -208, -214, 693, 1376, 1393, 1518, 1170, + 52949, 1327, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 252, 1156, 52280, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 4329, 404, 1099, 1156, 24178, 165, 141, + 2322, 484, -80, 387, -1000, 1853, 357, 215, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13422, + 13422, 16791, -408, 16791, 13422, 52949, 52949, -1000, -1000, -1000, + -1000, -347, 51611, 1017, 4509, 13422, 2995, 593, -208, -214, + 693, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 1148, -1000, 57876, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 996, 4706, 57207, 13666, -232, -1000, 2327, - -33, 2942, 531, -202, -205, 615, 1374, 1389, 1519, 1145, - 53193, 1339, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 224, 1191, 52524, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 4384, 265, 1147, 1191, 24422, 144, 143, - 2327, 509, -82, 250, -1000, 1630, 4240, 217, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13666, - 13666, 17035, -416, 17035, 13666, 53193, 53193, -1000, -1000, -1000, - -1000, -342, 51855, 996, 4706, 13666, 2942, 531, -202, -205, - 615, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -80, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -82, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7858,10 +7895,10 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 141, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 143, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7877,454 +7914,453 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 5729, -1000, 1969, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 2659, 3551, 1961, 2992, 957, 50942, + 52949, -1000, 159, 957, -1000, -1000, -1000, 2322, 3987, -1000, + 52949, 52949, 259, 2219, -1000, 786, 683, 659, 565, 432, + 1930, -1000, -1000, -1000, -1000, -1000, -1000, 891, 3970, -1000, + 52949, 52949, 52949, 3564, 52949, -1000, 464, 925, -1000, 4829, + 3772, 1712, 1137, 3576, -1000, -1000, 3550, -1000, 429, 1332, + 639, 662, 527, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 382, -1000, 3852, -1000, -1000, 423, -1000, -1000, 411, -1000, + -1000, -1000, 133, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 8, -1000, -1000, 1489, 2633, 13422, + 2400, -1000, 3312, 1978, -1000, -1000, -1000, 8712, 16110, 16110, + 16110, 16110, 52949, -1000, -1000, 3399, 13422, 3549, 3547, 3546, + 3545, -1000, -1000, -1000, -1000, -1000, -1000, 3543, 1922, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2394, -1000, + -1000, -1000, 13422, -1000, 3542, 3537, 3534, 3531, 3530, 3529, + 3528, 3527, 3525, 3524, 3522, 3521, 3520, 3519, 3208, 18139, + 3517, 2991, 2990, 3516, 3515, 3514, 2988, 3507, 3505, 3501, + 3208, 3208, 3497, 3491, 3490, 3487, 3486, 3484, 3483, 3481, + 3480, 3479, 3476, 3474, 3473, 3472, 3468, 3466, 3458, 3457, + 3451, 3449, 3447, 3445, 3443, 3442, 3440, 3439, 3438, 3435, + 3434, 3432, 3431, 3429, 3427, 3423, 3417, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 5782, -1000, 1913, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 2684, 3473, 1891, 2941, 927, 51186, - 53193, -1000, 158, 927, -1000, -1000, -1000, 2327, 3957, -1000, - 53193, 53193, 252, 2202, -1000, 676, 608, 549, 602, 414, - 1854, -1000, -1000, -1000, -1000, -1000, -1000, 858, 3908, -1000, - 53193, 53193, 53193, 3478, 53193, -1000, 398, 885, -1000, 4739, - 3724, 1647, 1097, 3517, -1000, -1000, 3472, -1000, 426, 930, - 613, 498, 533, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 388, -1000, 3809, -1000, -1000, 409, -1000, -1000, 369, -1000, - -1000, -1000, 126, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 15, -1000, -1000, 1463, 2362, 13666, - 2563, -1000, 3187, 1952, -1000, -1000, -1000, 8956, 16354, 16354, - 16354, 16354, 53193, -1000, -1000, 3289, 13666, 3458, 3456, 3455, - 3453, -1000, -1000, -1000, -1000, -1000, -1000, 3451, 1846, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2363, -1000, - -1000, -1000, 13666, -1000, 3450, 3448, 3441, 3440, 3439, 3436, - 3433, 3431, 3430, 3428, 3423, 3422, 3421, 3420, 3114, 18383, - 3418, 2939, 2938, 3417, 3416, 3408, 2935, 3406, 3403, 3402, - 3114, 3114, 3401, 3399, 3396, 3395, 3394, 3392, 3391, 3385, - 3380, 3374, 3372, 3371, 3367, 3366, 3364, 3363, 3362, 3361, - 3354, 3353, 3352, 3349, 3344, 3330, 3327, 3326, 3324, 3323, - 3322, 3320, 3315, 3314, 3313, 3307, 3305, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 1595, -1000, 3416, 3986, 3283, -1000, 3841, 3837, 3832, + 3830, -274, 3415, 2611, -1000, -1000, 116, 3969, 52949, -298, + 52949, 441, -87, -88, -91, 1114, -1000, -74, -1000, -1000, + 1330, -1000, 1302, 56294, 1063, -1000, -1000, 52949, 998, 998, + 998, 998, 52949, 225, 998, 998, 998, 998, 998, 1066, + 998, 3871, 1095, 1094, 1093, 1088, 998, -23, -1000, -1000, + -1000, -1000, -1000, -1000, 1242, -1000, -1000, -1000, -1000, 1727, + 52949, -1000, 3316, 441, -1000, 48, -328, 3575, 2130, 2130, + 3923, 3923, 3870, 3864, 939, 938, 930, 2130, 798, -1000, + 2186, 2186, 2186, 2186, 2130, 537, 933, 3874, 3874, 134, + 2186, 118, 2130, 2130, 118, 2130, 2130, -1000, 2213, 296, + -285, -1000, -1000, -1000, -1000, 2186, 2186, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 3846, 3845, 1017, 1172, 52949, 1017, + 52949, 406, 236, 52949, 1017, 1017, 1017, 52949, 1022, -336, + 58, 55625, 54956, 2697, 464, 916, 915, 1756, 2156, -1000, + 2134, 52949, 52949, 2134, 2134, 27527, 26858, -1000, 52949, -1000, + 3986, 3283, 3204, 2190, 3203, 3283, -93, 441, 1017, 1017, + 1017, 1017, 1017, 1017, 372, 1017, 1017, 1017, 1017, 1017, + 52949, 52949, 50273, 1017, 1017, 1017, 1017, 11400, 1853, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 16791, 2422, 2490, 211, -4, -325, 298, -1000, + -1000, 52949, 3721, 367, -1000, -1000, -1000, 3332, -1000, 3337, + 3337, 3337, 3337, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 3337, 3337, 3351, 3411, -1000, -1000, 3334, + 3334, 3334, 3332, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 3341, 3341, 3345, 3345, 3341, + 52949, -119, -1000, -1000, 13422, 52949, 3754, 434, 3406, 957, + -1000, -1000, 52949, 333, 474, 3986, 3739, 3874, 3914, -1000, + -1000, 1918, 2607, 2987, -1000, 432, -1000, 692, 432, -1000, + 577, 577, 2120, -1000, 1469, -1000, -1000, -1000, -1000, -1000, + -1000, 52949, 8, 1927, -1000, -1000, -1000, 2972, 3405, -1000, + 719, 1548, 1668, -1000, 381, 4701, 42914, 464, 42914, 52949, + -1000, -1000, -1000, -1000, -1000, -1000, 130, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 1672, -1000, 3302, 3910, 3160, -1000, 3791, 3786, 3782, - 3780, -281, 3301, 2600, -1000, -1000, 121, 3906, 53193, -302, - 53193, 497, -90, -92, -99, 1285, -1000, -63, -1000, -1000, - 1323, -1000, 1294, 56538, 1075, -1000, -1000, 53193, 991, 991, - 991, 991, 53193, 251, 991, 991, 991, 991, 991, 1080, - 991, 3831, 1144, 1142, 1129, 1123, 991, -39, -1000, -1000, - -1000, -1000, -1000, -1000, 1281, -1000, -1000, -1000, -1000, 1726, - 53193, -1000, 3195, 497, -1000, 75, -331, 3514, 1998, 1998, - 3890, 3890, 3829, 3826, 898, 892, 882, 1998, 750, -1000, - 2152, 2152, 2152, 2152, 1998, 581, 933, 3834, 3834, 173, - 2152, 109, 1998, 1998, 109, 1998, 1998, -1000, 2117, 358, - -288, -1000, -1000, -1000, -1000, 2152, 2152, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 3801, 3796, 996, 1063, 53193, 996, - 53193, 331, 242, 53193, 996, 996, 996, 53193, 1005, -328, - 48, 55869, 55200, 2620, 398, 881, 876, 1729, 2167, -1000, - 2113, 53193, 53193, 2113, 2113, 27771, 27102, -1000, 53193, -1000, - 3910, 3160, 3079, 2383, 3078, 3160, -100, 497, 996, 996, - 996, 996, 996, 996, 344, 996, 996, 996, 996, 996, - 53193, 53193, 50517, 996, 996, 996, 996, 11644, 1630, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, 17035, 2514, 2500, 215, -13, -325, 295, -1000, - -1000, 53193, 3685, 340, -1000, -1000, -1000, 3214, -1000, 3216, - 3216, 3216, 3216, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 3216, 3216, 3226, 3299, -1000, -1000, 3215, - 3215, 3215, 3214, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3217, 3217, - 3220, 3220, 3217, 53193, -125, -1000, -1000, 13666, 53193, 3700, - 504, 3298, 927, -1000, -1000, 53193, 333, 505, 3910, 3689, - 3834, 3883, -1000, -1000, 1841, 2586, 2931, -1000, 414, -1000, - 573, 414, -1000, 705, 705, 2098, -1000, 1418, -1000, -1000, - -1000, -1000, -1000, -1000, 53193, 15, 783, -1000, -1000, -1000, - 2905, 3297, -1000, 696, 1552, 1691, -1000, 407, 5540, 43158, - 398, 43158, 53193, -1000, -1000, -1000, -1000, -1000, -1000, 123, + -1000, 414, -1000, 13422, 13422, 13422, 13422, 13422, -1000, 852, + 15438, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 16110, 16110, + 16110, 16110, 16110, 16110, 16110, 16110, 16110, 16110, 16110, 16110, + 16110, 16110, 3398, 2203, 16110, 16110, 16110, 16110, 29534, 2190, + 3464, 1728, 330, 1978, 1978, 1978, 1978, 13422, -1000, 2254, + 2633, 13422, 13422, 13422, 13422, 36224, 52949, -1000, -1000, 5698, + 13422, 13422, 4508, 13422, 3820, 13422, 13422, 13422, 3202, 6678, + 52949, 13422, -1000, 3201, 3194, -1000, -1000, 2477, 13422, -1000, + -1000, 13422, -1000, -1000, 13422, 16110, 13422, -1000, 13422, 13422, + 13422, -1000, -1000, 1411, 1411, 1060, 3820, 3820, 3820, 2218, + 13422, 13422, 3820, 3820, 3820, 2215, 3820, 3820, 3820, 3820, + 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3193, 3190, 3189, + 3185, 3184, 13422, 13422, 13422, 13422, 13422, 12750, 3874, -227, + -1000, 10728, 3739, 3874, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -278, 3402, 52949, 2986, 2984, -358, + 202, 504, 52949, 1317, -1000, -1000, 52949, 2597, 52949, 2596, + 304, 287, 52949, 52949, 52949, 74, 1374, 1309, 1312, -1000, + -1000, 52949, 54287, -1000, 52949, 2260, 52949, 52949, 52949, 3807, + -1000, 52949, 52949, 1146, 998, 48266, 42914, 52949, 52949, 464, + 52949, 52949, 52949, 998, 998, 998, 998, 52949, -1000, 1022, + -1000, 52949, 1727, 3806, 52949, -1000, 3863, -1000, -1000, -1000, + 909, 3923, 16110, 16110, -1000, -1000, 13422, -1000, 264, 49604, + 2186, 2130, 2130, -1000, -1000, 52949, -1000, -1000, -1000, 2186, + 52949, 2186, 2186, 3923, 2186, -1000, -1000, -1000, 2130, 2130, + -1000, -1000, 13422, -1000, -1000, 2186, 2186, -1000, -1000, 3923, + 52949, 127, 3923, 3923, 112, -1000, -1000, -1000, 2130, 52949, + 52949, 998, 52949, -1000, 52949, 52949, -1000, -1000, 52949, 1017, + -1000, 2217, 2216, 3672, 4916, 52949, 447, 3764, 1209, 48266, + 48935, 3844, -1000, 42914, 52949, 52949, 1719, -1000, 1062, 40238, + -1000, 52949, 1659, -1000, 37, -1000, 53, 58, 2134, 58, + 2134, 1059, -1000, 709, 440, 25520, 633, 42914, 8031, -1000, + -1000, 2134, 2134, 8031, 8031, 1988, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 1715, -1000, 326, 3874, -1000, -1000, -1000, + -1000, -1000, 2593, -1000, 52949, 52949, 48266, 42914, 464, 52949, + 1017, 52949, 52949, 52949, 52949, 52949, -1000, 3401, 1915, -1000, + 3761, 52949, 52949, 52949, 52949, 1624, -1000, -1000, 22163, 1909, + -1000, -1000, 2239, -1000, 13422, 16791, -261, 13422, 16791, 16791, + 13422, 16791, -1000, 13422, 332, -1000, -1000, -1000, -1000, 2592, + -1000, 2587, -1000, -1000, -1000, -1000, -1000, 2983, 2983, -1000, + 2579, -1000, -1000, -1000, -1000, 2578, -1000, -1000, 2574, -1000, + -1000, -1000, -1000, -159, 3168, 1489, -1000, 2981, 3574, -229, + -1000, 23509, 52949, 52949, 434, -368, 2214, 2210, 2208, 3856, + -1000, -229, -1000, 22836, 52949, 3874, -1000, -242, 3908, 13422, + 52949, -1000, 3862, -1000, -1000, 432, -1000, -1000, -1000, 577, + 507, -1000, -1000, -1000, -1000, -1000, -1000, 1894, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -82, + -83, 1710, -1000, 52949, -1000, -1000, 381, 42914, 44921, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 293, -1000, -1000, 189, + -1000, 1058, 313, 2114, -1000, -1000, 254, 226, 262, 1168, + 2633, -1000, 2264, 2264, 2274, -1000, 814, -1000, -1000, -1000, + -1000, 3399, -1000, -1000, -1000, 2510, 2718, 1997, 2143, 2143, + 1757, 1757, 1757, 1757, 1757, 1968, 1968, -1000, -1000, -1000, + -1000, -1000, 8712, 3398, 16110, 16110, 16110, 16110, 1130, 1130, + 4237, 4485, -1000, -1000, -1000, -1000, 13422, 184, 2232, -1000, + 13422, 3020, 2076, 2784, 1753, 2097, -1000, 3332, 13422, 1866, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 422, -1000, 13666, 13666, 13666, 13666, - 13666, -1000, 1113, 15682, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 16354, 16354, 16354, 16354, 16354, 16354, 16354, 16354, 16354, - 16354, 16354, 16354, 16354, 16354, 3283, 2231, 16354, 16354, 16354, - 16354, 29778, 2383, 3715, 1727, 321, 1952, 1952, 1952, 1952, - 13666, -1000, 2228, 2362, 13666, 13666, 13666, 13666, 36468, 53193, - -1000, -1000, 4052, 13666, 13666, 5743, 13666, 3766, 13666, 13666, - 13666, 3076, 6922, 53193, 13666, -1000, 3074, 3073, -1000, -1000, - 2360, 13666, -1000, -1000, 13666, -1000, -1000, 13666, 16354, 13666, - -1000, 13666, 13666, 13666, -1000, -1000, 1050, 1050, 1046, 3766, - 3766, 3766, 2213, 13666, 13666, 3766, 3766, 3766, 2172, 3766, - 3766, 3766, 3766, 3766, 3766, 3766, 3766, 3766, 3766, 3766, - 3072, 3070, 3069, 3067, 3066, 13666, 13666, 13666, 13666, 13666, - 12994, 3834, -232, -1000, 10972, 3689, 3834, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -283, 3291, 53193, - 2930, 2917, -358, 196, 517, 53193, 1368, -1000, -1000, 53193, - 2585, 53193, 2583, 292, 254, 53193, 53193, 53193, 38, 1369, - 1313, 1319, -1000, -1000, 53193, 54531, -1000, 53193, 2243, 53193, - 53193, 53193, 3742, -1000, 53193, 53193, 1015, 991, 48510, 43158, - 53193, 53193, 398, 53193, 53193, 53193, 991, 991, 991, 991, - 53193, -1000, 1005, -1000, 53193, 1726, 3741, 53193, -1000, 3823, - -1000, -1000, -1000, 875, 3890, 16354, 16354, -1000, -1000, 13666, - -1000, 291, 49848, 2152, 1998, 1998, -1000, -1000, 53193, -1000, - -1000, -1000, 2152, 53193, 2152, 2152, 3890, 2152, -1000, -1000, - -1000, 1998, 1998, -1000, -1000, 13666, -1000, -1000, 2152, 2152, - -1000, -1000, 3890, 53193, 114, 3890, 3890, 122, -1000, -1000, - -1000, 1998, 53193, 53193, 991, 53193, -1000, 53193, 53193, -1000, - -1000, 53193, 996, -1000, 2199, 2195, 3621, 5146, 53193, 446, - 3721, 1262, 48510, 49179, 3785, -1000, 43158, 53193, 53193, 1710, - -1000, 1072, 40482, -1000, 53193, 1678, -1000, 61, -1000, 35, - 48, 2113, 48, 2113, 1058, -1000, 691, 427, 25764, 625, - 43158, 8275, -1000, -1000, 2113, 2113, 8275, 8275, 1953, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 1708, -1000, 271, 3834, - -1000, -1000, -1000, -1000, -1000, 2575, -1000, 53193, 53193, 48510, - 43158, 398, 53193, 996, 53193, 53193, 53193, 53193, 53193, -1000, - 3290, 1839, -1000, 3716, 53193, 53193, 53193, 53193, 1684, -1000, - -1000, 22407, 1834, -1000, -1000, 2257, -1000, 13666, 17035, -261, - 13666, 17035, 17035, 13666, 17035, -1000, 13666, 327, -1000, -1000, - -1000, -1000, 2569, -1000, 2566, -1000, -1000, -1000, -1000, -1000, - 2916, 2916, -1000, 2548, -1000, -1000, -1000, -1000, 2547, -1000, - -1000, 2545, -1000, -1000, -1000, -1000, -165, 3063, 1463, -1000, - 2915, 3510, -233, -1000, 23753, 53193, 53193, 504, -368, 2194, - 2192, 2184, 3813, -1000, -233, -1000, 23080, 53193, 3834, -1000, - -243, 3876, 13666, 53193, -1000, 3819, -1000, -1000, 414, -1000, - -1000, -1000, 705, 484, -1000, -1000, -1000, -1000, -1000, -1000, - 1833, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -86, -98, 1698, -1000, 53193, -1000, -1000, 407, - 43158, 45165, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 287, - -1000, -1000, 190, -1000, 1056, 294, 2097, -1000, -1000, 238, - 226, 255, 1205, 2362, -1000, 2271, 2271, 2266, -1000, 865, - -1000, -1000, -1000, -1000, 3289, -1000, -1000, -1000, 2196, 3404, - 1869, 2440, 2440, 1709, 1709, 1709, 1709, 1709, 2137, 2137, - -1000, -1000, -1000, -1000, -1000, 8956, 3283, 16354, 16354, 16354, - 16354, 1079, 1079, 2380, 4527, -1000, -1000, -1000, -1000, 13666, - 199, 2240, -1000, 13666, 2933, 2001, 2757, 1662, 2083, -1000, - 3214, 13666, 1830, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 3167, 3166, 2857, 3968, 3161, 13422, -1000, -1000, 2094, 2083, + 2078, -1000, 2604, 12078, -1000, -1000, -1000, 3159, 1865, 3156, + -1000, -1000, -1000, 3155, 2072, 1505, 3154, 2694, 3147, 3146, + 3145, 3143, 1704, 1703, 1696, -1000, -1000, -1000, -1000, 13422, + 13422, 13422, 13422, 3142, 2060, 2052, 13422, 13422, 13422, 13422, + 3141, 13422, 13422, 13422, 13422, 13422, 13422, 13422, 13422, 13422, + 13422, 52949, 191, 191, 191, 191, 191, 2062, 1860, 3425, + 3391, 2071, 1691, 1688, -1000, -1000, 2049, -1000, 2633, -1000, + -1000, 3908, -1000, 3397, 2570, 1674, -1000, -1000, -344, 2894, + 52949, 52949, 193, 52949, 2980, -299, 52949, -1000, -1000, 2978, + -1000, 52949, 52949, 52949, 52949, -107, 3750, 3747, -1000, -1000, + 1370, 1295, 1277, -1000, 52949, -1000, 2976, 3759, 3861, 1090, + -96, 52949, 3395, 3394, 998, 52949, 342, -1000, -1000, 1542, + -1000, 313, -10, 725, 1512, 3562, 1029, -120, 52949, 52949, + 52949, 52949, 3805, 47597, -1000, 3390, 2048, -1000, 3875, 52949, + 464, -1000, 1978, 1978, 2633, 52949, 52949, 52949, 3561, 52949, + 52949, 3923, 3923, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 2186, 3923, 3923, 2103, 2130, 2186, -1000, -1000, 2186, -368, + -1000, 2186, -1000, -368, 1863, -368, 52949, -1000, -1000, -1000, + 3801, 52949, 3700, 42914, 3683, 1660, -1000, -1000, -1000, 3912, + 1689, 993, 993, 1220, 809, 3910, 20825, -1000, 2055, 1427, + 1057, 3698, 410, -1000, 2055, -156, 963, 2055, 2055, 2055, + 2055, 2055, 2055, 2055, 886, 872, 2055, 2055, 2055, 2055, + 2055, 2055, 2055, 2055, 2055, 2055, 2055, 1388, 2055, 2055, + 2055, 2055, 2055, -1000, 2055, 3389, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 896, 835, -1000, -1000, 328, 464, 1054, + 78, 65, 338, 3840, 476, -1000, 471, 1542, 710, 3835, + 519, 52949, 52949, 3752, 1577, -1000, -1000, -1000, -1000, -1000, + 30203, 30203, 24851, 30203, -1000, 221, 2134, 58, 96, -1000, + -1000, 1659, 8031, 1659, 8031, 2563, -1000, -1000, 1048, -1000, + -1000, 1512, -1000, 52949, 52949, -1000, -1000, 3388, 2207, -1000, + -1000, 18139, -1000, 8031, 8031, -1000, -1000, 32210, 52949, -1000, + 4, -1000, 20, 3908, -1000, -1000, 1509, -1000, -1000, 1647, + 1512, 3571, 52949, 1509, 1509, 1509, -1000, -1000, 19487, 52949, + 52949, -1000, -1000, -1000, -316, 3923, 11400, -1000, 40238, -1000, + -1000, 46928, -1000, 46259, 2227, -1000, 16791, 2469, 208, -1000, + 294, -329, 205, 2318, 203, 2633, -1000, -1000, 3138, 3136, + 2042, -1000, 2038, 3133, 2002, 1993, 2543, -1000, 105, -1000, + 3729, 1513, -1000, 3383, -1000, 1991, 3667, -1000, 1632, -1000, + 2206, 1984, -1000, -1000, -1000, 13422, 45590, 13422, 1224, 1513, + 1962, 3664, 1632, 3908, 2966, 3739, -205, 1627, -1000, 2408, + 1857, 256, -1000, -1000, -1000, 52949, 2972, 1934, 44921, 1550, + -1000, 1039, 1850, 1846, -1000, 42914, 390, 42914, -1000, 42914, + -1000, -1000, 433, -1000, 52949, 3743, -1000, -1000, -1000, 2894, + 2204, -366, 52949, -1000, -1000, -1000, -1000, -1000, 1919, -1000, + 1130, 1130, 4237, 3815, -1000, 16110, -1000, 16110, 3319, -1000, + 2226, -1000, 13422, 2435, 5440, 13422, 5440, 1872, 28865, 36224, + -111, 3777, 3298, 52949, -1000, -1000, 13422, 13422, -1000, 3294, + -1000, -1000, -1000, -1000, 13422, 13422, 2624, -1000, 52949, -1000, + -1000, -1000, -1000, 28865, -1000, 16110, -1000, -1000, -1000, -1000, + 13422, 13422, 13422, 1576, 1576, 3280, 1913, 191, 191, 191, + 3249, 3236, 3232, 1912, 191, 3224, 3169, 3148, 3144, 3135, + 3123, 3063, 3025, 3011, 2979, 1911, -1000, 3382, -1000, -1000, + -1000, -1000, 191, 13422, 191, 13422, 191, 191, 13422, 2387, + 14766, 10728, -1000, 3739, 323, 1626, 2542, 2965, 143, -1000, + 2199, -1000, 2959, 52949, 52949, 1315, -1000, 52949, 3965, -1000, + 3964, 3962, -1000, -1000, 52949, 52949, 52949, -1000, -1000, -1000, + 1265, -1000, 2953, -1000, 324, 307, 2445, 2248, 2952, 363, + 1474, 19487, 52949, 3365, 229, 2055, 687, 42914, 908, -1000, + 52949, 2339, 2193, 3570, 1051, 3716, 52949, 52949, 3358, 628, + 3357, 3356, 3800, 606, 5839, 52949, 1555, -1000, 1825, 357, + -1000, 52949, -1000, 2541, -1000, -1000, -1000, -1000, 52949, -1000, + 464, -1000, 2130, -1000, -1000, 3923, -1000, -1000, 13422, 13422, + 3923, 2130, 2130, -1000, 2186, -1000, 52949, -1000, -368, 606, + 5839, 3316, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 5431, 851, 2526, -1000, 52949, -1000, -1000, -1000, 1034, -1000, + 1190, 998, 52949, 2313, 1190, 2312, 3355, -1000, -1000, 52949, + 52949, 52949, 52949, -1000, -1000, 52949, -1000, 52949, 52949, 52949, + 52949, 52949, 44252, -1000, 52949, 52949, -1000, 52949, 2309, 52949, + 2291, 3798, -1000, 2055, 2055, 1200, -1000, -1000, 695, -1000, + 44252, 2538, 2537, 2534, 2533, 2944, 2941, 2940, 2055, 2055, + 2531, 2939, 43583, 2937, 1413, 2530, 2525, 2523, 2517, 2936, + 1250, -1000, 2929, 2512, 2475, 2441, 52949, 3354, 2814, -1000, + -1000, 2445, 2924, 3353, 2522, 2918, 1110, 464, 2911, 3569, + 229, 2055, 475, 52949, 2183, 2171, 687, 671, 671, 724, + -15, 26189, -1000, -1000, -1000, 52949, 40238, 40238, 40238, 40238, + 40238, 40238, -1000, 3648, 3591, 3352, -1000, 3623, 3619, 3633, + 3647, 3582, 52949, 40238, 3316, -1000, 43583, -1000, -1000, -1000, + 2190, 1910, 3873, 1196, 13422, 8031, -1000, -1000, 30, 40, + -1000, -1000, -1000, -1000, 42914, 2909, 633, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 3739, 52949, 52949, 1019, 3131, 1622, + -1000, -1000, -1000, 5839, 3337, 3337, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 3337, 3337, 3351, -1000, -1000, + 3334, 3334, 3334, 3332, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 3060, 3059, 2642, 3905, 3057, 13666, -1000, - -1000, 2081, 2071, 2066, -1000, 2709, 12322, -1000, -1000, -1000, - 3056, 1829, 3055, -1000, -1000, -1000, 3052, 2058, 1498, 3051, - 2030, 3050, 3048, 3044, 3043, 1696, 1695, 1690, -1000, -1000, - -1000, -1000, 13666, 13666, 13666, 13666, 3039, 2056, 2053, 13666, - 13666, 13666, 13666, 3038, 13666, 13666, 13666, 13666, 13666, 13666, - 13666, 13666, 13666, 13666, 53193, 161, 161, 161, 161, 161, - 1995, 1964, 3693, 3654, 1921, 1689, 1688, -1000, -1000, 2052, - -1000, 2362, -1000, -1000, 3876, -1000, 3274, 2544, 1683, -1000, - -1000, -339, 2829, 53193, 53193, 194, 53193, 2914, -303, 53193, - -1000, -1000, 2913, -1000, 53193, 53193, 53193, 53193, -112, 3696, - 3694, -1000, -1000, 1356, 1293, 1288, -1000, 53193, -1000, 2912, - 3705, 3818, 1030, -104, 53193, 3271, 3270, 991, 53193, 325, - -1000, -1000, 1582, -1000, 294, -30, 641, 1505, 3267, 949, - -126, 53193, 53193, 53193, 53193, 3739, 47841, -1000, 3269, 2050, - -1000, 3835, 53193, 398, -1000, 1952, 1952, 2362, 53193, 53193, - 53193, 3259, 53193, 53193, 3890, 3890, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 2152, 3890, 3890, 1803, 1998, 2152, -1000, - -1000, 2152, -368, -1000, 2152, -1000, -368, 1828, -368, 53193, - -1000, -1000, -1000, 3737, 53193, 3651, 43158, 3630, 1680, -1000, - -1000, -1000, 3881, 1540, 972, 972, 1196, 916, 3879, 21069, - -1000, 2034, 1420, 1054, 3646, 418, -1000, 2034, -161, 947, - 2034, 2034, 2034, 2034, 2034, 2034, 2034, 846, 842, 2034, - 2034, 2034, 2034, 2034, 2034, 2034, 2034, 2034, 2034, 2034, - 1378, 2034, 2034, 2034, 2034, 2034, -1000, 2034, 3268, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 863, 800, -1000, -1000, - 303, 398, 1038, 84, 83, 314, 3771, 464, -1000, 499, - 1582, 717, 3765, 524, 53193, 53193, 3794, 1562, -1000, -1000, - -1000, -1000, -1000, 30447, 30447, 25095, 30447, -1000, 213, 2113, - 48, 59, -1000, -1000, 1678, 8275, 1678, 8275, 2536, -1000, - -1000, 1034, -1000, -1000, 1505, -1000, 53193, 53193, -1000, -1000, - 3262, 2178, -1000, -1000, 18383, -1000, 8275, 8275, -1000, -1000, - 32454, 53193, -1000, 8, -1000, 44, 3876, -1000, -1000, 1475, - -1000, -1000, 1676, 1505, 3503, 53193, 1475, 1475, 1475, -1000, - -1000, 19731, 53193, 53193, -1000, -1000, -1000, -314, 3890, 11644, - -1000, 40482, -1000, -1000, 47172, -1000, 46503, 2206, -1000, 17035, - 2488, 208, -1000, 278, -333, 207, 2259, 205, 2362, -1000, - -1000, 3033, 3032, 2048, -1000, 2042, 3030, 2038, 2035, 2535, - -1000, 105, -1000, 3687, 1512, -1000, 3254, -1000, 1997, 3616, - -1000, 1675, -1000, 2176, 1986, -1000, -1000, -1000, 13666, 45834, - 13666, 1261, 1512, 1985, 3612, 1675, 3876, 2907, 3689, -210, - 1669, -1000, 2538, 1823, 225, -1000, -1000, -1000, 53193, 2905, - 1970, 45165, 1559, -1000, 1032, 1820, 1818, -1000, 43158, 382, - 43158, -1000, 43158, -1000, -1000, 437, -1000, 53193, 3691, -1000, - -1000, -1000, 2829, 2170, -365, 53193, -1000, -1000, -1000, -1000, - -1000, 1968, -1000, 1079, 1079, 2380, 2638, -1000, 16354, -1000, - 16354, 3555, -1000, 2203, -1000, 13666, 2435, 5050, 13666, 5050, - 1717, 29109, 36468, -113, 3718, 3550, 53193, -1000, -1000, 13666, - 13666, -1000, 3545, -1000, -1000, -1000, -1000, 13666, 13666, 2605, - -1000, 53193, -1000, -1000, -1000, -1000, 29109, -1000, 16354, -1000, - -1000, -1000, -1000, 13666, 13666, 13666, 1659, 1659, 3538, 1966, - 161, 161, 161, 3512, 3474, 3414, 1927, 161, 3383, 3359, - 3347, 3328, 3281, 3265, 3257, 3181, 3177, 3173, 1909, -1000, - 3236, -1000, -1000, -1000, -1000, 161, 13666, 161, 13666, 161, - 161, 13666, 2354, 15010, 10972, -1000, 3689, 323, 1661, 2531, - 2889, 135, -1000, 2166, -1000, 2888, 53193, 53193, 1317, -1000, - 53193, 3903, -1000, 3902, 3901, -1000, -1000, 53193, 53193, 53193, - -1000, -1000, -1000, 1289, -1000, 2879, -1000, 320, 297, 2397, - 2215, 2876, 357, 1417, 19731, 53193, 3235, 206, 2034, 729, - 43158, 873, -1000, 53193, 2604, 2163, 3502, 1004, 3681, 53193, - 53193, 3233, 468, 3232, 3231, 3729, 598, 5877, 53193, 1573, - -1000, 1798, 4240, -1000, 53193, -1000, 2530, -1000, -1000, -1000, - -1000, 53193, -1000, 398, -1000, 1998, -1000, -1000, 3890, -1000, - -1000, 13666, 13666, 3890, 1998, 1998, -1000, 2152, -1000, 53193, - -1000, -368, 598, 5877, 3195, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 5450, 780, 2715, -1000, 53193, -1000, -1000, - -1000, 953, -1000, 1223, 991, 53193, 2322, 1223, 2321, 3230, - -1000, -1000, 53193, 53193, 53193, 53193, -1000, -1000, 53193, -1000, - 53193, 53193, 53193, 53193, 53193, 44496, -1000, 53193, 53193, -1000, - 53193, 2318, 53193, 2294, 3695, -1000, 2034, 2034, 1238, -1000, - -1000, 674, -1000, 44496, 2524, 2523, 2522, 2519, 2875, 2872, - 2871, 2034, 2034, 2510, 2865, 43827, 2861, 1467, 2507, 2506, - 2504, 2556, 2860, 1250, -1000, 2859, 2495, 2492, 2476, 53193, - 3229, 2751, -1000, -1000, 2397, 2856, 3228, 2499, 2854, 1151, - 398, 2848, 3501, 206, 2034, 450, 53193, 2149, 2141, 729, - 661, 661, 638, -31, 26433, -1000, -1000, -1000, 53193, 40482, - 40482, 40482, 40482, 40482, 40482, -1000, 3576, 3526, 3227, -1000, - 3569, 3542, 3578, 3575, 2945, 53193, 40482, 3195, -1000, 43827, - -1000, -1000, -1000, 2383, 1906, 3875, 1170, 13666, 8275, -1000, - -1000, 47, 24, -1000, -1000, -1000, -1000, 43158, 2847, 625, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3689, 53193, 53193, - 995, 3029, 1655, -1000, -1000, -1000, 5877, 3216, 3216, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3216, 3216, - 3226, -1000, -1000, 3215, 3215, 3215, 3214, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3217, 3217, 3220, - 3220, 3217, -1000, -1000, -1000, -1000, 3877, -1000, 1653, -1000, - -1000, 1797, -1000, 2233, -347, 17035, 2225, 2060, -1000, 13666, - 17035, 13666, -268, 444, -270, -1000, -1000, -1000, 2845, -1000, - -1000, -1000, 2493, -1000, 2491, -1000, 201, 228, 2282, -233, - 10972, 507, 53193, -233, 53193, 10972, -1000, 53193, 189, -383, - -404, 172, 2843, 493, -233, 3689, 105, -1000, -127, 13666, - 3638, -1000, -1000, 53193, 2483, -1000, -1000, -1000, 3900, 43158, - 398, 1977, 42489, -1000, 386, -1000, 284, 658, 2842, -1000, - 1122, 134, 2830, 2829, -1000, -1000, -1000, -1000, 16354, 1952, - -1000, -1000, -1000, 2362, 13666, 3028, -1000, 1274, 1274, 2736, - 3025, 3024, -1000, 3216, 3216, -1000, 3214, 3215, 3214, 1274, - 1274, 3018, -1000, 3197, -1000, 3718, -1000, 2596, 3127, -1000, - 3121, 3117, 13666, -1000, 3017, 4276, 1811, 1687, 3109, -47, - -194, 161, 161, -1000, -1000, -1000, -1000, 161, 161, 161, - 161, -1000, 161, 161, 161, 161, 161, 161, 161, 161, - 161, 161, 161, 944, -1000, 1896, -1000, 1768, -1000, -1000, - 3104, -97, -292, -101, -293, -1000, -1000, 3016, 1622, -1000, - -1000, -1000, -1000, -1000, 5743, 1581, 653, 653, 2829, 2828, - -1000, 1029, 2821, 1349, 53193, 2820, -304, 53193, 53193, 102, - 2143, 2326, -1000, 2814, -1000, -1000, 53193, 53193, 53193, 53862, - 798, 53193, 53193, 2813, -1000, -166, 3196, -106, 2812, 3013, - 1579, -1000, -1000, 53193, -1000, -1000, -1000, 3011, 3195, 20400, - 2611, -1000, -1000, -1000, 31785, 661, -1000, -1000, -1000, 791, - 470, 2478, 650, -1000, 53193, 619, 3636, 2140, 2810, 53193, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3681, -1000, - 1141, -368, 576, 38475, 17714, -1000, 435, 53193, -1000, 53193, - 20400, 20400, 435, 584, 2092, -1000, 927, 1492, 148, 40482, - 53193, -1000, 39813, 3010, -1000, -1000, -1000, 1505, 3890, -1000, - 2362, 2362, -368, 3890, 3890, 1998, -1000, -1000, 584, -1000, - 3727, -1000, 1707, 21738, 697, 587, 563, -1000, 805, -1000, - -1000, 912, 3673, 5877, -1000, 53193, -1000, 53193, -1000, 53193, - 53193, 991, 13666, 3673, 53193, 1023, -1000, 1388, 580, 552, - 929, 929, 1564, -1000, 3718, -1000, -1000, 1560, -1000, -1000, - -1000, -1000, 53193, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 29109, 29109, 3763, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 2808, 2807, -1000, -1000, + -1000, 3341, 3341, 3345, 3345, 3341, -1000, -1000, -1000, -1000, + 3918, -1000, 1620, -1000, -1000, 1812, -1000, 2256, -351, 16791, + 2231, 2080, -1000, 13422, 16791, 13422, -263, 453, -266, -1000, + -1000, -1000, 2908, -1000, -1000, -1000, 2521, -1000, 2518, -1000, + 219, 234, 2290, -229, 10728, 480, 52949, -229, 52949, 10728, + -1000, 52949, 179, -377, -380, 169, 2903, 479, -229, 3739, + 105, -1000, -121, 13422, 3692, -1000, -1000, 52949, 2516, -1000, + -1000, -1000, 3960, 42914, 464, 2013, 42245, -1000, 409, -1000, + 291, 681, 2896, -1000, 1082, 142, 2895, 2894, -1000, -1000, + -1000, -1000, 16110, 1978, -1000, -1000, -1000, 2633, 13422, 3129, + -1000, 1241, 1241, 2354, 3127, 3126, -1000, 3337, 3337, -1000, + 3332, 3334, 3332, 1241, 1241, 3111, -1000, 3321, -1000, 3777, + -1000, 2586, 2932, -1000, 2926, 2910, 13422, -1000, 3106, 4142, + 1874, 1818, 2876, -42, -189, 191, 191, -1000, -1000, -1000, + -1000, 191, 191, 191, 191, -1000, 191, 191, 191, 191, + 191, 191, 191, 191, 191, 191, 191, 959, -1000, 1839, + -1000, 1599, -1000, -1000, 2851, -95, -290, -97, -293, -1000, + -1000, 3100, 1606, -1000, -1000, -1000, -1000, -1000, 4508, 1605, + 736, 736, 2894, 2893, -1000, 1038, 2890, 1347, 52949, 2889, + -313, 52949, 52949, 83, 2246, 2341, -1000, 2888, -1000, -1000, + 52949, 52949, 52949, 53618, 829, 52949, 52949, 2884, -1000, -161, + 3318, -100, 2883, 3099, 1600, -1000, -1000, 52949, -1000, -1000, + -1000, 3096, 3316, 20156, 2626, -1000, -1000, -1000, 31541, 671, + -1000, -1000, -1000, 849, 362, 2509, 660, -1000, 52949, 656, + 3681, 2161, 2878, 52949, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 3716, -1000, 1359, -368, 568, 38231, 17470, -1000, + 427, 52949, -1000, 52949, 20156, 20156, 427, 591, 2220, -1000, + 957, 1537, 152, 40238, 52949, -1000, 39569, 3095, -1000, -1000, + -1000, 1512, 3923, -1000, 2633, 2633, -368, 3923, 3923, 2130, + -1000, -1000, 591, -1000, 3794, -1000, 1009, 21494, 767, 560, + 509, -1000, 804, -1000, -1000, 956, 3702, 5839, -1000, 52949, + -1000, 52949, -1000, 52949, 52949, 998, 13422, 3702, 52949, 1032, + -1000, 1340, 600, 571, 1016, 1016, 1594, -1000, 3777, -1000, + -1000, 1571, -1000, -1000, -1000, -1000, 52949, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 28865, 28865, 3829, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 2869, 2868, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 53193, 1884, -1000, - 2139, 2805, -106, 7603, -1000, -1000, 1011, -1000, 3500, 1109, - 2611, 31785, 2134, 2113, 2793, 2792, 661, -1000, 2791, 2786, - -1000, 2604, 2128, 1104, 53193, -1000, 1482, 53193, 53193, -1000, - 1670, -1000, 2126, 3482, 3497, 3482, -1000, 3482, -1000, -1000, - -1000, -1000, 3571, 2785, -1000, 3567, -1000, 3532, -1000, -1000, - -1000, -1000, 1670, -1000, -1000, -1000, -1000, -1000, 1170, -1000, - 3816, 1223, 1223, 1223, 3007, -1000, -1000, -1000, -1000, 1559, - 3006, -1000, -1000, 3815, -1000, -1000, -1000, -1000, -1000, -1000, - 19731, 3661, 3885, 3874, 41820, -1000, -347, 2086, -1000, 2337, - 202, 2200, 53193, -1000, -1000, -1000, 3003, 3002, -246, 204, - 3873, 3872, 1218, -1000, 3001, 1556, -233, -1000, -1000, 1512, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -413, -233, -1000, - 1512, 3815, 201, 385, -1000, -1000, 3652, -1000, -1000, 398, - -1000, 282, -1000, -1000, -1000, -1000, -1000, -1000, 273, -1000, - 53193, -1000, 1534, 132, -1000, 2362, -1000, -1000, -1000, -1000, - -1000, 5050, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, 2775, -1000, -1000, 13666, -1000, -1000, -1000, 2993, - -1000, -1000, 13666, 13666, -1000, 2997, 2771, 2995, 2770, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 3910, -1000, 3871, 161, - 13666, 161, 13666, 161, 1868, 2994, 2991, 1842, 2989, 2988, - -1000, 13666, 2987, 5743, 1248, 2768, 1248, -1000, -1000, 523, - 31116, 53193, 3898, -1000, 53193, 997, -368, 601, 3191, -1000, - 607, 2143, 1345, 3190, 2756, -1000, -1000, 53193, 2397, 797, - 2397, 847, 53193, -314, -108, 2468, 7603, -1000, 2754, -1000, - -118, 1417, 5877, 1152, 3726, 2983, 1514, -1000, -1000, -1000, - -1000, -1000, 2753, 286, -1000, -1000, -1000, -1000, 2465, -1000, - -1000, 2470, 1948, 307, -1000, -1000, -1000, -1000, -1000, -1000, - 2386, 53193, 41151, 2610, 2120, -369, -1000, 3189, -1000, 2034, - 2034, 2034, 997, 53193, 1835, -1000, 2034, 2034, 2982, -1000, - -1000, 997, 2979, 2978, -135, 957, 2129, 2124, -1000, 2458, - 30447, 40482, 39813, 1668, -1000, 1785, -1000, -1000, -1000, -1000, - -1000, -1000, 3890, 957, 435, 716, 2455, 16354, 3188, 16354, - 3184, 730, 3172, 1816, -1000, 53193, -1000, -1000, 53193, 501, - 3171, -1000, 3167, 3183, 651, 3165, 3164, 53193, 2862, -1000, - 3673, 53193, 880, 3660, -1000, -1000, -1000, 543, -1000, -1000, - -1000, 804, -1000, 53193, -1000, 53193, -1000, 1912, -1000, 29109, - -1000, -1000, 1814, -1000, 2751, 2750, -1000, -1000, 2975, 2362, - -1000, 2327, 398, 1089, 53193, -1000, 286, 2749, 8275, -1000, - -1000, -1000, -1000, -1000, 3636, 2747, 2386, 53193, -1000, 53193, - 1482, 1482, 3910, 53193, 10972, -1000, -1000, 13666, 3163, -1000, - 13666, -1000, -1000, -1000, 2974, -1000, -1000, -1000, -1000, -1000, - 3162, 3599, -1000, -1000, -1000, -1000, -1000, -1000, 3914, -1000, - 1957, -1000, 13666, 14338, -1000, 975, 17035, -271, 440, -1000, - -1000, -1000, -248, 2746, -1000, -1000, 3870, 2744, 2643, 53193, - -1000, -1000, 1512, -1000, 1512, -1000, -246, 13666, -1000, -1000, - 1505, -1000, -1000, 1422, 855, -1000, 2972, 302, -1000, 2858, - -1000, 2844, 2794, 161, -1000, 161, -1000, 289, 13666, -1000, - 2778, -1000, 2772, -1000, -1000, 2738, -1000, -1000, -1000, 2737, - -1000, -1000, 2740, -1000, 2970, -1000, 2723, -1000, -1000, 53193, - -1000, -1000, 1344, 2722, -1000, 511, 997, -1000, 411, 53193, - 645, -1000, 39144, 7603, -373, -1000, 2721, 2397, 2720, 2397, - 53193, 795, -1000, 3697, 2719, -1000, 2968, -1000, 2718, 2717, - -1000, -1000, 5877, 435, -135, 20400, -1000, -1000, 434, 474, - -1000, -1000, 2417, 703, -1000, -1000, 2716, 733, -1000, 1482, - -1000, 2114, 2331, 2661, 36468, 29109, 29778, 2714, -1000, -1000, - -1000, 38475, 1957, 1957, 4738, -1000, 422, 6323, -1000, 3159, - 1407, 2115, -1000, 2443, -1000, 2434, -1000, 3890, 1668, 139, - -1000, -1000, 1976, -1000, 1407, -1000, 2715, 3865, -1000, 3904, - 53193, 3277, 53193, 3154, 2111, 16354, -1000, 912, 3596, -1000, - -1000, 501, -1000, -1000, 2320, 16354, -1000, -1000, 2710, 29778, - 1134, 2106, 2101, 1157, 3142, -1000, 809, 3913, -1000, -1000, - -1000, 1230, 3141, -1000, 2280, 2272, -1000, 53193, -1000, 36468, - 36468, 828, 828, 36468, 36468, 3131, 929, -1000, -1000, 16354, - -1000, -1000, 2034, -1000, -1000, -1000, 2034, 1817, -1000, -1000, - -1000, -1000, -1000, 53193, 1777, -1000, -1000, -1000, 2610, -1000, - -1000, 1475, -1000, 3834, -1000, -1000, 2362, 53193, 2362, -1000, - 37806, -1000, 3861, 3860, -1000, -1000, 2362, 279, 274, 3130, - 3129, -1000, -347, 53193, 53193, -250, 2415, -1000, 2707, 237, - -1000, -1000, 1472, -248, 1463, -253, 122, 29109, 2099, -1000, - 2964, 381, -148, -1000, -1000, -1000, -1000, -1000, 2957, -1000, - 966, -1000, -1000, -1000, 1463, 161, 161, 2955, 2952, -1000, - -1000, -1000, -1000, 53193, -1000, 53193, -1000, 53193, 2703, 2414, - -1000, -1000, 1807, -1000, -1000, -1000, 2263, 2248, 1799, 2948, - 2327, 2655, -314, 2700, -314, 2685, 784, 2397, -285, -1000, - -1000, -1000, -1000, -121, -1000, -139, -1000, -1000, 687, 2623, - -1000, -1000, 471, -1000, -1000, -1000, 2386, 2682, -1000, -1000, - 131, -1000, 2068, 1794, -1000, -1000, -1000, -1000, -1000, -1000, - 908, -1000, 435, 6140, -1000, 1420, -1000, 1422, 908, 35130, - 758, 330, -1000, 2412, -1000, -1000, 3910, -1000, 755, -1000, - 721, -1000, 1790, -1000, 1789, 37137, 2411, 2869, -1000, 6089, - 1085, -1000, -1000, 2380, -1000, -1000, -1000, -1000, -1000, -1000, - 2679, 2678, -1000, -1000, -1000, -1000, -1000, 2407, 3126, 107, - 3760, 2673, -1000, -1000, 3125, 1769, 1749, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1740, 1725, 36468, - -1000, -1000, 2380, 2404, 29109, 2034, 1762, 53193, -1000, -1000, - 1704, 1682, -1000, -1000, -1000, -1000, -1000, -323, 3124, 13666, - 13666, -1000, -1000, -1000, 3120, -1000, -1000, 3859, -250, -255, - 2670, 187, 234, -1000, 2669, -1000, -123, 3585, -154, -1000, - -1000, 1013, -234, 151, 138, 136, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 53193, - 2668, -1000, -1000, 130, -1000, 2065, -1000, -314, -1000, -314, - 2397, 2662, -1000, 53193, -1000, 516, -1000, -1000, 272, -1000, - -1000, -1000, -1000, -1000, -1000, 2661, 2660, -1000, 655, 3858, - -1000, 6323, -1000, 2034, -1000, 655, 1673, -1000, 2034, 2034, - -1000, 596, -1000, 2105, -1000, 2396, -1000, 3834, -1000, 590, - -1000, 677, -1000, -1000, -1000, 1660, -1000, -1000, -1000, 6089, - 718, -1000, 903, 3116, -1000, -1000, 2867, 13666, 3114, 2034, - 2849, -110, 36468, 3179, 3175, 3123, 3119, 1652, -1000, -1000, - 29109, 53193, -1000, -1000, -1000, 35799, -1000, 3113, 1624, 1620, - 53193, 2643, -1000, -1000, 2656, -1000, 998, 241, 234, -1000, - 3855, 236, 3853, 3851, 1453, 3553, -1000, -1000, 2207, -1000, - 200, 198, 188, -1000, -1000, -1000, -1000, 2314, 2314, -1000, - 2655, 2653, -1000, -1000, 2652, -314, 616, -1000, 807, -1000, - -1000, -1000, -1000, -1000, 365, -1000, 3840, 780, -1000, 29109, - -1000, -1000, 35130, 1957, 1957, -1000, -1000, 2392, -1000, -1000, - -1000, -1000, 2391, -1000, -1000, -1000, 1597, -1000, 53193, 1130, - 10300, -1000, 2617, -1000, 53193, -1000, 3484, -1000, 353, 1594, - 365, 828, 365, 828, 365, 828, 365, 828, 366, -1000, - -1000, -1000, -1000, 1593, 13666, -1000, -1000, 1536, -1000, -1000, - -1000, 3111, 2385, 204, 223, 3838, -1000, 2643, 3837, 2643, - 2643, -1000, 170, -142, 1013, -1000, -1000, -1000, -1000, 2143, - -1000, 2143, -1000, -1000, -314, -1000, 2650, -1000, -1000, 378, - -1000, 2034, 2034, 2649, 2648, 565, -1000, -1000, 2034, 2034, - 2034, 2034, 34461, 697, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 718, 6323, -1000, 10300, 1525, -1000, 2362, -1000, 929, - -1000, -1000, 3386, 3112, 3896, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 3093, 2777, -1000, 53193, 3752, - 28440, 210, -1000, -1000, -1000, 2644, -1000, 2643, -1000, -1000, - 2032, -152, -1000, -1000, -1000, -1000, -290, -1000, 2381, 2371, - -1000, -1000, 53193, 2370, 2361, 2359, 2636, -1000, 53193, 716, - -1000, 6323, 1509, -1000, 10300, -1000, -1000, 3912, -1000, 3897, - 1112, 1112, 365, 365, 365, 365, 13666, -1000, -1000, -1000, - 53193, -1000, 1504, -1000, -1000, -1000, 1734, -1000, -1000, -1000, - -1000, 2635, -156, -1000, -1000, 2632, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 1499, 2715, -1000, -1000, -1000, -1000, -1000, - 2401, 814, -1000, 2745, 1452, -1000, 2018, -1000, 33792, 53193, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 53193, - 9628, -1000, 1631, -1000, -1000, 2362, 53193, -1000, + -1000, 52949, 1896, -1000, 2160, 2867, -100, 7359, -1000, -1000, + 1024, -1000, 3567, 1074, 2626, 31541, 2146, 2134, 2865, 2862, + 671, -1000, 2844, 2843, -1000, 2339, 2141, 1071, 52949, -1000, + 1511, 52949, 52949, -1000, 1601, -1000, 2140, 3556, 3566, 3556, + -1000, 3556, -1000, -1000, -1000, -1000, 3646, 2842, -1000, 3640, + -1000, 3637, -1000, -1000, -1000, -1000, 1601, -1000, -1000, -1000, + -1000, -1000, 1196, -1000, 3859, 1190, 1190, 1190, 3094, -1000, + -1000, -1000, -1000, 1550, 3089, -1000, -1000, 3858, -1000, -1000, + -1000, -1000, -1000, -1000, 19487, 3709, 3916, 3905, 41576, -1000, + -351, 2225, -1000, 2336, 201, 2258, 52949, -1000, -1000, -1000, + 3087, 3082, -244, 248, 3904, 3902, 1273, -1000, 3079, 1540, + -229, -1000, -1000, 1513, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -383, -229, -1000, 1513, 3858, 219, 396, -1000, -1000, + 3728, -1000, -1000, 464, -1000, 284, -1000, -1000, -1000, -1000, + -1000, -1000, 283, -1000, 52949, -1000, 1535, 140, -1000, 2633, + -1000, -1000, -1000, -1000, -1000, 5440, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 2839, -1000, -1000, 13422, + -1000, -1000, -1000, 2836, -1000, -1000, 13422, 13422, -1000, 3078, + 2829, 3071, 2825, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 3986, -1000, 3900, 191, 13422, 191, 13422, 191, 1891, 3070, + 3064, 1842, 3061, 3058, -1000, 13422, 3056, 4508, 1207, 2823, + 1207, -1000, -1000, 515, 30872, 52949, 3933, -1000, 52949, 1020, + -368, 632, 3315, -1000, 684, 2246, 1346, 3313, 2822, -1000, + -1000, 52949, 2445, 826, 2445, 893, 52949, -316, -102, 2506, + 7359, -1000, 2819, -1000, -115, 1474, 5839, 1092, 3784, 3044, + 1529, -1000, -1000, -1000, -1000, -1000, 2818, 311, -1000, -1000, + -1000, -1000, 2500, -1000, -1000, 2440, 1763, 308, -1000, -1000, + -1000, -1000, -1000, -1000, 2414, 52949, 40907, 2520, 2135, -370, + -1000, 3307, -1000, 2055, 2055, 2055, 1020, 52949, 1840, -1000, + 2055, 2055, 3043, -1000, -1000, 1020, 3037, 3035, -122, 978, + 2173, 2152, -1000, 2496, 30203, 40238, 39569, 1556, -1000, 1798, + -1000, -1000, -1000, -1000, -1000, -1000, 3923, 978, 427, 746, + 2495, 16110, 3305, 16110, 3304, 792, 3303, 1823, -1000, 52949, + -1000, -1000, 52949, 4385, 3302, -1000, 3300, 3559, 732, 3297, + 3288, 52949, 2810, -1000, 3702, 52949, 889, 3703, -1000, -1000, + -1000, 544, -1000, -1000, -1000, 837, -1000, 52949, -1000, 52949, + -1000, 1878, -1000, 28865, -1000, -1000, 1808, -1000, 2814, 2813, + -1000, -1000, 3031, 2633, -1000, 2322, 464, 1070, 52949, -1000, + 311, 2812, 8031, -1000, -1000, -1000, -1000, -1000, 3681, 2799, + 2414, 52949, -1000, 52949, 1511, 1511, 3986, 52949, 10728, -1000, + -1000, 13422, 3285, -1000, 13422, -1000, -1000, -1000, 3028, -1000, + -1000, -1000, -1000, -1000, 3282, 3688, -1000, -1000, -1000, -1000, + -1000, -1000, 3976, -1000, 1736, -1000, 13422, 14094, -1000, 996, + 16791, -267, 451, -1000, -1000, -1000, -247, 2798, -1000, -1000, + 3898, 2797, 2644, 52949, -1000, -1000, 1513, -1000, 1513, -1000, + -244, 13422, -1000, -1000, 1512, -1000, -1000, 1429, 888, -1000, + 3027, 297, -1000, 2765, -1000, 2686, 2680, 191, -1000, 191, + -1000, 300, 13422, -1000, 2641, -1000, 2629, -1000, -1000, 2794, + -1000, -1000, -1000, 2793, -1000, -1000, 2590, -1000, 3022, -1000, + 2791, -1000, -1000, 52949, -1000, -1000, 1339, 2783, -1000, 505, + 1020, -1000, 458, 52949, 731, -1000, 38900, 7359, -372, -1000, + 2766, 2445, 2740, 2445, 52949, 819, -1000, 3775, 2739, -1000, + 3019, -1000, 2737, 2735, -1000, -1000, 5839, 427, -122, 20156, + -1000, -1000, 430, 488, -1000, -1000, 2418, 729, -1000, -1000, + 2727, 720, -1000, 1511, -1000, 2133, 2356, 2692, 36224, 28865, + 29534, 2726, -1000, -1000, -1000, 38231, 1736, 1736, 6065, -1000, + 414, 58831, -1000, 3276, 1403, 2126, -1000, 2492, -1000, 2488, + -1000, 3923, 1556, 148, -1000, -1000, 2001, -1000, 1403, -1000, + 2526, 3897, -1000, 3535, 52949, 3183, 52949, 3274, 2132, 16110, + -1000, 956, 3661, -1000, -1000, 4385, -1000, -1000, 2323, 16110, + -1000, -1000, 2724, 29534, 1159, 2115, 2108, 1143, 3272, -1000, + 845, 3975, -1000, -1000, -1000, 1178, 3271, -1000, 2282, 2279, + -1000, 52949, -1000, 36224, 36224, 879, 879, 36224, 36224, 3268, + 1016, -1000, -1000, 16110, -1000, -1000, 2055, -1000, -1000, -1000, + 2055, 1859, -1000, -1000, -1000, -1000, -1000, 52949, 1777, -1000, + -1000, -1000, 2520, -1000, -1000, 1509, -1000, 3874, -1000, -1000, + 2633, 52949, 2633, -1000, 37562, -1000, 3896, 3894, -1000, -1000, + 2633, 275, 273, 3259, 3258, -1000, -351, 52949, 52949, -249, + 2487, -1000, 2721, 243, -1000, -1000, 1508, -247, 1489, -253, + 112, 28865, 2093, -1000, 3017, 389, -147, -1000, -1000, -1000, + -1000, -1000, 3016, -1000, 981, -1000, -1000, -1000, 1489, 191, + 191, 3005, 3002, -1000, -1000, -1000, -1000, 52949, -1000, 52949, + -1000, 52949, 2717, 2485, -1000, -1000, 1807, -1000, -1000, -1000, + 2272, 2270, 1789, 3001, 2322, 2687, -316, 2714, -316, 2713, + 800, 2445, -282, -1000, -1000, -1000, -1000, -116, -1000, -140, + -1000, -1000, 688, 2670, -1000, -1000, 486, -1000, -1000, -1000, + 2414, 2712, -1000, -1000, 135, -1000, 2087, 1768, -1000, -1000, + -1000, -1000, -1000, -1000, 954, -1000, 427, 5090, -1000, 1427, + -1000, 1429, 954, 34886, 778, 331, -1000, 2480, -1000, -1000, + 3986, -1000, 763, -1000, 771, -1000, 1760, -1000, 1740, 36893, + 2472, 3158, -1000, 6103, 1081, -1000, -1000, 4237, -1000, -1000, + -1000, -1000, -1000, -1000, 2707, 2706, -1000, -1000, -1000, -1000, + -1000, 2463, 3229, 57, 3818, 2701, -1000, -1000, 3228, 1729, + 1723, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 1709, 1671, 36224, -1000, -1000, 4237, 2455, 28865, 2055, + 1758, 52949, -1000, -1000, 1664, 1657, -1000, -1000, -1000, -1000, + -1000, -327, 3227, 13422, 13422, -1000, -1000, -1000, 3226, -1000, + -1000, 3891, -249, -255, 2699, 207, 278, -1000, 2698, -1000, + -117, 3655, -152, -1000, -1000, 1025, -230, 185, 170, 123, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 52949, 2696, -1000, -1000, 119, -1000, 2084, + -1000, -316, -1000, -316, 2445, 2693, -1000, 52949, -1000, 489, + -1000, -1000, 281, -1000, -1000, -1000, -1000, -1000, -1000, 2692, + 2690, -1000, 740, 3890, -1000, 58831, -1000, 2055, -1000, 740, + 1641, -1000, 2055, 2055, -1000, 599, -1000, 2111, -1000, 2424, + -1000, 3874, -1000, 594, -1000, 733, -1000, -1000, -1000, 1603, + -1000, -1000, -1000, 6103, 748, -1000, 944, 3212, -1000, -1000, + 2977, 13422, 3208, 2055, 2841, -104, 36224, 3558, 3557, 3393, + 3314, 1574, -1000, -1000, 28865, 52949, -1000, -1000, -1000, 35555, + -1000, 3207, 1557, 1547, 52949, 2644, -1000, -1000, 2689, -1000, + 1010, 247, 278, -1000, 3888, 223, 3887, 3885, 1478, 3652, + -1000, -1000, 2269, -1000, 196, 187, 178, -1000, -1000, -1000, + -1000, 2314, 2314, -1000, 2687, 2684, -1000, -1000, 2683, -316, + 643, -1000, 844, -1000, -1000, -1000, -1000, -1000, 352, -1000, + 3884, 851, -1000, 28865, -1000, -1000, 34886, 1736, 1736, -1000, + -1000, 2419, -1000, -1000, -1000, -1000, 2410, -1000, -1000, -1000, + 1541, -1000, 52949, 1134, 10056, -1000, 2514, -1000, 52949, -1000, + 3428, -1000, 327, 1533, 352, 879, 352, 879, 352, 879, + 352, 879, 383, -1000, -1000, -1000, -1000, 1530, 13422, -1000, + -1000, 1527, -1000, -1000, -1000, 2985, 2406, 248, 222, 3883, + -1000, 2644, 3882, 2644, 2644, -1000, 204, -142, 1025, -1000, + -1000, -1000, -1000, 2246, -1000, 2246, -1000, -1000, -316, -1000, + 2682, -1000, -1000, 385, -1000, 2055, 2055, 2677, 2667, 530, + -1000, -1000, 2055, 2055, 2055, 2055, 34217, 767, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 748, 58831, -1000, 10056, 1521, + -1000, 2633, -1000, 1016, -1000, -1000, 3322, 3301, 3953, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2863, + 2723, -1000, 52949, 3814, 28196, 217, -1000, -1000, -1000, 2662, + -1000, 2644, -1000, -1000, 2047, -150, -1000, -1000, -1000, -1000, + -287, -1000, 2401, 2399, -1000, -1000, 52949, 2373, 2347, 2329, + 2642, -1000, 52949, 746, -1000, 58831, 1516, -1000, 10056, -1000, + -1000, 3973, -1000, 3954, 1133, 1133, 352, 352, 352, 352, + 13422, -1000, -1000, -1000, 52949, -1000, 1506, -1000, -1000, -1000, + 1690, -1000, -1000, -1000, -1000, 2637, -153, -1000, -1000, 2632, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1498, 2526, -1000, + -1000, -1000, -1000, -1000, 2385, 861, -1000, 2646, 1442, -1000, + 2016, -1000, 33548, 52949, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 52949, 9384, -1000, 1475, -1000, -1000, 2633, + 52949, -1000, } var yyPgo = [...]int{ - 0, 191, 55, 266, 189, 4577, 89, 262, 302, 291, - 261, 258, 4576, 4575, 4574, 3614, 3608, 4573, 4569, 4568, - 4567, 4566, 4565, 4564, 4563, 4562, 4561, 4556, 4555, 4554, - 4553, 4552, 4549, 4548, 4546, 4544, 4543, 4542, 4541, 4540, - 4539, 4538, 4537, 4535, 4534, 4533, 4532, 4531, 4530, 4529, - 4528, 4526, 254, 4525, 4522, 4521, 4519, 4518, 4517, 4516, - 4515, 4514, 4513, 4512, 4511, 4510, 4508, 4506, 4505, 4501, - 4499, 4498, 4497, 4494, 4493, 4492, 4491, 4490, 4489, 4488, - 4487, 4486, 4478, 4477, 4476, 4475, 4474, 4473, 4472, 4471, - 4470, 265, 4469, 3602, 4468, 4467, 4466, 4465, 4462, 4461, - 4460, 4459, 4458, 4457, 4456, 4455, 333, 4454, 4452, 4451, - 4450, 4443, 4440, 4438, 4437, 4433, 4431, 4430, 4429, 4415, - 326, 4414, 4411, 4410, 4404, 260, 4403, 317, 4400, 187, - 144, 4399, 4397, 4396, 4394, 4388, 4387, 112, 129, 4386, - 4385, 4384, 4383, 4382, 4381, 4379, 4378, 4377, 4376, 4375, - 4374, 4372, 4371, 246, 156, 80, 4370, 53, 4369, 4366, - 231, 4365, 170, 4364, 166, 4361, 4360, 4359, 4357, 4356, - 4355, 4354, 4353, 4351, 4350, 4348, 4347, 4346, 4345, 4342, - 4341, 4339, 4337, 4336, 4335, 4334, 4333, 4332, 4331, 54, - 275, 4330, 4327, 4325, 4324, 193, 4322, 81, 4320, 4319, - 99, 26, 34, 4318, 50, 83, 272, 3279, 268, 4316, - 199, 4315, 4314, 252, 192, 4313, 4312, 276, 4306, 176, - 240, 174, 106, 137, 4305, 151, 4303, 270, 45, 52, - 248, 218, 165, 4297, 4296, 61, 147, 139, 4294, 227, - 107, 4290, 128, 4289, 4288, 125, 4287, 247, 186, 4282, - 119, 4281, 4280, 4278, 22, 4276, 4275, 216, 206, 4273, - 4271, 111, 4270, 4265, 64, 142, 4264, 82, 141, 183, - 135, 4262, 3198, 140, 91, 4261, 148, 117, 4260, 94, - 4257, 4252, 4249, 4247, 197, 4246, 4245, 157, 76, 4242, - 4240, 4239, 72, 4237, 84, 4233, 42, 4231, 66, 4229, - 4228, 4227, 4225, 4224, 4223, 4222, 4221, 4220, 4217, 4214, - 4213, 57, 4200, 4194, 4193, 4192, 7, 14, 17, 4190, - 29, 4188, 184, 4187, 4186, 181, 4185, 211, 4184, 4180, - 108, 97, 4179, 105, 179, 4177, 12, 38, 77, 4176, - 4172, 4171, 153, 4165, 4162, 4160, 278, 4159, 4158, 4157, - 175, 4156, 4154, 4152, 685, 4151, 4150, 4149, 4148, 4147, - 4146, 110, 4145, 1, 229, 43, 4144, 149, 152, 4143, - 40, 30, 4141, 51, 133, 219, 145, 114, 4140, 4139, - 4138, 298, 215, 109, 158, 0, 113, 230, 173, 4137, - 4136, 4134, 263, 4131, 241, 213, 244, 223, 273, 196, - 4129, 4128, 63, 4126, 177, 41, 59, 163, 85, 23, - 203, 4120, 2266, 8, 209, 4119, 220, 4117, 11, 16, - 228, 154, 4115, 4114, 33, 274, 4113, 4109, 4108, 143, - 4107, 4105, 205, 100, 4104, 4100, 4099, 4098, 4097, 39, - 4095, 194, 18, 4094, 115, 4093, 259, 102, 202, 162, - 198, 195, 171, 233, 242, 88, 87, 4092, 1960, 167, - 118, 15, 4091, 239, 4090, 210, 138, 4089, 95, 4088, - 251, 271, 222, 4086, 201, 9, 49, 35, 31, 48, - 10, 307, 70, 4085, 4084, 24, 58, 4083, 60, 4082, - 20, 4081, 4080, 46, 4079, 69, 5, 4078, 4076, 19, - 21, 4075, 37, 221, 185, 132, 101, 71, 4073, 4072, - 150, 159, 4071, 164, 169, 172, 4070, 86, 4069, 4068, - 4067, 4066, 813, 264, 4059, 4058, 4057, 4043, 4041, 4040, - 4039, 4038, 226, 4037, 122, 44, 4034, 4033, 4032, 4031, - 90, 155, 4029, 4028, 4027, 4026, 32, 160, 4025, 13, - 4024, 27, 25, 36, 4023, 116, 4022, 3, 200, 4021, - 4020, 4, 4019, 4018, 2, 4016, 4015, 131, 4014, 104, - 28, 182, 126, 4013, 4012, 103, 225, 168, 4011, 4010, - 121, 253, 4008, 214, 4007, 98, 245, 267, 4006, 224, - 4005, 4004, 4003, 4002, 4000, 1424, 3993, 3992, 249, 79, - 93, 3990, 235, 130, 3989, 3988, 96, 180, 123, 136, - 62, 92, 3987, 127, 217, 3986, 212, 3985, 269, 3984, - 3983, 120, 3982, 3981, 3980, 3979, 204, 3977, 3974, 207, - 238, 3973, 3972, 277, 3971, 3967, 3960, 3955, 3952, 3939, - 3938, 3936, 3932, 3931, 250, 256, 3930, + 0, 184, 51, 249, 190, 4593, 90, 271, 273, 265, + 270, 268, 4592, 4591, 4590, 3710, 3672, 4589, 4587, 4586, + 4584, 4583, 4582, 4581, 4580, 4579, 4578, 4576, 4575, 4574, + 4573, 4572, 4571, 4570, 4569, 4567, 4566, 4565, 4560, 4559, + 4558, 4557, 4556, 4553, 4551, 4550, 4549, 4548, 4547, 4546, + 4545, 4544, 267, 4543, 4541, 4537, 4534, 4533, 4532, 4531, + 4530, 4528, 4521, 4519, 4517, 4516, 4515, 4514, 4513, 4512, + 4510, 4509, 4507, 4506, 4505, 4504, 4501, 4500, 4496, 4495, + 4494, 4493, 4491, 4490, 4489, 4488, 4487, 4486, 4485, 4484, + 4483, 258, 4482, 3664, 4480, 4479, 4478, 4477, 4476, 4475, + 4474, 4473, 4472, 4471, 4470, 4467, 229, 4466, 4465, 4464, + 4463, 4462, 4461, 4460, 4458, 4455, 4454, 4452, 4451, 4450, + 316, 4449, 4448, 4447, 4446, 274, 4445, 306, 4444, 187, + 139, 4443, 4441, 4439, 4438, 4435, 4434, 108, 132, 4433, + 4432, 4431, 4428, 4426, 4425, 4424, 4423, 4422, 4420, 4419, + 4414, 4413, 4412, 247, 162, 72, 4411, 49, 4410, 4409, + 235, 4407, 157, 4405, 160, 4401, 4400, 4399, 4398, 4395, + 4394, 4393, 4392, 4391, 4376, 4375, 4374, 4373, 4370, 4368, + 4365, 4364, 4362, 4361, 4360, 4358, 4353, 4352, 4351, 54, + 266, 4350, 4349, 4348, 4347, 196, 4346, 85, 4345, 4344, + 87, 26, 36, 4342, 109, 91, 260, 2777, 257, 4341, + 205, 4340, 4339, 252, 192, 4338, 4336, 280, 4334, 174, + 239, 170, 107, 152, 4333, 151, 4332, 269, 45, 40, + 256, 210, 158, 4331, 4330, 57, 150, 138, 4329, 224, + 105, 4328, 125, 4327, 4322, 119, 4321, 250, 194, 4320, + 122, 4319, 4317, 4316, 22, 4311, 4310, 213, 206, 4308, + 4306, 113, 4303, 4300, 64, 148, 4298, 77, 136, 181, + 135, 4297, 3144, 137, 94, 4295, 133, 117, 4279, 143, + 4276, 4275, 4274, 4271, 198, 4270, 4269, 153, 76, 4268, + 4267, 4263, 69, 4262, 83, 4261, 82, 4260, 62, 4259, + 4256, 4251, 4249, 4247, 4245, 4243, 4242, 4241, 4240, 4239, + 4238, 56, 4236, 4235, 4234, 4233, 7, 14, 17, 4231, + 29, 4230, 182, 4228, 4227, 179, 4224, 209, 4220, 4219, + 103, 101, 4218, 102, 177, 4216, 9, 30, 80, 4215, + 4214, 4212, 79, 4211, 4210, 4208, 278, 4206, 4205, 4204, + 173, 4202, 4201, 4200, 685, 4196, 4194, 4193, 4191, 4190, + 4173, 165, 4172, 2, 226, 41, 4168, 144, 149, 4167, + 39, 32, 4166, 58, 128, 216, 147, 114, 4165, 4163, + 4162, 288, 212, 111, 70, 0, 112, 227, 163, 4161, + 4160, 4159, 264, 4158, 242, 214, 244, 248, 272, 189, + 4157, 4156, 71, 4155, 175, 33, 55, 145, 99, 23, + 202, 4154, 2232, 10, 199, 4153, 218, 4151, 8, 16, + 221, 156, 4150, 4148, 34, 275, 4146, 4145, 4144, 140, + 4143, 4142, 201, 81, 4134, 4133, 4131, 4129, 4127, 35, + 4124, 195, 19, 4123, 115, 4122, 255, 104, 230, 169, + 203, 193, 164, 231, 241, 92, 89, 4121, 2150, 172, + 116, 15, 4120, 233, 4119, 282, 131, 4116, 96, 4115, + 251, 276, 219, 4114, 197, 11, 50, 38, 31, 48, + 12, 312, 88, 4112, 4111, 24, 53, 4110, 60, 4108, + 21, 4107, 4106, 46, 4104, 61, 1, 4103, 4102, 20, + 18, 4100, 37, 223, 185, 142, 106, 63, 4099, 4098, + 167, 186, 4097, 171, 166, 168, 4096, 84, 4095, 4094, + 4093, 4092, 777, 263, 4090, 4089, 4088, 4087, 4086, 4084, + 4082, 4081, 225, 4080, 120, 43, 4078, 4077, 4075, 4073, + 86, 154, 4072, 4070, 4068, 4067, 42, 155, 4066, 13, + 4064, 27, 25, 44, 4063, 121, 4062, 3, 200, 4061, + 4060, 5, 4057, 4056, 4, 4055, 4053, 130, 4052, 110, + 28, 180, 124, 4051, 4050, 100, 222, 159, 4048, 4047, + 118, 253, 4046, 215, 4045, 98, 240, 261, 4043, 220, + 4042, 4040, 4039, 4038, 4037, 1355, 4036, 4035, 245, 66, + 93, 4034, 228, 127, 4033, 4032, 97, 176, 129, 141, + 59, 95, 4031, 126, 217, 4030, 211, 4027, 259, 4024, + 4023, 123, 4022, 4021, 4020, 4018, 207, 4017, 4016, 204, + 238, 4014, 4013, 277, 4011, 4010, 4009, 4008, 4006, 4004, + 4003, 4002, 4001, 4000, 246, 254, 3999, } -//line mysql_sql.y:13736 +//line mysql_sql.y:13821 type yySymType struct { union interface{} id int @@ -9589,10 +9625,10 @@ var yyR1 = [...]int{ 285, 285, 285, 284, 284, 284, 284, 284, 282, 282, 282, 282, 282, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, - 280, 280, 128, 129, 129, 281, 364, 364, 510, 510, - 513, 513, 511, 511, 512, 514, 514, 514, 515, 515, - 515, 516, 516, 516, 520, 520, 373, 373, 373, 381, - 381, 380, 380, 380, 380, 380, 380, 380, 380, 380, + 280, 280, 128, 129, 129, 281, 281, 281, 281, 281, + 281, 281, 281, 364, 364, 510, 510, 513, 513, 511, + 511, 512, 514, 514, 514, 515, 515, 515, 516, 516, + 516, 520, 520, 373, 373, 373, 381, 381, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, @@ -9630,13 +9666,14 @@ var yyR1 = [...]int{ 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, - 380, 380, 380, 379, 379, 379, 379, 379, 379, 379, - 379, 379, 379, 378, 378, 378, 378, 378, 378, 378, + 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, + 379, 379, 379, 379, 379, 379, 379, 379, 379, 379, + 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, - 378, 378, 378, 378, 378, + 378, 378, } var yyR2 = [...]int{ @@ -9835,9 +9872,10 @@ var yyR2 = [...]int{ 1, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 4, - 4, 1, 2, 3, 5, 1, 1, 3, 0, 1, - 0, 3, 0, 3, 3, 0, 3, 5, 0, 3, - 5, 0, 1, 1, 0, 1, 1, 2, 2, 0, + 4, 1, 2, 3, 5, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 0, 1, 0, 3, 0, + 3, 3, 0, 3, 5, 0, 3, 5, 0, 1, + 1, 0, 1, 1, 2, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -9882,7 +9920,7 @@ var yyR2 = [...]int{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, + 1, 1, } var yyChk = [...]int{ @@ -10005,328 +10043,330 @@ var yyChk = [...]int{ -385, 162, -279, -283, -280, -282, -281, -285, -284, 197, 198, 156, 201, 207, 203, 204, 205, 206, 208, 209, 210, 211, 212, 215, 216, 213, 32, 214, 265, 193, - 194, 195, 196, 217, 179, 199, 576, 225, 180, 226, - 181, 227, 182, 228, 183, 184, 229, 185, 188, 189, - 190, 191, 187, 161, -246, 92, 33, 86, 161, 92, - -237, 271, -217, -272, -264, 161, 693, -237, -633, -227, - -228, 11, -272, -361, -385, 462, 128, -106, 78, -106, - 461, 78, -106, 461, 243, -588, -589, -590, -592, 243, - 461, 460, 244, -125, 161, 287, 17, -392, -392, -385, - 84, -272, -446, 279, -471, -444, 37, 83, 162, 252, - 162, 83, 86, 404, 379, 443, 405, 524, 248, 417, - 251, 279, 418, 379, 443, 248, 251, 524, 279, 379, - 248, 251, 443, 279, 418, 379, 483, 484, 251, 28, - 409, 412, 413, 484, -543, 520, 162, 117, 114, 115, - 116, -412, 135, -427, 128, 129, 130, 131, 132, 133, - 134, 142, 141, 152, 145, 146, 147, 148, 149, 150, - 151, 143, 144, 159, 160, 138, 118, 136, 140, 137, - 120, 155, -207, -412, -420, 62, -410, -410, -410, -410, - -385, -503, -417, -412, 86, 86, 86, 86, 86, 161, - 105, 92, -412, 86, 86, 86, 86, 86, 86, 86, - 86, 86, 86, 86, 86, -536, 86, 86, -424, -425, - 86, 86, -405, -361, 86, 92, 92, 86, 86, 86, - 92, 86, 86, 86, -425, -425, 86, 86, 86, 86, + 194, 195, 196, 217, 218, 219, 220, 221, 222, 223, + 224, 179, 199, 576, 225, 180, 226, 181, 227, 182, + 228, 183, 184, 229, 185, 188, 189, 190, 191, 187, + 161, -246, 92, 33, 86, 161, 92, -237, 271, -217, + -272, -264, 161, 693, -237, -633, -227, -228, 11, -272, + -361, -385, 462, 128, -106, 78, -106, 461, 78, -106, + 461, 243, -588, -589, -590, -592, 243, 461, 460, 244, + -125, 161, 287, 17, -392, -392, -385, 84, -272, -446, + 279, -471, -444, 37, 83, 162, 252, 162, 83, 86, + 404, 379, 443, 405, 524, 248, 417, 251, 279, 418, + 379, 443, 248, 251, 524, 279, 379, 248, 251, 443, + 279, 418, 379, 483, 484, 251, 28, 409, 412, 413, + 484, -543, 520, 162, 117, 114, 115, 116, -412, 135, + -427, 128, 129, 130, 131, 132, 133, 134, 142, 141, + 152, 145, 146, 147, 148, 149, 150, 151, 143, 144, + 159, 160, 138, 118, 136, 140, 137, 120, 155, -207, + -412, -420, 62, -410, -410, -410, -410, -385, -503, -417, + -412, 86, 86, 86, 86, 86, 161, 105, 92, -412, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + 86, 86, -536, 86, 86, -424, -425, 86, 86, -405, + -361, 86, 92, 92, 86, 86, 86, 92, 86, 86, + 86, -425, -425, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, - 86, -228, 162, -227, 86, -227, -228, -208, -207, 33, - 34, 33, 34, 33, 34, 33, 34, -636, 665, 86, - 102, 688, 230, 17, -385, 674, -385, -618, 33, 569, - 569, 569, 569, 239, 16, 341, 55, 342, 513, 578, - 174, 175, 176, -385, 173, 252, -385, -432, 254, -432, - -432, -432, -256, -385, 275, 403, -190, 561, -432, -432, - -432, -432, -432, 250, -432, 24, 248, 248, 248, 248, - -432, 531, -597, 178, 162, -587, -236, 86, -618, 506, - 683, 684, 685, 83, -397, 136, 140, -397, -342, 18, - -342, 24, 24, 277, 277, 277, -397, 317, -644, -645, - 17, 138, -395, -645, -395, -395, -397, -646, 250, 494, - 44, 278, 277, -229, -230, 22, -229, 488, 484, -488, - 489, 490, -399, -645, -398, -397, -397, -398, -397, -397, - -397, 33, 248, 251, 524, 352, 669, -644, -644, 32, - 32, -522, 251, -191, 318, 57, 59, -272, -522, -385, - 254, -447, -522, 559, -374, -385, -522, -522, -522, -326, - -327, -272, -598, 253, 685, -630, -629, 511, -632, 513, - 167, -465, 167, -465, 89, -446, 279, 279, 162, 128, - 24, -466, 128, 139, -465, -465, -466, -466, -296, 42, - -384, 156, -385, 92, -296, 42, -627, -626, -272, -228, - -208, -207, 87, 87, 87, 569, -618, -522, -522, -522, - -522, -522, -522, -523, -522, -522, -522, -522, -522, -392, - -247, -385, -258, 254, -522, -522, -522, -522, -209, -210, - 147, -412, -385, -213, -3, -161, -160, 122, 123, 125, - 659, 398, 658, 662, 656, -465, 42, -516, 425, 424, - -510, -512, 86, -511, 86, -511, -511, -511, -511, -511, - 86, 86, -513, 86, -513, -513, -510, -514, 86, -514, - -515, 86, -515, -514, -385, -492, 578, -418, -420, -385, - 40, -532, 62, -204, 86, 32, 86, -237, -385, 194, - 172, 673, 36, -533, 62, -204, 86, 32, -228, -154, - 40, -230, 21, 161, 102, 92, -125, -106, 78, -125, - -106, -106, 87, 162, -591, 108, 109, -593, 212, 203, - -385, -123, 92, -557, -7, -11, -8, -9, -10, -52, - -91, -204, 567, 570, -560, -558, 86, 33, 452, 83, - 17, -472, 248, 524, 403, 275, 251, 379, -470, -453, - -450, -448, -384, -446, -449, -448, -475, -361, 484, -155, - 467, 466, 329, -412, -412, -412, -412, -412, 107, 118, - 370, 108, 109, -407, -428, 33, 325, 326, -408, -408, - -408, -408, -408, -408, -408, -408, -408, -408, -408, -408, - -410, -410, -416, -426, -503, 86, 138, 136, 140, 137, - 120, -410, -410, -408, -408, -298, -384, 156, 87, 162, - -412, -584, -583, 122, -412, -412, -412, -412, -439, -441, - -361, 86, -385, -580, -581, 539, 540, 541, 542, 543, - 544, 545, 546, 547, 548, 549, 394, 389, 395, 393, - 382, 401, 396, 397, 196, 556, 557, 550, 551, 552, - 553, 554, 555, -418, -418, -412, -580, -418, -354, 34, - 33, -420, -420, -420, 87, -412, -594, 368, 367, 369, - -232, -385, -418, 87, 87, 87, 102, -420, -420, -418, - -408, -418, -418, -418, -418, -581, -581, -582, 265, 193, - 195, 194, -354, -354, -354, -354, 147, -420, -420, -354, - -354, -354, -354, 147, -354, -354, -354, -354, -354, -354, - -354, -354, -354, -354, -354, 87, 87, 87, 87, 87, - -412, -412, -412, -412, -412, 147, -420, -229, -153, -541, - -540, -412, 42, -154, -230, -637, 666, 86, -361, -625, - 92, 92, 693, 172, 674, 17, 524, -385, 17, 248, - -385, 102, -385, 102, 248, 524, 248, 524, -272, -272, - -272, 514, 515, 171, 175, 174, -385, 173, -385, -385, - 118, -385, -385, -385, 36, -258, -247, 251, -432, -602, - -385, 93, -454, -451, -448, -385, -385, -444, -385, -374, - -272, -432, -432, -432, -432, -272, -598, -586, 36, -235, - -385, -140, 24, 279, -342, -410, -410, -412, 379, 524, - 248, -448, 279, -644, -397, -397, -375, -374, -399, -394, - -399, -399, -342, -395, -397, -397, -412, -399, -395, -342, - -385, 484, -342, -342, -488, -397, -396, -385, -396, -432, - -374, -375, -375, -272, -522, 128, 128, 60, -321, -328, - -322, -329, 271, 245, 387, 388, 242, 240, 11, 241, - -336, 318, -433, 532, -302, -303, 78, 43, -305, 269, - 429, 422, 281, 285, 96, 286, 462, 287, 250, 289, - 290, 291, 306, 308, 261, 292, 293, 294, 453, 295, - 166, 307, 296, 297, 298, 405, -297, 6, 355, 42, - 52, 53, 476, 475, 581, 578, 282, -385, 432, 570, - 32, 37, 242, 245, 241, -602, -600, 32, -385, 32, - -454, -448, -385, -385, 162, 252, -220, -222, -219, -215, - -216, -221, -345, -347, -218, 86, -272, -207, -385, -465, - 162, 512, 514, 515, -630, -466, -630, -466, 252, 33, - 452, -469, 452, 33, -444, -463, 508, 510, -459, 92, - 453, -449, -468, 83, 156, -540, -466, -466, -468, -468, - 155, 162, -628, 513, 514, 236, -229, 102, -385, -274, - -272, -602, -453, -444, -385, -522, -274, -274, -274, -387, - -387, 86, 161, 37, -385, -385, -385, -385, -341, 162, - -340, 17, -386, -385, 36, 92, 161, -162, -160, 124, - -412, -6, 658, -412, -6, -6, -412, -6, -412, -520, - 426, 102, 102, -364, 92, -364, 102, 102, 102, 584, - 87, 92, -457, 83, -534, -421, -578, 647, -239, 87, - -232, -576, -577, -232, -238, -385, -532, -264, 128, 128, - 128, 25, -534, -239, 87, -576, -229, 648, -231, 21, - -226, -225, -412, -385, 24, -125, -106, -589, 161, 162, - -235, -472, -452, -449, -474, 147, -385, -460, 162, 578, - 696, 90, 252, -615, -614, 444, 87, 162, -544, 253, - 531, 92, 693, 460, 230, 231, 107, 370, 108, 109, - -503, -420, -416, -410, -410, -408, -408, -414, 266, -414, - 117, -412, 694, -411, -583, 124, -412, 36, 162, 36, - 162, 84, 162, 87, -510, -412, 161, 87, 87, 17, - 17, 87, -412, 87, 87, 87, 87, 17, 17, -412, - 87, 161, 87, 87, 87, 87, 84, 87, 162, 87, - 87, 87, 87, 162, 162, 162, -420, -420, -412, -420, - 87, 87, 87, -412, -412, -412, -420, 87, -412, -412, - -412, -412, -412, -412, -412, -412, -412, -412, -235, -482, - 479, -482, -482, -482, -482, 87, 162, 87, 162, 87, - 87, 162, 162, 162, 162, 87, -231, 86, 102, 162, - 689, -368, -367, 92, -385, -385, 172, 674, -385, 92, - 674, -385, 92, -272, -374, -272, -374, 575, 40, 40, - 172, 176, 176, 175, -385, 92, 37, 24, 24, 316, - -135, 571, -257, 86, 86, -432, -272, -604, 430, -616, - 162, 42, -614, 524, -188, 329, -436, 84, -195, 336, - 17, 578, -272, -272, -272, -272, -286, 36, 17, -214, - -273, -385, 86, 87, 162, -142, 22, -385, -447, -385, - -385, -385, -445, 84, -385, -375, -342, -342, -399, -342, - -342, 162, 23, -397, -399, -399, -264, -395, -264, 161, - -264, -374, -509, 36, -272, -307, 54, 55, 56, -448, - -192, 57, 58, 162, 21, 271, -271, -382, -268, -270, - 256, -402, -269, 259, -572, 257, 255, 112, 260, 314, - 113, 250, -382, -382, 256, -306, 252, 36, -382, -324, - 250, 373, 314, 257, 21, 271, -323, 250, 113, -385, - 256, 260, 257, 255, -381, 128, -373, 155, 252, 44, - 405, -381, 582, 271, -381, -381, -381, -381, -381, -381, - -381, 288, 288, -381, -381, -381, -381, -381, -381, -381, - -381, -381, -381, -381, 167, -381, -381, -381, -381, -381, - -381, 86, 283, 284, 316, 571, 122, 584, 573, -447, - 252, 499, 499, -605, 430, 32, 385, 385, 386, -616, - 381, 43, 32, -196, 379, -327, -325, -396, 32, -348, - -349, -350, -351, -353, -352, 69, 73, 75, 79, 70, - 71, 72, 76, 81, 74, 32, 162, -383, -388, 36, - -385, 92, -383, -207, -222, -220, -383, 86, -466, -629, - -631, 516, 513, 519, -468, -468, 102, 252, 86, 128, - -468, -468, 42, -384, -626, 520, 514, -231, 162, 83, - -274, -248, -249, -250, -251, -279, -361, 198, 201, 203, - 204, 205, 206, 208, 209, 210, 211, 212, 215, 216, - 213, 214, 265, 193, 194, 195, 196, 217, 179, 199, - 576, 180, 181, 182, 183, 184, 185, 188, 189, 190, - 191, 187, -385, -258, -254, 676, -342, -210, -222, -385, - 92, -385, 147, 125, -6, 123, -166, -165, -164, 126, - 656, 662, 125, 125, 125, 87, 87, 87, 162, 87, - 87, 87, 162, 87, 162, 102, -547, 489, 41, 162, - 86, 87, 162, 62, 162, 128, 87, 162, -412, -385, - 92, -412, 194, 87, 62, -231, 92, -154, 626, 162, - -223, 38, 39, 161, 462, -385, -558, 87, -474, 162, - 252, 161, 161, -450, 408, -384, -452, 21, 578, -361, - 40, -368, 128, 693, -385, 87, -414, -414, 117, -410, - -407, 87, 125, -412, 123, -277, -279, 424, 425, -412, - -277, -278, -284, 156, 197, 265, 196, 195, 193, 424, - 425, -296, -441, 575, -223, 87, -385, -412, -412, 87, - -412, -412, 17, -385, -296, -408, -412, -412, -412, -228, - -228, 87, 87, -481, -482, -481, -481, 87, 87, 87, - 87, -481, 87, 87, 87, 87, 87, 87, 87, 87, - 87, 87, 87, 86, -482, -412, -482, -412, -482, -482, - -412, 102, 104, 102, 104, -540, -154, -638, 64, 664, - 63, 452, 107, 319, 162, 102, 92, 694, 162, 128, - 92, -385, -385, 17, 248, -385, 17, 17, 17, -272, - -272, -272, 176, 92, -617, 323, 379, 524, 248, 379, - 323, 524, 248, -493, 102, -136, 122, 92, 416, -259, - -260, -261, -262, -263, 138, 163, 164, -248, -272, 86, - -607, 491, 432, 442, -381, -404, -403, 381, 43, -527, - 453, 438, 439, -451, 279, -374, -613, 99, 128, 83, - 359, 363, 365, 364, 360, 361, 362, -430, -431, -429, - -433, -374, -600, 86, 86, -204, 36, 136, -195, 336, - 86, 86, 36, -504, 349, -279, -272, -214, -385, 17, - 162, -599, 161, -1, -385, 102, -385, -444, -397, -342, - -412, -412, -342, -397, -397, -399, -385, -264, -504, -279, - -236, -322, 245, 241, -478, 316, 317, -479, -494, 319, - -496, 86, -276, -361, -269, -571, -572, -432, -385, 113, - -571, 113, 86, -276, -361, -361, -325, -361, -385, -385, - -385, -385, -332, -331, -361, -334, 33, -335, -385, -385, - -385, -385, 113, -385, 113, -301, 42, 49, 50, 51, - -381, -381, 200, -304, 42, 452, 454, 455, -334, 102, - 102, 102, 102, 92, 92, 92, -381, -381, 102, 92, - -388, 92, -573, 175, 46, 47, 102, 102, 102, 102, - 42, 92, -309, 42, 299, 303, 300, 301, 302, 92, - 102, 42, 102, 42, 102, 42, -385, 86, -574, -575, - 92, -493, 92, 86, 102, 92, 242, -447, 92, 83, - -607, -381, 385, -465, 128, 128, -404, -609, 96, 433, - -609, -612, 329, -198, 524, 33, -240, 245, 241, -600, - -456, -455, -361, -219, -219, -219, -219, -219, -219, 69, - 80, 69, -233, 86, 69, 74, 69, 74, 69, -350, - 69, 80, -456, -221, -236, -388, 87, -623, -622, -621, - -619, 77, 253, 78, -418, -468, 513, 517, 518, -452, - -400, 92, -459, -154, -272, -272, -525, 309, 310, 87, - 162, -279, -344, 19, 161, 121, -6, -162, -164, -412, - -6, -412, 658, 398, 659, 92, 102, 102, -555, 473, - 468, 470, 113, -421, -542, -541, 62, -204, -232, -534, - -577, -540, -385, 694, 694, 694, 694, 92, 62, -204, - -534, -154, -547, 578, -225, -224, 45, -385, 102, 17, - -449, -444, 147, 147, -385, 409, -460, 92, 431, 92, - 248, 694, 92, -368, -407, -412, 87, -287, 184, 183, - -287, 36, 87, 87, -511, -511, -510, -513, -510, -287, - -287, 87, 86, -223, 87, 24, 87, 87, 87, -412, - 87, 87, 162, 162, 87, -530, 533, -531, 611, -481, + 86, 86, 86, 86, 86, 86, 86, 86, -228, 162, + -227, 86, -227, -228, -208, -207, 33, 34, 33, 34, + 33, 34, 33, 34, -636, 665, 86, 102, 688, 230, + 17, -385, 674, -385, -618, 33, 569, 569, 569, 569, + 239, 16, 341, 55, 342, 513, 578, 174, 175, 176, + -385, 173, 252, -385, -432, 254, -432, -432, -432, -256, + -385, 275, 403, -190, 561, -432, -432, -432, -432, -432, + 250, -432, 24, 248, 248, 248, 248, -432, 531, -597, + 178, 162, -587, -236, 86, -618, 506, 683, 684, 685, + 83, -397, 136, 140, -397, -342, 18, -342, 24, 24, + 277, 277, 277, -397, 317, -644, -645, 17, 138, -395, + -645, -395, -395, -397, -646, 250, 494, 44, 278, 277, + -229, -230, 22, -229, 488, 484, -488, 489, 490, -399, + -645, -398, -397, -397, -398, -397, -397, -397, 33, 248, + 251, 524, 352, 669, -644, -644, 32, 32, -522, 251, + -191, 318, 57, 59, -272, -522, -385, 254, -447, -522, + 559, -374, -385, -522, -522, -522, -326, -327, -272, -598, + 253, 685, -630, -629, 511, -632, 513, 167, -465, 167, + -465, 89, -446, 279, 279, 162, 128, 24, -466, 128, + 139, -465, -465, -466, -466, -296, 42, -384, 156, -385, + 92, -296, 42, -627, -626, -272, -228, -208, -207, 87, + 87, 87, 569, -618, -522, -522, -522, -522, -522, -522, + -523, -522, -522, -522, -522, -522, -392, -247, -385, -258, + 254, -522, -522, -522, -522, -209, -210, 147, -412, -385, + -213, -3, -161, -160, 122, 123, 125, 659, 398, 658, + 662, 656, -465, 42, -516, 425, 424, -510, -512, 86, + -511, 86, -511, -511, -511, -511, -511, 86, 86, -513, + 86, -513, -513, -510, -514, 86, -514, -515, 86, -515, + -514, -385, -492, 578, -418, -420, -385, 40, -532, 62, + -204, 86, 32, 86, -237, -385, 194, 172, 673, 36, + -533, 62, -204, 86, 32, -228, -154, 40, -230, 21, + 161, 102, 92, -125, -106, 78, -125, -106, -106, 87, + 162, -591, 108, 109, -593, 212, 203, -385, -123, 92, + -557, -7, -11, -8, -9, -10, -52, -91, -204, 567, + 570, -560, -558, 86, 33, 452, 83, 17, -472, 248, + 524, 403, 275, 251, 379, -470, -453, -450, -448, -384, + -446, -449, -448, -475, -361, 484, -155, 467, 466, 329, + -412, -412, -412, -412, -412, 107, 118, 370, 108, 109, + -407, -428, 33, 325, 326, -408, -408, -408, -408, -408, + -408, -408, -408, -408, -408, -408, -408, -410, -410, -416, + -426, -503, 86, 138, 136, 140, 137, 120, -410, -410, + -408, -408, -298, -384, 156, 87, 162, -412, -584, -583, + 122, -412, -412, -412, -412, -439, -441, -361, 86, -385, + -580, -581, 539, 540, 541, 542, 543, 544, 545, 546, + 547, 548, 549, 394, 389, 395, 393, 382, 401, 396, + 397, 196, 556, 557, 550, 551, 552, 553, 554, 555, + -418, -418, -412, -580, -418, -354, 34, 33, -420, -420, + -420, 87, -412, -594, 368, 367, 369, -232, -385, -418, + 87, 87, 87, 102, -420, -420, -418, -408, -418, -418, + -418, -418, -581, -581, -582, 265, 193, 195, 194, -354, + -354, -354, -354, 147, -420, -420, -354, -354, -354, -354, + 147, -354, -354, -354, -354, -354, -354, -354, -354, -354, + -354, -354, 87, 87, 87, 87, 87, -412, -412, -412, + -412, -412, 147, -420, -229, -153, -541, -540, -412, 42, + -154, -230, -637, 666, 86, -361, -625, 92, 92, 693, + 172, 674, 17, 524, -385, 17, 248, -385, 102, -385, + 102, 248, 524, 248, 524, -272, -272, -272, 514, 515, + 171, 175, 174, -385, 173, -385, -385, 118, -385, -385, + -385, 36, -258, -247, 251, -432, -602, -385, 93, -454, + -451, -448, -385, -385, -444, -385, -374, -272, -432, -432, + -432, -432, -272, -598, -586, 36, -235, -385, -140, 24, + 279, -342, -410, -410, -412, 379, 524, 248, -448, 279, + -644, -397, -397, -375, -374, -399, -394, -399, -399, -342, + -395, -397, -397, -412, -399, -395, -342, -385, 484, -342, + -342, -488, -397, -396, -385, -396, -432, -374, -375, -375, + -272, -522, 128, 128, 60, -321, -328, -322, -329, 271, + 245, 387, 388, 242, 240, 11, 241, -336, 318, -433, + 532, -302, -303, 78, 43, -305, 269, 429, 422, 281, + 285, 96, 286, 462, 287, 250, 289, 290, 291, 306, + 308, 261, 292, 293, 294, 453, 295, 166, 307, 296, + 297, 298, 405, -297, 6, 355, 42, 52, 53, 476, + 475, 581, 578, 282, -385, 432, 570, 32, 37, 242, + 245, 241, -602, -600, 32, -385, 32, -454, -448, -385, + -385, 162, 252, -220, -222, -219, -215, -216, -221, -345, + -347, -218, 86, -272, -207, -385, -465, 162, 512, 514, + 515, -630, -466, -630, -466, 252, 33, 452, -469, 452, + 33, -444, -463, 508, 510, -459, 92, 453, -449, -468, + 83, 156, -540, -466, -466, -468, -468, 155, 162, -628, + 513, 514, 236, -229, 102, -385, -274, -272, -602, -453, + -444, -385, -522, -274, -274, -274, -387, -387, 86, 161, + 37, -385, -385, -385, -385, -341, 162, -340, 17, -386, + -385, 36, 92, 161, -162, -160, 124, -412, -6, 658, + -412, -6, -6, -412, -6, -412, -520, 426, 102, 102, + -364, 92, -364, 102, 102, 102, 584, 87, 92, -457, + 83, -534, -421, -578, 647, -239, 87, -232, -576, -577, + -232, -238, -385, -532, -264, 128, 128, 128, 25, -534, + -239, 87, -576, -229, 648, -231, 21, -226, -225, -412, + -385, 24, -125, -106, -589, 161, 162, -235, -472, -452, + -449, -474, 147, -385, -460, 162, 578, 696, 90, 252, + -615, -614, 444, 87, 162, -544, 253, 531, 92, 693, + 460, 230, 231, 107, 370, 108, 109, -503, -420, -416, + -410, -410, -408, -408, -414, 266, -414, 117, -412, 694, + -411, -583, 124, -412, 36, 162, 36, 162, 84, 162, + 87, -510, -412, 161, 87, 87, 17, 17, 87, -412, + 87, 87, 87, 87, 17, 17, -412, 87, 161, 87, + 87, 87, 87, 84, 87, 162, 87, 87, 87, 87, + 162, 162, 162, -420, -420, -412, -420, 87, 87, 87, + -412, -412, -412, -420, 87, -412, -412, -412, -412, -412, + -412, -412, -412, -412, -412, -235, -482, 479, -482, -482, + -482, -482, 87, 162, 87, 162, 87, 87, 162, 162, + 162, 162, 87, -231, 86, 102, 162, 689, -368, -367, + 92, -385, -385, 172, 674, -385, 92, 674, -385, 92, + -272, -374, -272, -374, 575, 40, 40, 172, 176, 176, + 175, -385, 92, 37, 24, 24, 316, -135, 571, -257, + 86, 86, -432, -272, -604, 430, -616, 162, 42, -614, + 524, -188, 329, -436, 84, -195, 336, 17, 578, -272, + -272, -272, -272, -286, 36, 17, -214, -273, -385, 86, + 87, 162, -142, 22, -385, -447, -385, -385, -385, -445, + 84, -385, -375, -342, -342, -399, -342, -342, 162, 23, + -397, -399, -399, -264, -395, -264, 161, -264, -374, -509, + 36, -272, -307, 54, 55, 56, -448, -192, 57, 58, + 162, 21, 271, -271, -382, -268, -270, 256, -402, -269, + 259, -572, 257, 255, 112, 260, 314, 113, 250, -382, + -382, 256, -306, 252, 36, -382, -324, 250, 373, 314, + 257, 21, 271, -323, 250, 113, -385, 256, 260, 257, + 255, -381, 128, -373, 155, 252, 44, 405, -381, 582, + 271, -381, -381, -381, -381, -381, -381, -381, 288, 288, + -381, -381, -381, -381, -381, -381, -381, -381, -381, -381, + -381, 167, -381, -381, -381, -381, -381, -381, 86, 283, + 284, 316, 571, 122, 584, 573, -447, 252, 499, 499, + -605, 430, 32, 385, 385, 386, -616, 381, 43, 32, + -196, 379, -327, -325, -396, 32, -348, -349, -350, -351, + -353, -352, 69, 73, 75, 79, 70, 71, 72, 76, + 81, 74, 32, 162, -383, -388, 36, -385, 92, -383, + -207, -222, -220, -383, 86, -466, -629, -631, 516, 513, + 519, -468, -468, 102, 252, 86, 128, -468, -468, 42, + -384, -626, 520, 514, -231, 162, 83, -274, -248, -249, + -250, -251, -279, -361, 198, 201, 203, 204, 205, 206, + 208, 209, 210, 211, 212, 215, 216, 213, 214, 265, + 193, 194, 195, 196, 217, 218, 219, 220, 221, 222, + 223, 224, 179, 199, 576, 180, 181, 182, 183, 184, + 185, 188, 189, 190, 191, 187, -385, -258, -254, 676, + -342, -210, -222, -385, 92, -385, 147, 125, -6, 123, + -166, -165, -164, 126, 656, 662, 125, 125, 125, 87, + 87, 87, 162, 87, 87, 87, 162, 87, 162, 102, + -547, 489, 41, 162, 86, 87, 162, 62, 162, 128, + 87, 162, -412, -385, 92, -412, 194, 87, 62, -231, + 92, -154, 626, 162, -223, 38, 39, 161, 462, -385, + -558, 87, -474, 162, 252, 161, 161, -450, 408, -384, + -452, 21, 578, -361, 40, -368, 128, 693, -385, 87, + -414, -414, 117, -410, -407, 87, 125, -412, 123, -277, + -279, 424, 425, -412, -277, -278, -284, 156, 197, 265, + 196, 195, 193, 424, 425, -296, -441, 575, -223, 87, + -385, -412, -412, 87, -412, -412, 17, -385, -296, -408, + -412, -412, -412, -228, -228, 87, 87, -481, -482, -481, + -481, 87, 87, 87, 87, -481, 87, 87, 87, 87, + 87, 87, 87, 87, 87, 87, 87, 86, -482, -412, + -482, -412, -482, -482, -412, 102, 104, 102, 104, -540, + -154, -638, 64, 664, 63, 452, 107, 319, 162, 102, + 92, 694, 162, 128, 92, -385, -385, 17, 248, -385, + 17, 17, 17, -272, -272, -272, 176, 92, -617, 323, + 379, 524, 248, 379, 323, 524, 248, -493, 102, -136, + 122, 92, 416, -259, -260, -261, -262, -263, 138, 163, + 164, -248, -272, 86, -607, 491, 432, 442, -381, -404, + -403, 381, 43, -527, 453, 438, 439, -451, 279, -374, + -613, 99, 128, 83, 359, 363, 365, 364, 360, 361, + 362, -430, -431, -429, -433, -374, -600, 86, 86, -204, + 36, 136, -195, 336, 86, 86, 36, -504, 349, -279, + -272, -214, -385, 17, 162, -599, 161, -1, -385, 102, + -385, -444, -397, -342, -412, -412, -342, -397, -397, -399, + -385, -264, -504, -279, -236, -322, 245, 241, -478, 316, + 317, -479, -494, 319, -496, 86, -276, -361, -269, -571, + -572, -432, -385, 113, -571, 113, 86, -276, -361, -361, + -325, -361, -385, -385, -385, -385, -332, -331, -361, -334, + 33, -335, -385, -385, -385, -385, 113, -385, 113, -301, + 42, 49, 50, 51, -381, -381, 200, -304, 42, 452, + 454, 455, -334, 102, 102, 102, 102, 92, 92, 92, + -381, -381, 102, 92, -388, 92, -573, 175, 46, 47, + 102, 102, 102, 102, 42, 92, -309, 42, 299, 303, + 300, 301, 302, 92, 102, 42, 102, 42, 102, 42, + -385, 86, -574, -575, 92, -493, 92, 86, 102, 92, + 242, -447, 92, 83, -607, -381, 385, -465, 128, 128, + -404, -609, 96, 433, -609, -612, 329, -198, 524, 33, + -240, 245, 241, -600, -456, -455, -361, -219, -219, -219, + -219, -219, -219, 69, 80, 69, -233, 86, 69, 74, + 69, 74, 69, -350, 69, 80, -456, -221, -236, -388, + 87, -623, -622, -621, -619, 77, 253, 78, -418, -468, + 513, 517, 518, -452, -400, 92, -459, -154, -272, -272, + -525, 309, 310, 87, 162, -279, -344, 19, 161, 121, + -6, -162, -164, -412, -6, -412, 658, 398, 659, 92, + 102, 102, -555, 473, 468, 470, 113, -421, -542, -541, + 62, -204, -232, -534, -577, -540, -385, 694, 694, 694, + 694, 92, 62, -204, -534, -154, -547, 578, -225, -224, + 45, -385, 102, 17, -449, -444, 147, 147, -385, 409, + -460, 92, 431, 92, 248, 694, 92, -368, -407, -412, + 87, -287, 184, 183, -287, 36, 87, 87, -511, -511, + -510, -513, -510, -287, -287, 87, 86, -223, 87, 24, + 87, 87, 87, -412, 87, 87, 162, 162, 87, -530, + 533, -531, 611, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, -481, - -481, -481, -481, -481, -481, -481, -423, -422, 271, 87, - 162, 87, 162, 87, 474, 671, 671, 474, 671, 671, - 87, 162, -580, 162, -376, 324, -376, -367, 92, 252, - 92, 172, -385, 92, 674, -272, -374, -241, 490, -201, - 122, -202, 120, 44, 92, -385, -385, -385, 316, -385, - 316, -385, -385, 92, -141, 584, 86, -138, 572, 92, - 87, 162, -361, 87, -236, -265, -266, -267, -276, -268, - -270, -608, 96, -603, 92, -385, 93, -609, 158, 383, - 42, 434, 435, 450, 378, 102, 102, 440, -601, -385, - -197, 248, 379, -611, 53, 128, 92, -272, -429, -373, - 155, 290, -264, 352, -339, -338, -385, 92, -265, -204, - -272, -272, -265, -265, -204, -505, 351, 21, 102, 146, - -237, 84, 161, -222, -273, -385, 147, 87, -342, -264, - -342, -342, -397, -505, 36, -490, 320, 86, -488, 86, - -488, 113, 360, -497, -495, 271, -330, 46, 48, -279, - -569, -385, -567, -569, -385, -567, -567, -432, -412, -330, - -276, 252, 32, 241, -333, 357, 358, 363, 365, -461, - 315, 118, -461, 162, -223, 162, -385, -296, -296, 32, - 92, 92, -274, 87, 162, 128, 92, -138, -137, -412, - -204, -207, 252, 83, 248, -608, -603, 128, -466, 92, - 92, -609, 92, 92, -613, 128, -275, 248, -374, 162, - -240, -240, -342, 162, 128, -243, -242, 83, 84, -244, - 83, -242, -242, 69, -234, 92, 69, 69, -342, -621, - -620, 24, -572, -572, -572, 87, 87, -245, 24, -250, - 42, -343, 20, 21, 147, 125, 123, 125, 125, -385, - 87, 87, -517, 649, -551, -553, 468, 21, 21, 15, - 253, 87, -534, 694, -534, -245, -555, 409, 46, 47, - -444, -460, 453, -272, 162, 694, -277, -315, 92, -412, - 87, -412, -412, 87, 92, 87, 92, -228, 21, -482, - -412, -482, -412, -482, 87, 162, 87, 87, 87, 162, - 87, 87, -412, 87, -580, -377, 194, 92, -377, 379, - -386, -385, 17, -385, -200, 252, -264, -203, 347, 86, - 343, -201, 172, 86, 92, -385, -493, 316, -493, 316, - 248, -385, -254, -139, 573, 102, -137, 92, -437, 577, - -261, -279, 246, 36, 87, 162, 92, -606, 444, 102, - 42, 102, 158, 436, -528, -189, 96, -274, 33, -240, - -610, 96, 128, 693, 86, -381, -381, -381, -200, -385, - 87, 162, -381, -381, 87, -200, 87, 87, -294, 578, - -506, 270, 102, 146, 102, 146, 102, -383, -222, -385, - -342, -599, 161, -342, -506, -204, -480, 321, 102, -408, - 86, -408, 86, -489, 318, 86, 87, 162, -385, -361, - -291, -290, -288, 107, 118, 42, 422, -289, 96, 155, - 304, 307, 306, 282, 305, -320, -401, 83, 428, 357, - 358, -433, 649, 563, 255, 112, 113, 410, -402, 86, - 86, 84, 324, 86, 86, -569, 87, -330, -361, 42, - -333, 42, 371, 315, -331, -385, 155, -296, 87, -575, - 92, 87, -447, 248, -385, -606, 92, -468, -611, 92, - -189, -274, -600, -228, -455, -540, -412, 86, -412, 87, - 86, 69, 11, 19, 15, -405, -412, -420, 678, 680, - 681, 254, -6, 659, 398, -311, 650, 92, 21, 92, - -549, 92, -456, -517, -420, -157, -308, -373, 287, 87, - -314, 138, 578, 87, 87, 87, -481, -481, -484, -483, - -487, 474, 316, 482, -420, 87, 87, 92, 92, 87, - 87, 92, -385, 172, 92, 379, -200, 36, 416, 22, - 590, 348, -235, 344, 345, 346, -385, 92, -420, -205, - -207, 693, 92, -493, 92, -493, -385, 316, 36, 92, - 87, 92, 92, -252, -279, -204, -294, -267, 21, 578, - 382, 42, 102, 42, 437, 92, -197, 128, 108, 109, - -369, -370, 92, -439, -296, -298, 92, -338, -405, -405, - -292, -204, 36, -293, -336, -433, -156, -155, -292, 86, - -507, 166, 102, 146, 102, 102, -342, -342, -507, -496, - 21, 87, -475, 87, -475, 86, 128, -408, -495, -498, - 62, -288, 107, -408, 92, -298, -299, 42, 303, 299, - 128, 128, -300, 42, 283, 284, -310, 86, 314, 15, - 200, 86, 113, 113, -272, -439, -439, -570, 359, 360, - 361, 366, 363, 364, 362, 365, -570, -439, -439, 86, - -462, -461, -408, -381, -381, 155, -385, 161, -610, -229, - -235, -568, -385, 255, 21, 21, -526, 578, 679, 86, - 86, -385, -385, -365, 651, 102, 92, 470, -311, -518, - 652, -545, -488, -296, 128, 87, 76, 576, 579, 87, - -486, 120, 436, 440, -406, -409, 102, 104, 192, -482, - -482, 87, 87, -385, -385, -272, 92, 102, 87, 117, - 117, 87, 87, -372, -371, 92, -254, 92, -254, 92, - 316, -493, -2, 577, -193, 578, 92, 93, 431, 92, - 93, 382, -189, 92, 694, 162, 128, 87, -476, 271, - -204, 162, -336, -373, -157, -476, -295, -337, -385, 92, - -524, 175, 350, 578, 102, 146, 102, -228, -508, 175, - 350, -479, 87, 87, 87, -475, 102, 87, -502, -499, - 86, -336, 273, 138, 92, 92, 102, 86, -535, 32, - 92, -440, 86, 87, 87, 87, 87, -439, 102, -296, - -381, 161, -385, 87, 87, 162, 681, 86, -420, -420, - 86, 21, -365, -519, 653, 92, -554, 473, -548, -546, - 468, 469, 470, 471, 92, 577, 66, 580, -485, -486, - 440, -406, -409, 647, 480, 480, 480, -385, 92, 694, - 162, 128, -254, -254, -493, 92, -255, -385, -194, 61, - 520, 453, -370, 92, -442, -477, 323, 21, -336, -381, - -477, 87, 162, -381, -381, 350, 102, 146, 102, -229, - 350, -491, 322, 87, -502, -336, -501, -500, 321, 274, - 86, 87, -412, -424, -381, 87, -313, -312, 574, -439, - -442, 84, -442, 84, -442, 84, -442, 84, 87, -296, - -385, -385, 255, -152, 86, 87, 87, -366, -385, -549, - 92, -556, 253, -552, -553, 472, -546, 21, 470, 21, - 21, -158, 162, 66, 117, 481, 481, 481, -201, -202, - -201, -202, -371, 92, 92, -254, -253, 36, 475, 314, - -443, 261, 371, 372, 96, 578, 357, 358, 376, 375, - 374, 377, 21, -478, -296, -337, -405, -405, 102, 102, - 87, 162, -385, 270, 86, -419, -413, -412, 270, 87, - -385, -319, -317, -318, 83, 487, 312, 313, 87, -570, - -570, -570, -570, -320, 87, 162, -418, 87, 162, -563, - 86, 102, -551, -550, -552, 21, -549, 21, -549, -549, - 477, 578, -485, -201, -201, -254, 92, 409, -381, -381, - 92, 92, 356, -381, -381, -381, -381, -361, 86, -490, - -500, -499, -419, 87, 162, -461, -318, 83, -317, 83, - 16, 15, -442, -442, -442, -442, 86, 87, -385, -566, - 32, 87, -562, -561, -362, -557, -385, 473, 474, 92, - -549, 128, 579, -641, -640, 670, 102, 102, -385, 102, - 102, 102, 92, -475, -480, 87, -413, -316, 309, 310, - 32, 175, -316, -418, -565, -564, -363, 87, 162, 161, - 92, 580, 92, 87, -496, 107, 42, 311, 87, 162, - 128, -561, -385, -564, 42, -412, 161, -385, + -423, -422, 271, 87, 162, 87, 162, 87, 474, 671, + 671, 474, 671, 671, 87, 162, -580, 162, -376, 324, + -376, -367, 92, 252, 92, 172, -385, 92, 674, -272, + -374, -241, 490, -201, 122, -202, 120, 44, 92, -385, + -385, -385, 316, -385, 316, -385, -385, 92, -141, 584, + 86, -138, 572, 92, 87, 162, -361, 87, -236, -265, + -266, -267, -276, -268, -270, -608, 96, -603, 92, -385, + 93, -609, 158, 383, 42, 434, 435, 450, 378, 102, + 102, 440, -601, -385, -197, 248, 379, -611, 53, 128, + 92, -272, -429, -373, 155, 290, -264, 352, -339, -338, + -385, 92, -265, -204, -272, -272, -265, -265, -204, -505, + 351, 21, 102, 146, -237, 84, 161, -222, -273, -385, + 147, 87, -342, -264, -342, -342, -397, -505, 36, -490, + 320, 86, -488, 86, -488, 113, 360, -497, -495, 271, + -330, 46, 48, -279, -569, -385, -567, -569, -385, -567, + -567, -432, -412, -330, -276, 252, 32, 241, -333, 357, + 358, 363, 365, -461, 315, 118, -461, 162, -223, 162, + -385, -296, -296, 32, 92, 92, -274, 87, 162, 128, + 92, -138, -137, -412, -204, -207, 252, 83, 248, -608, + -603, 128, -466, 92, 92, -609, 92, 92, -613, 128, + -275, 248, -374, 162, -240, -240, -342, 162, 128, -243, + -242, 83, 84, -244, 83, -242, -242, 69, -234, 92, + 69, 69, -342, -621, -620, 24, -572, -572, -572, 87, + 87, -245, 24, -250, 42, -343, 20, 21, 147, 125, + 123, 125, 125, -385, 87, 87, -517, 649, -551, -553, + 468, 21, 21, 15, 253, 87, -534, 694, -534, -245, + -555, 409, 46, 47, -444, -460, 453, -272, 162, 694, + -277, -315, 92, -412, 87, -412, -412, 87, 92, 87, + 92, -228, 21, -482, -412, -482, -412, -482, 87, 162, + 87, 87, 87, 162, 87, 87, -412, 87, -580, -377, + 194, 92, -377, 379, -386, -385, 17, -385, -200, 252, + -264, -203, 347, 86, 343, -201, 172, 86, 92, -385, + -493, 316, -493, 316, 248, -385, -254, -139, 573, 102, + -137, 92, -437, 577, -261, -279, 246, 36, 87, 162, + 92, -606, 444, 102, 42, 102, 158, 436, -528, -189, + 96, -274, 33, -240, -610, 96, 128, 693, 86, -381, + -381, -381, -200, -385, 87, 162, -381, -381, 87, -200, + 87, 87, -294, 578, -506, 270, 102, 146, 102, 146, + 102, -383, -222, -385, -342, -599, 161, -342, -506, -204, + -480, 321, 102, -408, 86, -408, 86, -489, 318, 86, + 87, 162, -385, -361, -291, -290, -288, 107, 118, 42, + 422, -289, 96, 155, 304, 307, 306, 282, 305, -320, + -401, 83, 428, 357, 358, -433, 649, 563, 255, 112, + 113, 410, -402, 86, 86, 84, 324, 86, 86, -569, + 87, -330, -361, 42, -333, 42, 371, 315, -331, -385, + 155, -296, 87, -575, 92, 87, -447, 248, -385, -606, + 92, -468, -611, 92, -189, -274, -600, -228, -455, -540, + -412, 86, -412, 87, 86, 69, 11, 19, 15, -405, + -412, -420, 678, 680, 681, 254, -6, 659, 398, -311, + 650, 92, 21, 92, -549, 92, -456, -517, -420, -157, + -308, -373, 287, 87, -314, 138, 578, 87, 87, 87, + -481, -481, -484, -483, -487, 474, 316, 482, -420, 87, + 87, 92, 92, 87, 87, 92, -385, 172, 92, 379, + -200, 36, 416, 22, 590, 348, -235, 344, 345, 346, + -385, 92, -420, -205, -207, 693, 92, -493, 92, -493, + -385, 316, 36, 92, 87, 92, 92, -252, -279, -204, + -294, -267, 21, 578, 382, 42, 102, 42, 437, 92, + -197, 128, 108, 109, -369, -370, 92, -439, -296, -298, + 92, -338, -405, -405, -292, -204, 36, -293, -336, -433, + -156, -155, -292, 86, -507, 166, 102, 146, 102, 102, + -342, -342, -507, -496, 21, 87, -475, 87, -475, 86, + 128, -408, -495, -498, 62, -288, 107, -408, 92, -298, + -299, 42, 303, 299, 128, 128, -300, 42, 283, 284, + -310, 86, 314, 15, 200, 86, 113, 113, -272, -439, + -439, -570, 359, 360, 361, 366, 363, 364, 362, 365, + -570, -439, -439, 86, -462, -461, -408, -381, -381, 155, + -385, 161, -610, -229, -235, -568, -385, 255, 21, 21, + -526, 578, 679, 86, 86, -385, -385, -365, 651, 102, + 92, 470, -311, -518, 652, -545, -488, -296, 128, 87, + 76, 576, 579, 87, -486, 120, 436, 440, -406, -409, + 102, 104, 192, -482, -482, 87, 87, -385, -385, -272, + 92, 102, 87, 117, 117, 87, 87, -372, -371, 92, + -254, 92, -254, 92, 316, -493, -2, 577, -193, 578, + 92, 93, 431, 92, 93, 382, -189, 92, 694, 162, + 128, 87, -476, 271, -204, 162, -336, -373, -157, -476, + -295, -337, -385, 92, -524, 175, 350, 578, 102, 146, + 102, -228, -508, 175, 350, -479, 87, 87, 87, -475, + 102, 87, -502, -499, 86, -336, 273, 138, 92, 92, + 102, 86, -535, 32, 92, -440, 86, 87, 87, 87, + 87, -439, 102, -296, -381, 161, -385, 87, 87, 162, + 681, 86, -420, -420, 86, 21, -365, -519, 653, 92, + -554, 473, -548, -546, 468, 469, 470, 471, 92, 577, + 66, 580, -485, -486, 440, -406, -409, 647, 480, 480, + 480, -385, 92, 694, 162, 128, -254, -254, -493, 92, + -255, -385, -194, 61, 520, 453, -370, 92, -442, -477, + 323, 21, -336, -381, -477, 87, 162, -381, -381, 350, + 102, 146, 102, -229, 350, -491, 322, 87, -502, -336, + -501, -500, 321, 274, 86, 87, -412, -424, -381, 87, + -313, -312, 574, -439, -442, 84, -442, 84, -442, 84, + -442, 84, 87, -296, -385, -385, 255, -152, 86, 87, + 87, -366, -385, -549, 92, -556, 253, -552, -553, 472, + -546, 21, 470, 21, 21, -158, 162, 66, 117, 481, + 481, 481, -201, -202, -201, -202, -371, 92, 92, -254, + -253, 36, 475, 314, -443, 261, 371, 372, 96, 578, + 357, 358, 376, 375, 374, 377, 21, -478, -296, -337, + -405, -405, 102, 102, 87, 162, -385, 270, 86, -419, + -413, -412, 270, 87, -385, -319, -317, -318, 83, 487, + 312, 313, 87, -570, -570, -570, -570, -320, 87, 162, + -418, 87, 162, -563, 86, 102, -551, -550, -552, 21, + -549, 21, -549, -549, 477, 578, -485, -201, -201, -254, + 92, 409, -381, -381, 92, 92, 356, -381, -381, -381, + -381, -361, 86, -490, -500, -499, -419, 87, 162, -461, + -318, 83, -317, 83, 16, 15, -442, -442, -442, -442, + 86, 87, -385, -566, 32, 87, -562, -561, -362, -557, + -385, 473, 474, 92, -549, 128, 579, -641, -640, 670, + 102, 102, -385, 102, 102, 102, 92, -475, -480, 87, + -413, -316, 309, 310, 32, 175, -316, -418, -565, -564, + -363, 87, 162, 161, 92, 580, 92, 87, -496, 107, + 42, 311, 87, 162, 128, -561, -385, -564, 42, -412, + 161, -385, } var yyDef = [...]int{ @@ -10354,72 +10394,72 @@ var yyDef = [...]int{ 839, 0, 0, 0, 884, 902, 23, 0, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, 0, 19, 0, 19, 0, 0, 0, 1494, 1495, 1496, - 1497, 2329, 2299, -2, 2057, 2031, 2223, 2224, 2117, 2132, - 2024, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, - 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, - 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, - 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, - 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, - 2422, 2423, 2424, 1981, 1982, 1983, 1984, 1985, 1986, 1987, - 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, - 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, - 2018, 2019, 2020, 2021, 2022, 2023, 2025, 2026, 2027, 2028, - 2029, 2030, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, - 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, - 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2058, 2059, 2060, - 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, - 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, - 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, - 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, - 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, - 2111, 2112, 2113, 2114, 2115, 2116, 2118, 2119, 2120, 2121, - 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, - 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, - 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, - 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, - 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, - 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, - 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, - 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, - 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, - 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2225, - 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, - 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, - 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, - -2, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, - 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, - 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, - 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, - 2296, 2297, 2298, 2300, 2301, 2302, 2303, 2304, 2305, 2306, - 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, -2, -2, - -2, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, - 2327, 2328, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, - 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, - 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, - 2358, 2359, 2360, 2361, 2362, 0, 315, 313, 1996, 2024, - 2031, 2057, 2117, 2132, 2133, 2171, 2223, 2224, 2256, 2299, - 2315, 2316, 2317, 2329, 0, 0, 1053, 0, 809, 0, + 1497, 2336, 2306, -2, 2064, 2038, 2230, 2231, 2124, 2139, + 2031, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, + 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, + 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, + 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, + 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, + 2429, 2430, 2431, 1988, 1989, 1990, 1991, 1992, 1993, 1994, + 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, + 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, + 2025, 2026, 2027, 2028, 2029, 2030, 2032, 2033, 2034, 2035, + 2036, 2037, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, + 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, + 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2065, 2066, 2067, + 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, + 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, + 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, + 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, + 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, + 2118, 2119, 2120, 2121, 2122, 2123, 2125, 2126, 2127, 2128, + 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, + 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, + 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, + 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, + 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, + 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, + 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, + 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, + 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, + 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2232, + 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, + 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, + 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, + -2, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, + 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, + 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, + 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, + 2303, 2304, 2305, 2307, 2308, 2309, 2310, 2311, 2312, 2313, + 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, -2, -2, + -2, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, + 2334, 2335, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, + 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, + 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, + 2365, 2366, 2367, 2368, 2369, 0, 315, 313, 2003, 2031, + 2038, 2064, 2124, 2139, 2140, 2178, 2230, 2231, 2263, 2306, + 2322, 2323, 2324, 2336, 0, 0, 1053, 0, 809, 0, 0, 814, 1441, 809, 352, 750, 751, 839, 867, 708, - 0, 391, 0, 2047, 395, 2306, 0, 0, 0, 0, + 0, 391, 0, 2054, 395, 2313, 0, 0, 0, 0, 705, 385, 386, 387, 388, 389, 390, 0, 0, 1012, - 0, 0, 2362, 381, 0, 346, 2120, 2328, 1498, 0, + 0, 0, 2369, 381, 0, 346, 2127, 2335, 1498, 0, 0, 0, 0, 0, 202, 1178, 204, 1180, 208, 216, 0, 0, 0, 221, 222, 225, 226, 227, 228, 229, 0, 233, 0, 235, 238, 0, 240, 241, 0, 244, 245, 246, 0, 256, 257, 258, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, -2, 131, 1051, 1952, 1838, 0, 1845, 1858, 1869, 1582, 1583, 1584, 1585, 0, 0, 0, - 0, 0, 0, 1593, 1594, 0, 1635, 2377, 2420, 2421, + 0, 0, 0, 1593, 1594, 0, 1635, 2384, 2427, 2428, 0, 1602, 1603, 1604, 1605, 1606, 1607, 0, 142, 154, 155, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 0, 1899, - 1900, 1901, 0, 1567, 1494, 0, 2386, 0, 2408, 2415, - 2416, 2417, 2418, 2407, 0, 0, 1794, 0, 1784, 0, - 0, -2, -2, 0, 0, 2196, -2, 2422, 2423, 2424, - 2383, 2404, 2412, 2413, 2414, 2387, 2388, 2411, 2379, 2380, - 2381, 2374, 2375, 2376, 2378, 2390, 2392, 2403, 0, 2399, - 2409, 2410, 2304, 0, 0, 2351, 0, 0, 0, 0, - 0, 2357, 2358, 2359, 2360, 2361, 2346, 156, 157, -2, + 1900, 1901, 0, 1567, 1494, 0, 2393, 0, 2415, 2422, + 2423, 2424, 2425, 2414, 0, 0, 1794, 0, 1784, 0, + 0, -2, -2, 0, 0, 2203, -2, 2429, 2430, 2431, + 2390, 2411, 2419, 2420, 2421, 2394, 2395, 2418, 2386, 2387, + 2388, 2381, 2382, 2383, 2385, 2397, 2399, 2410, 0, 2406, + 2416, 2417, 2311, 0, 0, 2358, 0, 0, 0, 0, + 0, 2364, 2365, 2366, 2367, 2368, 2353, 156, 157, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 1805, -2, 1807, -2, 1809, -2, 1811, -2, -2, -2, -2, 1816, 1817, -2, @@ -10437,340 +10477,342 @@ var yyDef = [...]int{ 637, 0, 0, 0, 685, 0, 0, 860, 860, 0, 688, 695, 685, 685, -2, 685, 685, 682, 685, 0, 0, 1239, 651, 652, 653, 637, 637, 656, 657, 658, - 668, 669, 696, 1976, 0, 0, 549, 0, 0, 549, - 0, 0, 549, 0, 549, 549, 549, 0, 768, 2073, - 2166, 2054, 2138, 2006, 2120, 2328, 0, 288, 2196, 293, - 0, 2056, 2076, 0, 0, 2095, 0, -2, 0, 368, + 668, 669, 696, 1983, 0, 0, 549, 0, 0, 549, + 0, 0, 549, 0, 549, 549, 549, 0, 768, 2080, + 2173, 2061, 2145, 2013, 2127, 2335, 0, 288, 2203, 293, + 0, 2063, 2083, 0, 0, 2102, 0, -2, 0, 368, 867, 0, 0, 839, 0, 0, 0, 0, 549, 549, 549, 549, 549, 549, 1326, 549, 549, 549, 549, 549, 0, 0, 0, 549, 549, 549, 549, 0, 903, 904, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 5, 6, 19, 0, 0, 0, 0, 0, 0, 110, - 109, 0, 1953, 1971, 1904, 1905, 1906, 1958, 1908, 1962, - 1962, 1962, 1962, 1937, 1938, 1939, 1940, 1941, 1942, 1943, - 1944, 1945, 1946, 1962, 1962, 0, 0, 1951, 1928, 1960, - 1960, 1960, 1958, 1955, 1909, 1910, 1911, 1912, 1913, 1914, - 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1965, 1965, - 1968, 1968, 1965, 0, 431, 429, 430, 1834, 0, 0, - 0, 0, 809, 813, 1439, 0, 0, 0, 867, -2, - 0, 0, 709, 392, 1499, 0, 0, 396, 0, 397, - 0, 0, 399, 0, 0, 0, 420, 0, 423, 407, - 408, 409, 410, 403, 0, 182, 0, 383, 384, 380, - 0, 0, 348, 0, 0, 0, 550, 0, 0, 0, - 0, 0, 0, 213, 209, 217, 220, 230, 237, 0, - 249, 251, 254, 210, 218, 223, 224, 231, 252, 211, - 214, 215, 219, 253, 255, 212, 232, 236, 250, 234, - 239, 242, 243, 248, 0, 183, 0, 0, 0, 0, - 0, 1844, 0, 0, 1877, 1878, 1879, 1880, 1881, 1882, - 1883, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -2, 1838, 0, 0, 1588, 1589, 1590, 1591, - 0, 1595, 0, 1636, 0, 0, 0, 0, 0, 0, - 1898, 1902, 0, 1834, 1834, 0, 1834, 1830, 0, 0, - 0, 0, 0, 0, 1834, 1767, 0, 0, 1769, 1785, - 0, 0, 1771, 1772, 0, 1775, 1776, 1834, 0, 1834, - 1780, 1834, 1834, 1834, 1761, 1762, 0, 0, 0, 1830, - 1830, 1830, 1830, 0, 0, 1830, 1830, 1830, 1830, 1830, - 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 860, 0, 868, 0, -2, 0, 886, 888, 890, - 891, 893, 894, 896, 897, 899, 900, 845, 0, 0, - 106, 0, 0, 0, 0, 0, 0, 72, 74, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 334, 0, 339, 325, 2159, 0, 324, 0, 0, 0, - 0, 0, 0, 1050, 0, 0, 0, 1225, 0, 0, - 0, 0, 0, 0, 0, 0, 1225, 1225, 1225, 1225, - 0, 1245, 768, 767, 0, 854, 0, 0, 71, 615, - 619, 620, 621, 0, 927, 0, 0, 624, 625, 0, - 626, 0, 0, 637, 685, 685, 643, 644, 639, 638, - 691, 692, 688, 0, 688, 688, 927, 0, 662, 663, - 664, 685, 685, 670, 861, 0, 671, 672, 688, 0, - 693, 694, 927, 0, 0, 927, 927, 0, 680, 681, - 683, 685, 0, 0, 1225, 0, 701, 639, 639, 1977, - 1978, 0, 549, 1088, 0, 0, 0, 1236, 0, 0, - 0, 0, 0, 0, 0, 704, 0, 0, 0, 449, - 450, 0, 0, 769, 0, 267, 271, 0, 274, 0, - 2166, 0, 2166, 0, 0, 281, 0, 0, 0, 0, - 0, 0, 311, 312, 0, 0, 0, 0, 302, 305, - 1433, 1434, 1175, 1176, 306, 307, 360, 361, 0, 860, - 885, 887, 881, 882, 883, 0, 73, 0, 0, 0, - 0, 0, 0, 549, 0, 0, 0, 0, 0, 744, - 0, 1068, 746, 0, 0, 0, 0, 0, 935, 929, - 931, 1007, 142, 905, 8, 127, 124, 0, 19, 0, - 0, 19, 19, 0, 19, 316, 0, 1974, 1972, 1973, - 1907, 1959, 0, 1933, 0, 1934, 1935, 1936, 1947, 1948, - 0, 0, 1929, 0, 1930, 1931, 1932, 1923, 0, 1924, - 1925, 0, 1926, 1927, 314, 428, 0, 0, 1835, 1054, - 0, 787, 801, 782, 0, 790, 0, 0, 1441, 0, - 0, 0, 0, 770, 801, 772, 0, 790, 860, 837, - 0, 865, 0, 0, 393, 0, 404, 398, 0, 405, - 400, 401, 0, 0, 422, 424, 425, 426, 411, 412, - 706, 377, 378, 379, 369, 370, 371, 372, 373, 374, - 375, 376, 0, 0, 382, 152, 0, 349, 350, 0, - 0, 0, 196, 197, 198, 199, 200, 201, 203, 187, - 733, 735, 1167, 1179, 0, 1170, 0, 206, 247, 179, - 0, 0, 0, 1839, 1840, 1841, 1842, 1843, 1848, 0, - 1850, 1852, 1854, 1856, 0, 1874, -2, -2, 1568, 1569, - 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, - 1580, 1581, 1859, 1872, 1873, 0, 0, 0, 0, 0, - 0, 1870, 1870, 1865, 0, 1608, 1435, 1436, 1586, 0, - 0, 1633, 1637, 0, 0, 0, 0, 0, 0, 1207, - 1958, 0, 143, 1829, 1728, 1729, 1730, 1731, 1732, 1733, - 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, - 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, - 1754, 1755, 1756, 0, 0, 1838, 0, 0, 0, 1831, - 1832, 0, 0, 0, 1716, 0, 0, 1722, 1723, 1724, - 0, 796, 0, 1795, 1768, 1786, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1757, 1758, - 1759, 1760, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 959, 961, 0, - 805, 807, 808, 834, 865, 841, 0, 0, 0, 102, - 107, 0, 1294, 0, 0, 0, 0, 0, 0, 0, - 75, 1240, 76, 1242, 0, 0, 0, 0, 0, 0, - 0, 343, 344, 0, 0, 338, 326, 2159, 328, 0, - 0, 0, 0, 1037, 0, 0, 0, 1225, 0, 0, - 1103, 1104, 547, 1161, 0, 0, 0, 1177, 1211, 1221, - 0, 0, 0, 0, 0, 1300, 0, 856, 0, 0, - 976, 617, 0, 0, 623, 686, 687, 928, 627, 0, - 0, 634, 2120, 639, 927, 927, 646, 640, 647, 690, - 648, 649, 650, 688, 927, 927, 862, 685, 688, 673, - 689, 688, 1441, 677, 0, 684, 1441, 702, 1441, 0, - 700, 654, 655, 1302, 0, 0, 0, 0, 447, 448, - 453, 455, 0, 514, 514, 514, 497, 514, 0, 0, - 485, 1979, 0, 0, 0, 0, 494, 1979, 0, 0, - 1979, 1979, 1979, 1979, 1979, 1979, 1979, 0, 0, 1979, - 1979, 1979, 1979, 1979, 1979, 1979, 1979, 1979, 1979, 1979, - 0, 1979, 1979, 1979, 1979, 1979, 1419, 1979, 0, 1237, - 504, 505, 506, 507, 512, 513, 0, 0, 458, 459, - 0, 0, 0, 0, 0, 542, 0, 0, 1102, 0, - 547, 0, 0, 1144, 0, 0, 940, 0, 941, 942, - 943, 938, 978, 1002, 1002, 0, 1002, 982, 1441, 0, - 0, 0, 279, 280, 268, 0, 269, 0, 0, 282, - 283, 0, 285, 286, 287, 294, 2054, 2138, 289, 291, - 0, 0, 295, 308, 309, 310, 0, 0, 300, 301, - 0, 0, 363, 364, 366, 0, 865, 1241, 729, 730, - 1437, 731, 732, 736, 0, 0, 739, 740, 741, 742, - 743, 1070, 0, 0, 1153, 1154, 1155, 1227, 927, 0, - 936, 0, 932, 1008, 0, 1010, 0, 0, 125, 19, - 0, 118, 115, 0, 0, 0, 0, 0, 1954, 1903, - 1975, 0, 0, 0, 1956, 0, 0, 0, 0, 0, - 108, 817, 777, 0, 781, 798, 0, 802, 0, 0, - 794, 786, 791, 0, 0, 811, 778, 1440, 0, 0, - 0, 0, 771, 0, 0, 776, 865, 0, 815, 0, - 869, 870, 873, 1500, 0, 406, 402, 421, 0, 0, - 0, 0, 190, 1164, 0, 191, 195, 185, 0, 0, - 0, 1169, 0, 1166, 1171, 0, 205, 0, 0, 180, - 181, 1285, 1294, 0, 0, 0, 1849, 1851, 1853, 1855, - 1857, 0, 1860, 1870, 1870, 1866, 0, 1861, 0, 1863, - 0, 1839, 1592, 0, 1638, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 873, 0, 0, 1706, 1707, 0, - 0, 1711, 0, 1713, 1714, 1715, 1717, 0, 0, 0, - 1721, 0, 1766, 1787, 1770, 1773, 0, 1777, 0, 1779, - 1781, 1782, 1783, 0, 0, 0, 867, 867, 0, 0, - 1677, 1677, 1677, 0, 0, 0, 0, 1677, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1611, - 0, 1612, 1613, 1614, 1615, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 962, 815, 0, 0, 0, - 0, 0, 1292, 0, 92, 0, 0, 0, 0, 97, - 0, 0, 77, 0, 0, 1248, 1249, 0, 0, 0, - 345, 333, 335, 0, 327, 0, 1226, 0, 0, 0, - 1041, 0, 0, -2, 1070, 0, 0, 1114, 1979, 551, - 0, 0, 1163, 0, 1133, 0, 0, 0, -2, 0, - 0, 0, 1221, 0, 0, 0, 1304, 0, 0, 0, - 755, 759, 23, 859, 0, 614, 0, 616, 622, 630, - 628, 0, 632, 0, 633, 685, 641, 642, 927, 665, - 666, 0, 0, 927, 685, 685, 676, 688, 697, 0, - 698, 1441, 1304, 0, 858, 1089, 1094, 1095, 1096, 1090, - 1091, 1097, 1098, 1236, 1370, 1338, 475, 0, 1454, 1455, - 515, 0, 1461, 1470, 1225, 1532, 0, 1470, 0, 0, - 1472, 1473, 0, 0, 0, 0, 498, 499, 0, 484, - 0, 0, 0, 0, 0, 0, 483, 0, 0, 525, - 0, 0, 0, 0, 0, 1980, 1979, 1979, 0, 492, - 493, 0, 496, 0, 0, 0, 0, 0, 0, 0, - 0, 1979, 1979, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1410, 0, 0, 0, 0, 0, - 0, 0, 1425, 1426, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1114, 1979, 0, 0, 0, 0, 551, - 1158, 1158, 1131, 1149, 0, 451, 452, 522, 0, 0, - 0, 0, 0, 0, 0, 968, 0, 0, 0, 967, - 0, 0, 0, 0, 0, 0, 0, 858, 1003, 0, - 1005, 1006, 980, -2, 0, 940, 985, 1834, 0, 272, - 273, 0, 0, 278, 296, 298, 270, 0, 0, 0, - 297, 299, 303, 304, 362, 365, 367, 815, 0, 0, - 1328, 0, 1071, 1072, 1074, 1075, 0, -2, -2, -2, + 109, 0, 1953, 1978, 1904, 1905, 1906, 1965, 1908, 1969, + 1969, 1969, 1969, 1937, 1938, 1939, 1940, 1941, 1942, 1943, + 1944, 1945, 1946, 1969, 1969, 0, 0, 1951, 1928, 1967, + 1967, 1967, 1965, 1955, 1956, 1957, 1958, 1959, 1960, 1961, + 1962, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, + 1918, 1919, 1920, 1921, 1922, 1972, 1972, 1975, 1975, 1972, + 0, 431, 429, 430, 1834, 0, 0, 0, 0, 809, + 813, 1439, 0, 0, 0, 867, -2, 0, 0, 709, + 392, 1499, 0, 0, 396, 0, 397, 0, 0, 399, + 0, 0, 0, 420, 0, 423, 407, 408, 409, 410, + 403, 0, 182, 0, 383, 384, 380, 0, 0, 348, + 0, 0, 0, 550, 0, 0, 0, 0, 0, 0, + 213, 209, 217, 220, 230, 237, 0, 249, 251, 254, + 210, 218, 223, 224, 231, 252, 211, 214, 215, 219, + 253, 255, 212, 232, 236, 250, 234, 239, 242, 243, + 248, 0, 183, 0, 0, 0, 0, 0, 1844, 0, + 0, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, + 1838, 0, 0, 1588, 1589, 1590, 1591, 0, 1595, 0, + 1636, 0, 0, 0, 0, 0, 0, 1898, 1902, 0, + 1834, 1834, 0, 1834, 1830, 0, 0, 0, 0, 0, + 0, 1834, 1767, 0, 0, 1769, 1785, 0, 0, 1771, + 1772, 0, 1775, 1776, 1834, 0, 1834, 1780, 1834, 1834, + 1834, 1761, 1762, 0, 0, 0, 1830, 1830, 1830, 1830, + 0, 0, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 860, 0, + 868, 0, -2, 0, 886, 888, 890, 891, 893, 894, + 896, 897, 899, 900, 845, 0, 0, 106, 0, 0, + 0, 0, 0, 0, 72, 74, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 334, 0, 339, + 325, 2166, 0, 324, 0, 0, 0, 0, 0, 0, + 1050, 0, 0, 0, 1225, 0, 0, 0, 0, 0, + 0, 0, 0, 1225, 1225, 1225, 1225, 0, 1245, 768, + 767, 0, 854, 0, 0, 71, 615, 619, 620, 621, + 0, 927, 0, 0, 624, 625, 0, 626, 0, 0, + 637, 685, 685, 643, 644, 639, 638, 691, 692, 688, + 0, 688, 688, 927, 0, 662, 663, 664, 685, 685, + 670, 861, 0, 671, 672, 688, 0, 693, 694, 927, + 0, 0, 927, 927, 0, 680, 681, 683, 685, 0, + 0, 1225, 0, 701, 639, 639, 1984, 1985, 0, 549, + 1088, 0, 0, 0, 1236, 0, 0, 0, 0, 0, + 0, 0, 704, 0, 0, 0, 449, 450, 0, 0, + 769, 0, 267, 271, 0, 274, 0, 2173, 0, 2173, + 0, 0, 281, 0, 0, 0, 0, 0, 0, 311, + 312, 0, 0, 0, 0, 302, 305, 1433, 1434, 1175, + 1176, 306, 307, 360, 361, 0, 860, 885, 887, 881, + 882, 883, 0, 73, 0, 0, 0, 0, 0, 0, + 549, 0, 0, 0, 0, 0, 744, 0, 1068, 746, + 0, 0, 0, 0, 0, 935, 929, 931, 1007, 142, + 905, 8, 127, 124, 0, 19, 0, 0, 19, 19, + 0, 19, 316, 0, 1981, 1979, 1980, 1907, 1966, 0, + 1933, 0, 1934, 1935, 1936, 1947, 1948, 0, 0, 1929, + 0, 1930, 1931, 1932, 1923, 0, 1924, 1925, 0, 1926, + 1927, 314, 428, 0, 0, 1835, 1054, 0, 787, 801, + 782, 0, 790, 0, 0, 1441, 0, 0, 0, 0, + 770, 801, 772, 0, 790, 860, 837, 0, 865, 0, + 0, 393, 0, 404, 398, 0, 405, 400, 401, 0, + 0, 422, 424, 425, 426, 411, 412, 706, 377, 378, + 379, 369, 370, 371, 372, 373, 374, 375, 376, 0, + 0, 382, 152, 0, 349, 350, 0, 0, 0, 196, + 197, 198, 199, 200, 201, 203, 187, 733, 735, 1167, + 1179, 0, 1170, 0, 206, 247, 179, 0, 0, 0, + 1839, 1840, 1841, 1842, 1843, 1848, 0, 1850, 1852, 1854, + 1856, 0, 1874, -2, -2, 1568, 1569, 1570, 1571, 1572, + 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1859, + 1872, 1873, 0, 0, 0, 0, 0, 0, 1870, 1870, + 1865, 0, 1608, 1435, 1436, 1586, 0, 0, 1633, 1637, + 0, 0, 0, 0, 0, 0, 1207, 1965, 0, 143, + 1829, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, + 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, + 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, + 0, 0, 1838, 0, 0, 0, 1831, 1832, 0, 0, + 0, 1716, 0, 0, 1722, 1723, 1724, 0, 796, 0, + 1795, 1768, 1786, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1757, 1758, 1759, 1760, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 959, 961, 0, 805, 807, 808, + 834, 865, 841, 0, 0, 0, 102, 107, 0, 1294, + 0, 0, 0, 0, 0, 0, 0, 75, 1240, 76, + 1242, 0, 0, 0, 0, 0, 0, 0, 343, 344, + 0, 0, 338, 326, 2166, 328, 0, 0, 0, 0, + 1037, 0, 0, 0, 1225, 0, 0, 1103, 1104, 547, + 1161, 0, 0, 0, 1177, 1211, 1221, 0, 0, 0, + 0, 0, 1300, 0, 856, 0, 0, 976, 617, 0, + 0, 623, 686, 687, 928, 627, 0, 0, 634, 2127, + 639, 927, 927, 646, 640, 647, 690, 648, 649, 650, + 688, 927, 927, 862, 685, 688, 673, 689, 688, 1441, + 677, 0, 684, 1441, 702, 1441, 0, 700, 654, 655, + 1302, 0, 0, 0, 0, 447, 448, 453, 455, 0, + 514, 514, 514, 497, 514, 0, 0, 485, 1986, 0, + 0, 0, 0, 494, 1986, 0, 0, 1986, 1986, 1986, + 1986, 1986, 1986, 1986, 0, 0, 1986, 1986, 1986, 1986, + 1986, 1986, 1986, 1986, 1986, 1986, 1986, 0, 1986, 1986, + 1986, 1986, 1986, 1419, 1986, 0, 1237, 504, 505, 506, + 507, 512, 513, 0, 0, 458, 459, 0, 0, 0, + 0, 0, 542, 0, 0, 1102, 0, 547, 0, 0, + 1144, 0, 0, 940, 0, 941, 942, 943, 938, 978, + 1002, 1002, 0, 1002, 982, 1441, 0, 0, 0, 279, + 280, 268, 0, 269, 0, 0, 282, 283, 0, 285, + 286, 287, 294, 2061, 2145, 289, 291, 0, 0, 295, + 308, 309, 310, 0, 0, 300, 301, 0, 0, 363, + 364, 366, 0, 865, 1241, 729, 730, 1437, 731, 732, + 736, 0, 0, 739, 740, 741, 742, 743, 1070, 0, + 0, 1153, 1154, 1155, 1227, 927, 0, 936, 0, 932, + 1008, 0, 1010, 0, 0, 125, 19, 0, 118, 115, + 0, 0, 0, 0, 0, 1954, 1903, 1982, 0, 0, + 0, 1963, 0, 0, 0, 0, 0, 108, 817, 777, + 0, 781, 798, 0, 802, 0, 0, 794, 786, 791, + 0, 0, 811, 778, 1440, 0, 0, 0, 0, 771, + 0, 0, 776, 865, 0, 815, 0, 869, 870, 873, + 1500, 0, 406, 402, 421, 0, 0, 0, 0, 190, + 1164, 0, 191, 195, 185, 0, 0, 0, 1169, 0, + 1166, 1171, 0, 205, 0, 0, 180, 181, 1285, 1294, + 0, 0, 0, 1849, 1851, 1853, 1855, 1857, 0, 1860, + 1870, 1870, 1866, 0, 1861, 0, 1863, 0, 1839, 1592, + 0, 1638, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 873, 0, 0, 1706, 1707, 0, 0, 1711, 0, + 1713, 1714, 1715, 1717, 0, 0, 0, 1721, 0, 1766, + 1787, 1770, 1773, 0, 1777, 0, 1779, 1781, 1782, 1783, + 0, 0, 0, 867, 867, 0, 0, 1677, 1677, 1677, + 0, 0, 0, 0, 1677, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1611, 0, 1612, 1613, + 1614, 1615, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 962, 815, 0, 0, 0, 0, 0, 1292, + 0, 92, 0, 0, 0, 0, 97, 0, 0, 77, + 0, 0, 1248, 1249, 0, 0, 0, 345, 333, 335, + 0, 327, 0, 1226, 0, 0, 0, 1041, 0, 0, + -2, 1070, 0, 0, 1114, 1986, 551, 0, 0, 1163, + 0, 1133, 0, 0, 0, -2, 0, 0, 0, 1221, + 0, 0, 0, 1304, 0, 0, 0, 755, 759, 23, + 859, 0, 614, 0, 616, 622, 630, 628, 0, 632, + 0, 633, 685, 641, 642, 927, 665, 666, 0, 0, + 927, 685, 685, 676, 688, 697, 0, 698, 1441, 1304, + 0, 858, 1089, 1094, 1095, 1096, 1090, 1091, 1097, 1098, + 1236, 1370, 1338, 475, 0, 1454, 1455, 515, 0, 1461, + 1470, 1225, 1532, 0, 1470, 0, 0, 1472, 1473, 0, + 0, 0, 0, 498, 499, 0, 484, 0, 0, 0, + 0, 0, 0, 483, 0, 0, 525, 0, 0, 0, + 0, 0, 1987, 1986, 1986, 0, 492, 493, 0, 496, + 0, 0, 0, 0, 0, 0, 0, 0, 1986, 1986, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1410, 0, 0, 0, 0, 0, 0, 0, 1425, + 1426, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1114, 1986, 0, 0, 0, 0, 551, 1158, 1158, 1131, + 1149, 0, 451, 452, 522, 0, 0, 0, 0, 0, + 0, 0, 968, 0, 0, 0, 967, 0, 0, 0, + 0, 0, 0, 0, 858, 1003, 0, 1005, 1006, 980, + -2, 0, 940, 985, 1834, 0, 272, 273, 0, 0, + 278, 296, 298, 270, 0, 0, 0, 297, 299, 303, + 304, 362, 365, 367, 815, 0, 0, 1328, 0, 1071, + 1072, 1074, 1075, 0, -2, -2, -2, -2, -2, -2, + -2, -2, -2, -2, -2, -2, -2, 2045, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, - 2038, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, - -2, -2, 1069, 747, 1156, 1228, 918, 930, 937, 1009, - 1011, 143, 933, 0, 128, 19, 127, 119, 120, 0, - 19, 0, 0, 0, 0, 1964, 1963, 1949, 0, 1950, - 1961, 1966, 0, 1969, 0, 432, 821, 0, 0, 801, - 803, 0, 0, 801, 0, 0, 810, 0, 0, 0, - 0, 0, 0, 0, 801, 815, 817, 838, 0, 0, - 876, 874, 875, 0, 0, 707, 153, 427, 0, 0, - 0, 0, 0, 734, 0, 1168, 187, 0, 0, 207, - 0, 0, 0, 1294, 1289, 1833, 1862, 1864, 0, 1871, - 1867, 1587, 1596, 1634, 0, 0, 1640, 1652, 1652, 0, - 0, 0, 1643, 1962, 1962, 1646, 1958, 1960, 1958, 1652, - 1652, 0, 1208, 0, 1209, 873, 144, 0, 0, 1712, - 0, 0, 0, 797, 0, 0, 0, 0, 0, 1673, - 1675, 1677, 1677, 1684, 1678, 1685, 1686, 1677, 1677, 1677, - 1677, 1691, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, - 1677, 1677, 1677, 1671, 1616, 0, 1619, 0, 1622, 1623, - 0, 0, 0, 1892, 1893, 806, 835, 0, 0, 848, - 849, 850, 851, 852, 0, 0, 62, 62, 1294, 0, - 101, 93, 0, 0, 0, 0, 0, 0, 0, 1257, - 1265, 0, 337, 0, 78, 79, 81, 0, 0, 0, - 0, 0, 0, 0, 91, 1045, 0, 1039, 0, 0, - 1056, 1057, 1059, 0, 1062, 1063, 1064, 0, 858, 1447, - 1118, 1115, 1116, 1117, 0, 1158, 552, 553, 554, 555, - 0, 0, 0, 1162, 0, 0, 1126, 0, 0, 0, - 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, -2, 1231, - 0, 1441, 0, 0, 1447, 1277, 0, 0, 1282, 0, - 1447, 1447, 0, 1312, 0, 1301, 809, 0, -2, 0, - 0, 757, 0, 0, 977, 618, 629, 635, 927, 659, - 863, 864, 1441, 927, 927, 685, 703, 699, 1312, 1303, - 0, 454, 514, 0, 1358, 0, 0, 1364, 0, 1371, - 468, 0, 516, 0, 1460, 1488, 1471, 1488, 1533, 1488, - 1488, 1225, 0, 516, 0, 0, 486, 0, 0, 0, - 0, 0, 482, 519, 873, 469, 471, 472, 473, 523, - 524, 526, 0, 528, 529, 488, 500, 501, 502, 503, - 0, 0, 0, 495, 508, 509, 510, 511, 470, 1387, - 1388, 1389, 1392, 1393, 1394, 1395, 0, 0, 1398, 1399, - 1400, 1401, 1402, 1485, 1486, 1487, 1403, 1404, 1405, 1406, - 1407, 1408, 1409, 1427, 1428, 1429, 1430, 1431, 1432, 1411, - 1412, 1413, 1414, 1415, 1416, 1417, 1418, 0, 0, 1422, - 0, 0, 1039, 0, 462, 463, 0, 465, 0, 0, - 1118, 0, 0, 0, 0, 0, 1158, 545, 0, 0, - 546, 1133, 0, 1151, 0, 1145, 1146, 0, 0, 779, - 927, 355, 0, 972, 963, 0, 947, 0, 949, 969, - 950, 970, 0, 0, 954, 0, 956, 0, 952, 953, - 958, 951, 927, 939, 979, 1004, 981, 984, 986, 987, - 993, 0, 0, 0, 0, 266, 275, 276, 277, 284, - 0, 571, 290, 879, 1438, 737, 738, 1329, 1330, 745, - 0, 1076, 916, 0, 0, 123, 126, 0, 121, 0, - 0, 0, 0, 113, 111, 1957, 0, 0, 823, 167, - 0, 0, 0, 799, 0, 804, 801, 785, 795, 784, - 792, 793, 812, 1442, 1443, 1444, 1445, 0, 801, 775, - 774, 879, 821, 0, 871, 872, 0, 1501, 394, 0, - 1165, 187, 192, 193, 194, 188, 186, 1172, 0, 1174, - 0, 1287, 0, 0, 1868, 1639, 1597, 1641, 1653, 1654, - 1642, 0, 1599, 1600, 1644, 1645, 1647, 1648, 1649, 1650, - 1651, 1601, 0, 1210, 1708, 0, 1710, 1718, 1719, 0, - 1774, 1778, 0, 0, 1765, 0, 0, 0, 0, 1682, - 1683, 1687, 1688, 1689, 1690, 1692, 1693, 1694, 1695, 1696, - 1697, 1698, 1699, 1700, 1701, 1702, 867, 1672, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 846, 0, 0, 0, 64, 0, 64, 1293, 1295, 0, - 1007, 0, 0, 98, 0, 1271, 1441, 1259, 0, 1251, - 0, 1265, 0, 0, 0, 80, 82, 0, 2123, 0, - 0, 0, 0, 1227, 1047, 0, 0, 1038, 0, 1049, - 1065, 1061, 0, 0, 0, 0, 1448, 1449, 1451, 1452, - 1453, 1086, 0, 0, 1106, 1107, 1108, 1120, 0, 557, - 558, 0, 0, 0, 570, 566, 567, 568, 548, 1157, - 1140, 0, 0, 1129, 0, 0, 1139, 0, 1232, 1979, - 1979, 1979, 1271, 0, 0, 1372, 1979, 1979, 0, 1279, - 1281, 1271, 0, 0, 1376, 1315, 0, 0, 1306, 0, - 1002, 0, 0, 927, 756, 759, 760, 857, 636, 674, - 678, 675, 927, 1315, 0, 1336, 0, 0, 0, 0, - 0, 1368, 0, 0, 1340, 0, 487, 517, 0, -2, - 0, 1489, 0, 1474, 1489, 0, 0, 1488, 0, 476, - 516, 0, 0, 0, 530, 535, 536, 0, 532, 533, - 1528, 0, 534, 0, 521, 0, 527, 1390, 1391, 0, - 1396, 1397, 0, 1421, 0, 0, 457, 460, 0, 1043, - 1044, -2, 0, 0, 0, 537, 0, 0, 0, 538, - 539, 544, 1159, 1160, 1126, 0, 1140, 0, 1150, 0, - 1147, 1148, 867, 0, 0, 944, 973, 0, 0, 945, - 0, 946, 948, 971, 0, 965, 955, 957, 354, 988, - 0, 0, 990, 991, 992, 983, 292, 833, 0, 1073, - 0, 901, 0, 0, 934, 0, 19, 0, 0, 116, - 1967, 1970, 825, 0, 822, 168, 0, 0, 0, 0, - 789, 800, 783, 1446, 773, 836, 823, 0, 877, 878, - 189, 184, 1173, 1297, 0, 1288, 0, 1552, 1610, 0, - 1720, 0, 0, 1677, 1674, 1677, 1676, 1668, 0, 1617, - 0, 1620, 0, 1624, 1625, 0, 1627, 1628, 1629, 0, - 1631, 1632, 0, 844, 0, 60, 0, 63, 61, 0, - 100, 94, 0, 0, 1246, 0, 1271, 1250, 0, 0, - 0, 1252, 0, 0, 0, 83, 0, 0, 0, 0, - 0, 0, 89, 0, 0, 1046, 0, 1040, 0, 0, - 1058, 1060, 0, 0, 1376, 0, 1119, 1105, 0, 0, - 559, 560, 0, 563, 569, 1121, 0, 0, 1123, 1124, - 1125, 0, 0, 1137, 0, 0, 0, 0, 1220, 1222, - 1238, 0, 0, 0, -2, 1283, 0, -2, 1276, 0, - 1321, 0, 1313, 0, 1305, 0, 1308, 927, 927, -2, - 753, 758, 0, 679, 1321, 446, 1338, 0, 1359, 0, - 0, 0, 0, 0, 0, 0, 1339, 0, 1352, 518, - 1490, -2, 1504, 1506, 0, 1237, 1509, 1510, 0, 0, - 0, 0, 0, 0, 1559, 1518, 0, 0, 1522, 1523, - 1524, 0, 0, 1527, 0, 1886, 1887, 0, 1531, 0, - 0, 0, 0, 0, 0, 0, 1468, 477, 478, 0, - 480, 481, 1979, 1529, 520, 474, 1979, 490, 1420, 1423, - 1424, 461, 464, 0, 0, 543, 540, 541, 1129, 1132, - 1143, 1152, 780, 860, 356, 357, 974, 0, 964, 966, - 997, 994, 0, 0, 880, 1077, 917, 925, 2351, 2353, - 2350, 117, 122, 0, 0, 827, 0, 824, 0, 818, - 820, 178, 788, 825, 866, 138, 170, 0, 0, 1598, - 0, 0, 0, 1709, 1763, 1764, 1680, 1681, 0, 1669, - 0, 1663, 1664, 1665, 1670, 0, 0, 0, 0, 847, - 842, 65, 96, 0, 99, 0, 1247, 0, 0, 0, - 1263, 1264, 0, 1266, 1267, 1268, 0, 0, 0, 0, - -2, 69, 1227, 0, 1227, 0, 0, 0, 0, 1048, - 1042, 1052, 1066, 0, 1079, 1092, 1243, 1450, 0, 0, - 556, 561, 0, 564, 565, 1141, 1140, 0, 1127, 1128, - 0, 1135, 0, 0, 1233, 1234, 1235, 1373, 1374, 1375, - 1331, 1278, 0, -2, 1384, 0, 1274, 1297, 1331, 0, - 1309, 0, 1316, 0, 1314, 1307, 867, 754, 1318, 456, - 1370, 1360, 0, 1362, 0, 0, 0, 0, 1341, -2, - 0, 1505, 1507, 1508, 1511, 1512, 1513, 1564, 1565, 1566, - 0, 0, 1516, 1561, 1562, 1563, 1517, 0, 0, 0, - 0, 0, 1884, 1885, 1557, 0, 0, 1475, 1477, 1478, - 1479, 1480, 1481, 1482, 1483, 1484, 1476, 0, 0, 0, - 1467, 1469, 479, 0, 0, 1979, 0, 0, 1142, 353, - 0, 0, 998, 1000, 995, 996, 919, 0, 0, 0, - 0, 112, 114, 129, 0, 826, 169, 0, 827, 140, - 0, 161, 0, 1298, 0, 1609, 0, 0, 0, 1679, - 1666, 0, 0, 0, 0, 0, 1888, 1889, 1890, 1618, - 1621, 1626, 1630, 95, 1272, 1260, 1261, 1262, 1258, 0, - 0, 1269, 1270, 0, 67, 0, 84, 1227, 85, 1227, - 0, 0, 1036, 0, 1085, 1099, 1109, 1110, 0, 1112, - 1113, 562, 1122, 1130, 1134, 1137, 0, 1194, 1333, 0, - 1280, 1236, 1386, 1979, 1284, 1333, 0, 1378, 1979, 1979, - 1299, 0, 1311, 0, 1323, 0, 1317, 860, 445, 0, - 1320, 1356, 1361, 1363, 1365, 0, 1369, 1367, 1342, -2, - 0, 1350, 0, 0, 1514, 1515, 0, 0, 1784, 1979, - 0, 1547, 0, 1194, 1194, 1194, 1194, 0, 531, 489, - 0, 0, 467, 975, 989, 0, 926, 0, 0, 0, - 0, 0, 816, 130, 0, 139, 158, 0, 171, 172, - 0, 0, 0, 0, 1290, 0, 1555, 1556, 0, 1655, - 0, 0, 0, 1659, 1660, 1661, 1662, 1265, 1265, 66, - 69, 0, 86, 87, 0, 1227, 0, 1078, 0, 1100, - 1101, 1111, 1136, 1138, 1193, 1273, 0, 1370, 1385, 0, - 1275, 1377, 0, 0, 0, 1310, 1322, 0, 1325, 752, - 1319, 1337, 0, 1366, 1343, 1351, 0, 1346, 0, 0, - 0, 1560, 0, 1521, 0, 1526, 1535, 1548, 0, 0, - 1456, 0, 1458, 0, 1462, 0, 1464, 0, 0, 491, - 466, 999, 1001, 0, 1834, 921, 922, 0, 829, 819, - 141, 145, 0, 167, 164, 0, 173, 0, 0, 0, - 0, 1286, 0, 1553, 0, 1656, 1657, 1658, 1253, 1265, - 1254, 1265, 68, 70, 1227, 88, 0, 1080, 1081, 0, - 1195, 1979, 1979, 0, 0, 0, 1201, 1202, 1979, 1979, - 1979, 1979, 0, 1358, 1390, 1379, 1380, 1381, 1324, 1357, - 1345, 0, -2, 1353, 0, 0, 1836, 1846, 1847, 1519, - 1525, 1534, 1536, 1537, 0, 1549, 1550, 1551, 1558, 1194, - 1194, 1194, 1194, 1466, 920, 0, 0, 828, 0, 132, - 0, 0, 162, 163, 165, 0, 174, 0, 176, 177, - 0, 0, 1667, 1255, 1256, 90, 1082, 1093, 0, 0, - 1198, 1199, 0, 0, 0, 0, 0, 1334, 0, 1336, - 1347, -2, 0, 1355, 0, 1520, 1538, 0, 1539, 0, - 0, 0, 1457, 1459, 1463, 1465, 1834, 923, 830, 1296, - 0, 146, 0, 148, 150, 151, 1491, 159, 160, 166, - 175, 0, 0, 1067, 1083, 0, 1196, 1197, 1200, 1203, - 1204, 1205, 1206, 0, 1338, 1354, 1837, 1540, 1542, 1543, - 0, 0, 1541, 0, 133, 134, 0, 147, 0, 0, - 1291, 1554, 1084, 1335, 1332, 1544, 1546, 1545, 924, 0, - 0, 149, 1492, 135, 136, 137, 0, 1493, + -2, -2, -2, -2, -2, -2, 1069, 747, 1156, 1228, + 918, 930, 937, 1009, 1011, 143, 933, 0, 128, 19, + 127, 119, 120, 0, 19, 0, 0, 0, 0, 1971, + 1970, 1949, 0, 1950, 1968, 1973, 0, 1976, 0, 432, + 821, 0, 0, 801, 803, 0, 0, 801, 0, 0, + 810, 0, 0, 0, 0, 0, 0, 0, 801, 815, + 817, 838, 0, 0, 876, 874, 875, 0, 0, 707, + 153, 427, 0, 0, 0, 0, 0, 734, 0, 1168, + 187, 0, 0, 207, 0, 0, 0, 1294, 1289, 1833, + 1862, 1864, 0, 1871, 1867, 1587, 1596, 1634, 0, 0, + 1640, 1652, 1652, 0, 0, 0, 1643, 1969, 1969, 1646, + 1965, 1967, 1965, 1652, 1652, 0, 1208, 0, 1209, 873, + 144, 0, 0, 1712, 0, 0, 0, 797, 0, 0, + 0, 0, 0, 1673, 1675, 1677, 1677, 1684, 1678, 1685, + 1686, 1677, 1677, 1677, 1677, 1691, 1677, 1677, 1677, 1677, + 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1671, 1616, 0, + 1619, 0, 1622, 1623, 0, 0, 0, 1892, 1893, 806, + 835, 0, 0, 848, 849, 850, 851, 852, 0, 0, + 62, 62, 1294, 0, 101, 93, 0, 0, 0, 0, + 0, 0, 0, 1257, 1265, 0, 337, 0, 78, 79, + 81, 0, 0, 0, 0, 0, 0, 0, 91, 1045, + 0, 1039, 0, 0, 1056, 1057, 1059, 0, 1062, 1063, + 1064, 0, 858, 1447, 1118, 1115, 1116, 1117, 0, 1158, + 552, 553, 554, 555, 0, 0, 0, 1162, 0, 0, + 1126, 0, 0, 0, 1212, 1213, 1214, 1215, 1216, 1217, + 1218, 1219, -2, 1231, 0, 1441, 0, 0, 1447, 1277, + 0, 0, 1282, 0, 1447, 1447, 0, 1312, 0, 1301, + 809, 0, -2, 0, 0, 757, 0, 0, 977, 618, + 629, 635, 927, 659, 863, 864, 1441, 927, 927, 685, + 703, 699, 1312, 1303, 0, 454, 514, 0, 1358, 0, + 0, 1364, 0, 1371, 468, 0, 516, 0, 1460, 1488, + 1471, 1488, 1533, 1488, 1488, 1225, 0, 516, 0, 0, + 486, 0, 0, 0, 0, 0, 482, 519, 873, 469, + 471, 472, 473, 523, 524, 526, 0, 528, 529, 488, + 500, 501, 502, 503, 0, 0, 0, 495, 508, 509, + 510, 511, 470, 1387, 1388, 1389, 1392, 1393, 1394, 1395, + 0, 0, 1398, 1399, 1400, 1401, 1402, 1485, 1486, 1487, + 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1427, 1428, 1429, + 1430, 1431, 1432, 1411, 1412, 1413, 1414, 1415, 1416, 1417, + 1418, 0, 0, 1422, 0, 0, 1039, 0, 462, 463, + 0, 465, 0, 0, 1118, 0, 0, 0, 0, 0, + 1158, 545, 0, 0, 546, 1133, 0, 1151, 0, 1145, + 1146, 0, 0, 779, 927, 355, 0, 972, 963, 0, + 947, 0, 949, 969, 950, 970, 0, 0, 954, 0, + 956, 0, 952, 953, 958, 951, 927, 939, 979, 1004, + 981, 984, 986, 987, 993, 0, 0, 0, 0, 266, + 275, 276, 277, 284, 0, 571, 290, 879, 1438, 737, + 738, 1329, 1330, 745, 0, 1076, 916, 0, 0, 123, + 126, 0, 121, 0, 0, 0, 0, 113, 111, 1964, + 0, 0, 823, 167, 0, 0, 0, 799, 0, 804, + 801, 785, 795, 784, 792, 793, 812, 1442, 1443, 1444, + 1445, 0, 801, 775, 774, 879, 821, 0, 871, 872, + 0, 1501, 394, 0, 1165, 187, 192, 193, 194, 188, + 186, 1172, 0, 1174, 0, 1287, 0, 0, 1868, 1639, + 1597, 1641, 1653, 1654, 1642, 0, 1599, 1600, 1644, 1645, + 1647, 1648, 1649, 1650, 1651, 1601, 0, 1210, 1708, 0, + 1710, 1718, 1719, 0, 1774, 1778, 0, 0, 1765, 0, + 0, 0, 0, 1682, 1683, 1687, 1688, 1689, 1690, 1692, + 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, + 867, 1672, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 846, 0, 0, 0, 64, 0, + 64, 1293, 1295, 0, 1007, 0, 0, 98, 0, 1271, + 1441, 1259, 0, 1251, 0, 1265, 0, 0, 0, 80, + 82, 0, 2130, 0, 0, 0, 0, 1227, 1047, 0, + 0, 1038, 0, 1049, 1065, 1061, 0, 0, 0, 0, + 1448, 1449, 1451, 1452, 1453, 1086, 0, 0, 1106, 1107, + 1108, 1120, 0, 557, 558, 0, 0, 0, 570, 566, + 567, 568, 548, 1157, 1140, 0, 0, 1129, 0, 0, + 1139, 0, 1232, 1986, 1986, 1986, 1271, 0, 0, 1372, + 1986, 1986, 0, 1279, 1281, 1271, 0, 0, 1376, 1315, + 0, 0, 1306, 0, 1002, 0, 0, 927, 756, 759, + 760, 857, 636, 674, 678, 675, 927, 1315, 0, 1336, + 0, 0, 0, 0, 0, 1368, 0, 0, 1340, 0, + 487, 517, 0, -2, 0, 1489, 0, 1474, 1489, 0, + 0, 1488, 0, 476, 516, 0, 0, 0, 530, 535, + 536, 0, 532, 533, 1528, 0, 534, 0, 521, 0, + 527, 1390, 1391, 0, 1396, 1397, 0, 1421, 0, 0, + 457, 460, 0, 1043, 1044, -2, 0, 0, 0, 537, + 0, 0, 0, 538, 539, 544, 1159, 1160, 1126, 0, + 1140, 0, 1150, 0, 1147, 1148, 867, 0, 0, 944, + 973, 0, 0, 945, 0, 946, 948, 971, 0, 965, + 955, 957, 354, 988, 0, 0, 990, 991, 992, 983, + 292, 833, 0, 1073, 0, 901, 0, 0, 934, 0, + 19, 0, 0, 116, 1974, 1977, 825, 0, 822, 168, + 0, 0, 0, 0, 789, 800, 783, 1446, 773, 836, + 823, 0, 877, 878, 189, 184, 1173, 1297, 0, 1288, + 0, 1552, 1610, 0, 1720, 0, 0, 1677, 1674, 1677, + 1676, 1668, 0, 1617, 0, 1620, 0, 1624, 1625, 0, + 1627, 1628, 1629, 0, 1631, 1632, 0, 844, 0, 60, + 0, 63, 61, 0, 100, 94, 0, 0, 1246, 0, + 1271, 1250, 0, 0, 0, 1252, 0, 0, 0, 83, + 0, 0, 0, 0, 0, 0, 89, 0, 0, 1046, + 0, 1040, 0, 0, 1058, 1060, 0, 0, 1376, 0, + 1119, 1105, 0, 0, 559, 560, 0, 563, 569, 1121, + 0, 0, 1123, 1124, 1125, 0, 0, 1137, 0, 0, + 0, 0, 1220, 1222, 1238, 0, 0, 0, -2, 1283, + 0, -2, 1276, 0, 1321, 0, 1313, 0, 1305, 0, + 1308, 927, 927, -2, 753, 758, 0, 679, 1321, 446, + 1338, 0, 1359, 0, 0, 0, 0, 0, 0, 0, + 1339, 0, 1352, 518, 1490, -2, 1504, 1506, 0, 1237, + 1509, 1510, 0, 0, 0, 0, 0, 0, 1559, 1518, + 0, 0, 1522, 1523, 1524, 0, 0, 1527, 0, 1886, + 1887, 0, 1531, 0, 0, 0, 0, 0, 0, 0, + 1468, 477, 478, 0, 480, 481, 1986, 1529, 520, 474, + 1986, 490, 1420, 1423, 1424, 461, 464, 0, 0, 543, + 540, 541, 1129, 1132, 1143, 1152, 780, 860, 356, 357, + 974, 0, 964, 966, 997, 994, 0, 0, 880, 1077, + 917, 925, 2358, 2360, 2357, 117, 122, 0, 0, 827, + 0, 824, 0, 818, 820, 178, 788, 825, 866, 138, + 170, 0, 0, 1598, 0, 0, 0, 1709, 1763, 1764, + 1680, 1681, 0, 1669, 0, 1663, 1664, 1665, 1670, 0, + 0, 0, 0, 847, 842, 65, 96, 0, 99, 0, + 1247, 0, 0, 0, 1263, 1264, 0, 1266, 1267, 1268, + 0, 0, 0, 0, -2, 69, 1227, 0, 1227, 0, + 0, 0, 0, 1048, 1042, 1052, 1066, 0, 1079, 1092, + 1243, 1450, 0, 0, 556, 561, 0, 564, 565, 1141, + 1140, 0, 1127, 1128, 0, 1135, 0, 0, 1233, 1234, + 1235, 1373, 1374, 1375, 1331, 1278, 0, -2, 1384, 0, + 1274, 1297, 1331, 0, 1309, 0, 1316, 0, 1314, 1307, + 867, 754, 1318, 456, 1370, 1360, 0, 1362, 0, 0, + 0, 0, 1341, -2, 0, 1505, 1507, 1508, 1511, 1512, + 1513, 1564, 1565, 1566, 0, 0, 1516, 1561, 1562, 1563, + 1517, 0, 0, 0, 0, 0, 1884, 1885, 1557, 0, + 0, 1475, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, + 1476, 0, 0, 0, 1467, 1469, 479, 0, 0, 1986, + 0, 0, 1142, 353, 0, 0, 998, 1000, 995, 996, + 919, 0, 0, 0, 0, 112, 114, 129, 0, 826, + 169, 0, 827, 140, 0, 161, 0, 1298, 0, 1609, + 0, 0, 0, 1679, 1666, 0, 0, 0, 0, 0, + 1888, 1889, 1890, 1618, 1621, 1626, 1630, 95, 1272, 1260, + 1261, 1262, 1258, 0, 0, 1269, 1270, 0, 67, 0, + 84, 1227, 85, 1227, 0, 0, 1036, 0, 1085, 1099, + 1109, 1110, 0, 1112, 1113, 562, 1122, 1130, 1134, 1137, + 0, 1194, 1333, 0, 1280, 1236, 1386, 1986, 1284, 1333, + 0, 1378, 1986, 1986, 1299, 0, 1311, 0, 1323, 0, + 1317, 860, 445, 0, 1320, 1356, 1361, 1363, 1365, 0, + 1369, 1367, 1342, -2, 0, 1350, 0, 0, 1514, 1515, + 0, 0, 1784, 1986, 0, 1547, 0, 1194, 1194, 1194, + 1194, 0, 531, 489, 0, 0, 467, 975, 989, 0, + 926, 0, 0, 0, 0, 0, 816, 130, 0, 139, + 158, 0, 171, 172, 0, 0, 0, 0, 1290, 0, + 1555, 1556, 0, 1655, 0, 0, 0, 1659, 1660, 1661, + 1662, 1265, 1265, 66, 69, 0, 86, 87, 0, 1227, + 0, 1078, 0, 1100, 1101, 1111, 1136, 1138, 1193, 1273, + 0, 1370, 1385, 0, 1275, 1377, 0, 0, 0, 1310, + 1322, 0, 1325, 752, 1319, 1337, 0, 1366, 1343, 1351, + 0, 1346, 0, 0, 0, 1560, 0, 1521, 0, 1526, + 1535, 1548, 0, 0, 1456, 0, 1458, 0, 1462, 0, + 1464, 0, 0, 491, 466, 999, 1001, 0, 1834, 921, + 922, 0, 829, 819, 141, 145, 0, 167, 164, 0, + 173, 0, 0, 0, 0, 1286, 0, 1553, 0, 1656, + 1657, 1658, 1253, 1265, 1254, 1265, 68, 70, 1227, 88, + 0, 1080, 1081, 0, 1195, 1986, 1986, 0, 0, 0, + 1201, 1202, 1986, 1986, 1986, 1986, 0, 1358, 1390, 1379, + 1380, 1381, 1324, 1357, 1345, 0, -2, 1353, 0, 0, + 1836, 1846, 1847, 1519, 1525, 1534, 1536, 1537, 0, 1549, + 1550, 1551, 1558, 1194, 1194, 1194, 1194, 1466, 920, 0, + 0, 828, 0, 132, 0, 0, 162, 163, 165, 0, + 174, 0, 176, 177, 0, 0, 1667, 1255, 1256, 90, + 1082, 1093, 0, 0, 1198, 1199, 0, 0, 0, 0, + 0, 1334, 0, 1336, 1347, -2, 0, 1355, 0, 1520, + 1538, 0, 1539, 0, 0, 0, 1457, 1459, 1463, 1465, + 1834, 923, 830, 1296, 0, 146, 0, 148, 150, 151, + 1491, 159, 160, 166, 175, 0, 0, 1067, 1083, 0, + 1196, 1197, 1200, 1203, 1204, 1205, 1206, 0, 1338, 1354, + 1837, 1540, 1542, 1543, 0, 0, 1541, 0, 133, 134, + 0, 147, 0, 0, 1291, 1554, 1084, 1335, 1332, 1544, + 1546, 1545, 924, 0, 0, 149, 1492, 135, 136, 137, + 0, 1493, } var yyTok1 = [...]int{ @@ -27276,8 +27318,12 @@ yydefault: yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))") goto ret1 } - if yyDollar[2].lengthScaleOptUnion().DisplayWith > 38 || yyDollar[2].lengthScaleOptUnion().DisplayWith < 0 { - yylex.Error("For decimal(M), M must between 0 and 38.") + if yyDollar[2].lengthScaleOptUnion().Scale > 30 { + yylex.Error("Display scale for decimal out of range (max = 30)") + goto ret1 + } + if yyDollar[2].lengthScaleOptUnion().DisplayWith > 65 || yyDollar[2].lengthScaleOptUnion().DisplayWith < 0 { + yylex.Error("For decimal(M), M must between 0 and 65.") goto ret1 } else if yyDollar[2].lengthScaleOptUnion().DisplayWith <= 16 { yyLOCAL = &tree.T{ @@ -27309,15 +27355,19 @@ yydefault: case 1926: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12536 +//line mysql_sql.y:12540 { locale := "" if yyDollar[2].lengthScaleOptUnion().Scale != tree.NotDefineDec && yyDollar[2].lengthScaleOptUnion().Scale > yyDollar[2].lengthScaleOptUnion().DisplayWith { yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))") goto ret1 } - if yyDollar[2].lengthScaleOptUnion().DisplayWith > 38 || yyDollar[2].lengthScaleOptUnion().DisplayWith < 0 { - yylex.Error("For decimal(M), M must between 0 and 38.") + if yyDollar[2].lengthScaleOptUnion().Scale > 30 { + yylex.Error("Display scale for decimal out of range (max = 30)") + goto ret1 + } + if yyDollar[2].lengthScaleOptUnion().DisplayWith > 65 || yyDollar[2].lengthScaleOptUnion().DisplayWith < 0 { + yylex.Error("For decimal(M), M must between 0 and 65.") goto ret1 } else if yyDollar[2].lengthScaleOptUnion().DisplayWith <= 16 { yyLOCAL = &tree.T{ @@ -27349,7 +27399,7 @@ yydefault: case 1927: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12572 +//line mysql_sql.y:12580 { locale := "" yyLOCAL = &tree.T{ @@ -27368,7 +27418,7 @@ yydefault: case 1928: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12589 +//line mysql_sql.y:12597 { locale := "" yyLOCAL = &tree.T{ @@ -27384,7 +27434,7 @@ yydefault: case 1929: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12601 +//line mysql_sql.y:12609 { locale := "" if yyDollar[2].lengthOptUnion() < 0 || yyDollar[2].lengthOptUnion() > 6 { @@ -27408,7 +27458,7 @@ yydefault: case 1930: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12621 +//line mysql_sql.y:12629 { locale := "" if yyDollar[2].lengthOptUnion() < 0 || yyDollar[2].lengthOptUnion() > 6 { @@ -27432,7 +27482,7 @@ yydefault: case 1931: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12641 +//line mysql_sql.y:12649 { locale := "" if yyDollar[2].lengthOptUnion() < 0 || yyDollar[2].lengthOptUnion() > 6 { @@ -27456,7 +27506,7 @@ yydefault: case 1932: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12661 +//line mysql_sql.y:12669 { locale := "" yyLOCAL = &tree.T{ @@ -27474,7 +27524,7 @@ yydefault: case 1933: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12677 +//line mysql_sql.y:12685 { locale := "" yyLOCAL = &tree.T{ @@ -27491,7 +27541,7 @@ yydefault: case 1934: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12690 +//line mysql_sql.y:12698 { locale := "" yyLOCAL = &tree.T{ @@ -27508,7 +27558,7 @@ yydefault: case 1935: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12703 +//line mysql_sql.y:12711 { locale := "" yyLOCAL = &tree.T{ @@ -27525,7 +27575,7 @@ yydefault: case 1936: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12716 +//line mysql_sql.y:12724 { locale := "" yyLOCAL = &tree.T{ @@ -27542,7 +27592,7 @@ yydefault: case 1937: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12729 +//line mysql_sql.y:12737 { locale := "" yyLOCAL = &tree.T{ @@ -27558,7 +27608,7 @@ yydefault: case 1938: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12741 +//line mysql_sql.y:12749 { locale := "" yyLOCAL = &tree.T{ @@ -27574,7 +27624,7 @@ yydefault: case 1939: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12753 +//line mysql_sql.y:12761 { locale := "" yyLOCAL = &tree.T{ @@ -27590,7 +27640,7 @@ yydefault: case 1940: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12765 +//line mysql_sql.y:12773 { locale := "" yyLOCAL = &tree.T{ @@ -27606,7 +27656,7 @@ yydefault: case 1941: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12777 +//line mysql_sql.y:12785 { locale := "" yyLOCAL = &tree.T{ @@ -27622,7 +27672,7 @@ yydefault: case 1942: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12789 +//line mysql_sql.y:12797 { locale := "" yyLOCAL = &tree.T{ @@ -27638,7 +27688,7 @@ yydefault: case 1943: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12801 +//line mysql_sql.y:12809 { locale := "" yyLOCAL = &tree.T{ @@ -27654,7 +27704,7 @@ yydefault: case 1944: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12813 +//line mysql_sql.y:12821 { locale := "" yyLOCAL = &tree.T{ @@ -27670,7 +27720,7 @@ yydefault: case 1945: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12825 +//line mysql_sql.y:12833 { locale := "" yyLOCAL = &tree.T{ @@ -27686,7 +27736,7 @@ yydefault: case 1946: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12837 +//line mysql_sql.y:12845 { locale := "" yyLOCAL = &tree.T{ @@ -27702,7 +27752,7 @@ yydefault: case 1947: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12849 +//line mysql_sql.y:12857 { locale := "" yyLOCAL = &tree.T{ @@ -27719,7 +27769,7 @@ yydefault: case 1948: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12862 +//line mysql_sql.y:12870 { locale := "" yyLOCAL = &tree.T{ @@ -27736,7 +27786,7 @@ yydefault: case 1949: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12875 +//line mysql_sql.y:12883 { locale := "" yyLOCAL = &tree.T{ @@ -27753,7 +27803,7 @@ yydefault: case 1950: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12888 +//line mysql_sql.y:12896 { locale := "" yyLOCAL = &tree.T{ @@ -27770,7 +27820,7 @@ yydefault: case 1951: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12901 +//line mysql_sql.y:12909 { locale := "" yyLOCAL = &tree.T{ @@ -27787,7 +27837,7 @@ yydefault: case 1952: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL tree.Statement -//line mysql_sql.y:12916 +//line mysql_sql.y:12924 { yyLOCAL = &tree.Do{ Exprs: yyDollar[2].exprsUnion(), @@ -27797,7 +27847,7 @@ yydefault: case 1953: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL tree.Statement -//line mysql_sql.y:12924 +//line mysql_sql.y:12932 { yyLOCAL = &tree.Declare{ Variables: yyDollar[2].strsUnion(), @@ -27809,7 +27859,7 @@ yydefault: case 1954: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL tree.Statement -//line mysql_sql.y:12933 +//line mysql_sql.y:12941 { yyLOCAL = &tree.Declare{ Variables: yyDollar[2].strsUnion(), @@ -27821,7 +27871,7 @@ yydefault: case 1955: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *tree.T -//line mysql_sql.y:12943 +//line mysql_sql.y:12951 { locale := "" yyLOCAL = &tree.T{ @@ -27835,74 +27885,186 @@ yydefault: } yyVAL.union = yyLOCAL case 1956: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:12963 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1957: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:12975 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1958: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:12987 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1959: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:12999 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1960: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:13011 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1961: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:13023 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1962: + yyDollar = yyS[yypt-1 : yypt+1] + var yyLOCAL *tree.T +//line mysql_sql.y:13035 + { + locale := "" + yyLOCAL = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: yyDollar[1].str, + Locale: &locale, + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } + yyVAL.union = yyLOCAL + case 1963: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []string -//line mysql_sql.y:12966 +//line mysql_sql.y:13051 { yyLOCAL = make([]string, 0, 4) yyLOCAL = append(yyLOCAL, yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1957: + case 1964: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []string -//line mysql_sql.y:12971 +//line mysql_sql.y:13056 { yyLOCAL = append(yyDollar[1].strsUnion(), yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1958: + case 1965: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:12977 +//line mysql_sql.y:13062 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1960: + case 1967: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:12984 +//line mysql_sql.y:13069 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1961: + case 1968: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:12988 +//line mysql_sql.y:13073 { yyLOCAL = int32(yyDollar[2].item.(int64)) } yyVAL.union = yyLOCAL - case 1962: + case 1969: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:12993 +//line mysql_sql.y:13078 { yyLOCAL = int32(-1) } yyVAL.union = yyLOCAL - case 1963: + case 1970: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:12997 +//line mysql_sql.y:13082 { yyLOCAL = int32(yyDollar[2].item.(int64)) } yyVAL.union = yyLOCAL - case 1964: + case 1971: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int32 -//line mysql_sql.y:13003 +//line mysql_sql.y:13088 { yyLOCAL = tree.GetDisplayWith(int32(yyDollar[2].item.(int64))) } yyVAL.union = yyLOCAL - case 1965: + case 1972: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13009 +//line mysql_sql.y:13094 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: tree.NotDefineDisplayWidth, @@ -27910,10 +28072,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1966: + case 1973: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13016 +//line mysql_sql.y:13101 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: tree.GetDisplayWith(int32(yyDollar[2].item.(int64))), @@ -27921,10 +28083,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1967: + case 1974: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13023 +//line mysql_sql.y:13108 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: tree.GetDisplayWith(int32(yyDollar[2].item.(int64))), @@ -27932,10 +28094,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1968: + case 1975: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13032 +//line mysql_sql.y:13117 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: 38, // this is the default precision for decimal @@ -27943,10 +28105,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1969: + case 1976: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13039 +//line mysql_sql.y:13124 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: tree.GetDisplayWith(int32(yyDollar[2].item.(int64))), @@ -27954,10 +28116,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1970: + case 1977: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL tree.LengthScaleOpt -//line mysql_sql.y:13046 +//line mysql_sql.y:13131 { yyLOCAL = tree.LengthScaleOpt{ DisplayWith: tree.GetDisplayWith(int32(yyDollar[2].item.(int64))), @@ -27965,52 +28127,52 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1971: + case 1978: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line mysql_sql.y:13055 +//line mysql_sql.y:13140 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1972: + case 1979: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line mysql_sql.y:13059 +//line mysql_sql.y:13144 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1973: + case 1980: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line mysql_sql.y:13063 +//line mysql_sql.y:13148 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1974: + case 1981: yyDollar = yyS[yypt-0 : yypt+1] -//line mysql_sql.y:13069 +//line mysql_sql.y:13154 { } - case 1975: + case 1982: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line mysql_sql.y:13071 +//line mysql_sql.y:13156 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1979: + case 1986: yyDollar = yyS[yypt-0 : yypt+1] -//line mysql_sql.y:13081 +//line mysql_sql.y:13166 { yyVAL.str = "" } - case 1980: + case 1987: yyDollar = yyS[yypt-1 : yypt+1] -//line mysql_sql.y:13085 +//line mysql_sql.y:13170 { yyVAL.str = string(yyDollar[1].str) } diff --git a/pkg/sql/parsers/dialect/mysql/mysql_sql.y b/pkg/sql/parsers/dialect/mysql/mysql_sql.y index bd5f399a99000..6d6c289da2b22 100644 --- a/pkg/sql/parsers/dialect/mysql/mysql_sql.y +++ b/pkg/sql/parsers/dialect/mysql/mysql_sql.y @@ -12504,8 +12504,12 @@ decimal_type: yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))") goto ret1 } - if $2.DisplayWith > 38 || $2.DisplayWith < 0 { - yylex.Error("For decimal(M), M must between 0 and 38.") + if $2.Scale > 30 { + yylex.Error("Display scale for decimal out of range (max = 30)") + goto ret1 + } + if $2.DisplayWith > 65 || $2.DisplayWith < 0 { + yylex.Error("For decimal(M), M must between 0 and 65.") goto ret1 } else if $2.DisplayWith <= 16 { $$ = &tree.T{ @@ -12540,8 +12544,12 @@ decimal_type: yylex.Error("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column 'a'))") goto ret1 } - if $2.DisplayWith > 38 || $2.DisplayWith < 0 { - yylex.Error("For decimal(M), M must between 0 and 38.") + if $2.Scale > 30 { + yylex.Error("Display scale for decimal out of range (max = 30)") + goto ret1 + } + if $2.DisplayWith > 65 || $2.DisplayWith < 0 { + yylex.Error("For decimal(M), M must between 0 and 65.") goto ret1 } else if $2.DisplayWith <= 16 { $$ = &tree.T{ @@ -12952,13 +12960,90 @@ spatial_type: }, } } -// | POINT -// | LINESTRING -// | POLYGON -// | GEOMETRYCOLLECTION -// | MULTIPOINT -// | MULTILINESTRING -// | MULTIPOLYGON +| POINT + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| LINESTRING + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| POLYGON + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| GEOMETRYCOLLECTION + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| MULTIPOINT + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| MULTILINESTRING + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } +| MULTIPOLYGON + { + locale := "" + $$ = &tree.T{ + InternalType: tree.InternalType{ + Family: tree.GeometryFamily, + FamilyString: $1, + Locale: &locale, + Oid:uint32(defines.MYSQL_TYPE_GEOMETRY), + }, + } + } // TODO: // need to encode SQL string diff --git a/pkg/sql/parsers/dialect/mysql/mysql_sql_test.go b/pkg/sql/parsers/dialect/mysql/mysql_sql_test.go index 5667e5eddf8f4..211beac17ddb2 100644 --- a/pkg/sql/parsers/dialect/mysql/mysql_sql_test.go +++ b/pkg/sql/parsers/dialect/mysql/mysql_sql_test.go @@ -142,6 +142,46 @@ func TestDataBranchDiffColumns(t *testing.T) { require.Nil(t, diffStmt.OutputOpt) } +func TestDecimalPrecisionUpTo65(t *testing.T) { + _, err := ParseOne(context.TODO(), "create table t (a decimal(65,30), b numeric(39,0))", 1) + require.NoError(t, err) + + _, err = ParseOne(context.TODO(), "create table t (a decimal(40,39))", 1) + require.Error(t, err) + require.Contains(t, err.Error(), "Display scale for decimal out of range (max = 30)") + + _, err = ParseOne(context.TODO(), "create table t (a numeric(40,39))", 1) + require.Error(t, err) + require.Contains(t, err.Error(), "Display scale for decimal out of range (max = 30)") +} + +func TestSpatialSubtypeColumnTypes(t *testing.T) { + tests := []string{ + "POINT", + "LINESTRING", + "POLYGON", + "GEOMETRYCOLLECTION", + "MULTIPOINT", + "MULTILINESTRING", + "MULTIPOLYGON", + } + + for _, subtype := range tests { + t.Run(subtype, func(t *testing.T) { + stmt, err := ParseOne(context.TODO(), "create table t (g "+subtype+")", 1) + require.NoError(t, err) + + createTable, ok := stmt.(*tree.CreateTable) + require.True(t, ok) + col, ok := createTable.Defs[0].(*tree.ColumnTableDef) + require.True(t, ok) + colType, ok := col.Type.(*tree.T) + require.True(t, ok) + require.Equal(t, subtype, colType.InternalType.FamilyString) + }) + } +} + func getFuncExprsFromSelect(t *testing.T, sql string) []*tree.FuncExpr { t.Helper() diff --git a/pkg/sql/plan/base_binder.go b/pkg/sql/plan/base_binder.go index ba41359e42c3f..d81c3710694c9 100644 --- a/pkg/sql/plan/base_binder.go +++ b/pkg/sql/plan/base_binder.go @@ -2052,7 +2052,7 @@ func (b *baseBinder) bindNumVal(astExpr *tree.NumVal, typ Type) (*Expr, error) { } d128, scale, err := types.Parse128(astExpr.String()) if err != nil { - return nil, err + return makePlan2DecimalExprWithType(b.GetContext(), astExpr.String()) } a := int64(d128.B0_63) b := int64(d128.B64_127) diff --git a/pkg/sql/plan/build_alter_table.go b/pkg/sql/plan/build_alter_table.go index 0f508cf589815..b41fd6e06e4f1 100644 --- a/pkg/sql/plan/build_alter_table.go +++ b/pkg/sql/plan/build_alter_table.go @@ -316,8 +316,8 @@ func buildAlterInsertDataSQL( } insertSQL := fmt.Sprintf("INSERT INTO `%s`.`%s` (%s) SELECT %s FROM `%s`.`%s`", - formatStr(schemaName), formatStr(copyTableName), insertBuffer.String(), - selectBuffer.String(), formatStr(schemaName), formatStr(originTableName)) + formatIdent(schemaName), formatIdent(copyTableName), insertBuffer.String(), + selectBuffer.String(), formatIdent(schemaName), formatIdent(originTableName)) return insertSQL, nil } diff --git a/pkg/sql/plan/build_ddl.go b/pkg/sql/plan/build_ddl.go index 0cbfcc7cee8f5..d26e839451db6 100644 --- a/pkg/sql/plan/build_ddl.go +++ b/pkg/sql/plan/build_ddl.go @@ -747,8 +747,8 @@ func buildCreateTable( var err error oldTable := stmt.LikeTableName newTable := stmt.Table - tblName := formatStr(string(oldTable.ObjectName)) - dbName := formatStr(string(oldTable.SchemaName)) + tblName := formatIdent(string(oldTable.ObjectName)) + dbName := formatIdent(string(oldTable.SchemaName)) var snapshot *Snapshot snapshot = ctx.GetSnapshot() diff --git a/pkg/sql/plan/build_show.go b/pkg/sql/plan/build_show.go index 2a4cda4cd30b3..d2e6389599af4 100644 --- a/pkg/sql/plan/build_show.go +++ b/pkg/sql/plan/build_show.go @@ -15,7 +15,6 @@ package plan import ( - "bytes" "context" "encoding/json" "fmt" @@ -38,6 +37,24 @@ const MO_DEFUALT_HOSTNAME = "localhost" const INFORMATION_SCHEMA = "information_schema" const SYSMOCATALOGPITR = "sys_mo_catalog_pitr" +// escapeForDoubleQuotedLiteral prepares s for embedding inside a +// double-quoted MySQL string literal (`"..."`). Both backslashes and +// double quotes are escaped so every byte survives the outer scanner +// pass verbatim. Order matters: backslashes must be doubled first, +// otherwise the `\"` inserted for each `"` would be re-escaped and +// produce a spurious extra backslash on round-trip. +// +// Used by SHOW CREATE {TABLE,VIEW} which wrap the generated DDL text +// inside a SELECT ... AS projection so the result set columns can be +// streamed back to the client; the DDL already carries literal +// backslashes (formatStrLit, column-comment path) that must not be +// re-interpreted by the scanner. +func escapeForDoubleQuotedLiteral(s string) string { + s = strings.ReplaceAll(s, "\\", "\\\\") + s = strings.ReplaceAll(s, "\"", "\\\"") + return s +} + func buildShowCreateDatabase(stmt *tree.ShowCreateDatabase, ctx CompilerContext) (*Plan, error) { @@ -76,7 +93,7 @@ func buildShowCreateDatabase(stmt *tree.ShowCreateDatabase, sqlStr := "SELECT \"%s\" AS `Database`, \"%s\" AS `Create Database`" createSql := fmt.Sprintf("CREATE DATABASE `%s`", name) - sqlStr = fmt.Sprintf(sqlStr, name, createSql) + sqlStr = fmt.Sprintf(sqlStr, escapeForDoubleQuotedLiteral(name), escapeForDoubleQuotedLiteral(createSql)) return returnByRewriteSQL(ctx, sqlStr, plan.DataDefinition_SHOW_CREATEDATABASE) } @@ -138,18 +155,8 @@ func buildShowCreateTable(stmt *tree.ShowCreateTable, ctx CompilerContext) (*Pla return nil, err } - var buf bytes.Buffer - for i, ch := range ddlStr { - // escape double quote, for the sql pattern below - if ch == '"' { - if i == 0 || ddlStr[i-1] != '\\' { - buf.WriteRune('"') - } - } - buf.WriteRune(ch) - } sql := "SELECT \"%s\" AS `Table`, \"%s\" AS `Create Table`" - sql = fmt.Sprintf(sql, tblName, buf.String()) + sql = fmt.Sprintf(sql, escapeForDoubleQuotedLiteral(tblName), escapeForDoubleQuotedLiteral(ddlStr)) return returnByRewriteSQL(ctx, sql, plan.DataDefinition_SHOW_CREATETABLE) } @@ -207,8 +214,7 @@ func buildShowCreateView(stmt *tree.ShowCreateView, ctx CompilerContext) (*Plan, stmtStr = stmtStr[:viewIdx] + "SQL SECURITY " + securityType + " " + stmtStr[viewIdx:] } } - stmtStr = strings.ReplaceAll(stmtStr, "\"", "\\\"") - sqlStr = fmt.Sprintf(sqlStr, tblName, fmt.Sprint(stmtStr)) + sqlStr = fmt.Sprintf(sqlStr, escapeForDoubleQuotedLiteral(tblName), escapeForDoubleQuotedLiteral(stmtStr)) // logutil.Info(sqlStr) diff --git a/pkg/sql/plan/build_show_util.go b/pkg/sql/plan/build_show_util.go index c0e72eb21efbe..e139a4d6d61cb 100644 --- a/pkg/sql/plan/build_show_util.go +++ b/pkg/sql/plan/build_show_util.go @@ -44,9 +44,9 @@ func ConstructCreateTableSQL( tblName := tableDef.Name schemaName := tableDef.DbName - dbTblName := fmt.Sprintf("`%s`", formatStr(tblName)) + dbTblName := fmt.Sprintf("`%s`", formatIdent(tblName)) if useDbName { - dbTblName = fmt.Sprintf("`%s`.`%s`", formatStr(schemaName), formatStr(tblName)) + dbTblName = fmt.Sprintf("`%s`.`%s`", formatIdent(schemaName), formatIdent(tblName)) } if tableDef.TableType == catalog.SystemOrdinaryRel { @@ -100,12 +100,18 @@ func ConstructCreateTableSQL( } typeStr := FormatColType(col.Typ) + // SET and ENUM carry case-sensitive member names in their type string + // (e.g. SET('Read','Write')); lower-casing the whole thing would + // change the members themselves, which is a correctness bug. Only + // lower-case the leading type keyword. if strings.HasPrefix(typeStr, "ENUM") { typeStr = strings.ToLower(typeStr[:4]) + typeStr[4:] + } else if strings.HasPrefix(typeStr, "SET") { + typeStr = strings.ToLower(typeStr[:3]) + typeStr[3:] } else { typeStr = strings.ToLower(typeStr) } - fmt.Fprintf(buf, " `%s` %s", formatStr(colNameOrigin), typeStr) + fmt.Fprintf(buf, " `%s` %s", formatIdent(colNameOrigin), typeStr) //------------------------------------------------------------------------------------------------------------- if col.Typ.AutoIncr { @@ -124,7 +130,10 @@ func ConstructCreateTableSQL( buf.WriteString(" DEFAULT NULL") } } else if len(col.Default.OriginString) > 0 { - buf.WriteString(" DEFAULT " + formatStr(col.Default.OriginString)) + // OriginString is free-form SQL text reconstructed from the + // AST (e.g. concat(`col`, 'x')). It is already valid SQL — + // emit it verbatim; do not re-escape backticks or quotes. + buf.WriteString(" DEFAULT " + col.Default.OriginString) } if col.OnUpdate != nil && col.OnUpdate.Expr != nil { @@ -133,7 +142,15 @@ func ConstructCreateTableSQL( } if col.Comment != "" { - buf.WriteString(" COMMENT '" + col.Comment + "'") + // col.Comment has already been passed through + // util.DealCommentString at parse time (see AttributeComment + // production in mysql_sql.y), so any embedded single quote + // is stored in pre-doubled MySQL string-literal form. + // Backslashes still need escaping: the MySQL scanner interprets + // \n, \t, \\ etc. inside string literals, so a raw backslash + // must be emitted as \\ to round-trip correctly. + escaped := strings.ReplaceAll(col.Comment, "\\", "\\\\") + buf.WriteString(" COMMENT '" + escaped + "'") } createStr += buf.String() @@ -153,9 +170,9 @@ func ConstructCreateTableSQL( for i, def := range pkDefs { def = colNameToOriginName[def] if i == len(pkDefs)-1 { - pkStr += fmt.Sprintf("`%s`)", formatStr(def)) + pkStr += fmt.Sprintf("`%s`)", formatIdent(def)) } else { - pkStr += fmt.Sprintf("`%s`,", formatStr(def)) + pkStr += fmt.Sprintf("`%s`,", formatIdent(def)) } } if rowCount != 0 { @@ -185,7 +202,7 @@ func ConstructCreateTableSQL( indexStr += " FULLTEXT " if len(indexdef.IndexName) > 0 { - indexStr += fmt.Sprintf("`%s`", formatStr(indexdef.IndexName)) + indexStr += fmt.Sprintf("`%s`", formatIdent(indexdef.IndexName)) } indexStr += "(" i := 0 @@ -198,7 +215,7 @@ func ConstructCreateTableSQL( } part = colNameToOriginName[part] - indexStr += fmt.Sprintf("`%s`", formatStr(part)) + indexStr += fmt.Sprintf("`%s`", formatIdent(part)) i++ } @@ -221,7 +238,7 @@ func ConstructCreateTableSQL( } else { indexStr = " KEY " } - indexStr += fmt.Sprintf("`%s` ", formatStr(indexdef.IndexName)) + indexStr += fmt.Sprintf("`%s` ", formatIdent(indexdef.IndexName)) if !catalog.IsNullIndexAlgo(indexdef.IndexAlgo) { indexStr += fmt.Sprintf("USING %s ", indexdef.IndexAlgo) } @@ -236,7 +253,7 @@ func ConstructCreateTableSQL( } part = colNameToOriginName[part] - indexStr += fmt.Sprintf("`%s`", formatStr(part)) + indexStr += fmt.Sprintf("`%s`", formatIdent(part)) i++ } @@ -251,8 +268,7 @@ func ConstructCreateTableSQL( } } if indexdef.Comment != "" { - indexdef.Comment = strings.Replace(indexdef.Comment, "'", "\\'", -1) - indexStr += fmt.Sprintf(" COMMENT '%s'", formatStr(indexdef.Comment)) + indexStr += " COMMENT " + formatStrLit(indexdef.Comment) } if rowCount != 0 { createStr += ",\n" @@ -378,12 +394,12 @@ func ConstructCreateTableSQL( createStr += ",\n" } - fkRefDbTblName := fmt.Sprintf("`%s`", formatStr(fkTableDef.Name)) + fkRefDbTblName := fmt.Sprintf("`%s`", formatIdent(fkTableDef.Name)) if cloneStmt != nil || tableDef.DbName != fkTableDef.DbName { - fkRefDbTblName = fmt.Sprintf("`%s`.`%s`", formatStr(fkTableDef.DbName), formatStr(fkTableDef.Name)) + fkRefDbTblName = fmt.Sprintf("`%s`.`%s`", formatIdent(fkTableDef.DbName), formatIdent(fkTableDef.Name)) } createStr += fmt.Sprintf(" CONSTRAINT `%s` FOREIGN KEY (`%s`) REFERENCES %s (`%s`) ON DELETE %s ON UPDATE %s", - formatStr(fk.Name), strings.Join(colOriginNames, "`,`"), fkRefDbTblName, strings.Join(fkColOriginNames, "`,`"), strings.ReplaceAll(fk.OnDelete.String(), "_", " "), strings.ReplaceAll(fk.OnUpdate.String(), "_", " ")) + formatIdent(fk.Name), strings.Join(colOriginNames, "`,`"), fkRefDbTblName, strings.Join(fkColOriginNames, "`,`"), strings.ReplaceAll(fk.OnDelete.String(), "_", " "), strings.ReplaceAll(fk.OnUpdate.String(), "_", " ")) } if rowCount != 0 { @@ -396,7 +412,13 @@ func ConstructCreateTableSQL( if proDef, ok := def.Def.(*plan.TableDef_DefType_Properties); ok { for _, kv := range proDef.Properties.Properties { if kv.Key == catalog.SystemRelAttr_Comment { - comment = " COMMENT='" + kv.Value + "'" + // Like col.Comment, the table-level comment stored in + // kv.Value has already been DealCommentString'd at parse + // time, so it is in pre-doubled MySQL string-literal + // form. Backslashes still need escaping for the MySQL + // scanner to round-trip correctly. + escaped := strings.ReplaceAll(kv.Value, "\\", "\\\\") + comment = " COMMENT='" + escaped + "'" } } } @@ -461,14 +483,14 @@ func ConstructCreateTableSQL( cbNames := util.SplitCompositeClusterByColumnName(tableDef.ClusterBy.Name) for i, cbName := range cbNames { if i != 0 { - clusterby += fmt.Sprintf(", `%s`", formatStr(cbName)) + clusterby += fmt.Sprintf(", `%s`", formatIdent(cbName)) } else { - clusterby += fmt.Sprintf("`%s`", formatStr(cbName)) + clusterby += fmt.Sprintf("`%s`", formatIdent(cbName)) } } } else { //single column cluster by - clusterby += fmt.Sprintf("`%s`", formatStr(tableDef.ClusterBy.Name)) + clusterby += fmt.Sprintf("`%s`", formatIdent(tableDef.ClusterBy.Name)) } clusterby += ")" createStr += clusterby @@ -488,8 +510,13 @@ func ConstructCreateTableSQL( return "", nil, err } } - // hide file path - createStr += fmt.Sprintf(" INFILE{'FILEPATH'='','COMPRESSION'='%s','FORMAT'='%s','JSONDATA'='%s'}", param.CompressType, param.Format, param.JsonData) + // hide file path. INFILE{} option values must be single-quote-escaped + // per MySQL string-literal rules; users can legitimately put a quote + // in CompressType/Format/JsonData metadata. + createStr += " INFILE{'FILEPATH'=''," + + "'COMPRESSION'=" + formatStrLit(param.CompressType) + "," + + "'FORMAT'=" + formatStrLit(param.Format) + "," + + "'JSONDATA'=" + formatStrLit(param.JsonData) + "}" fields := "" if param.Tail != nil && param.Tail.Fields != nil { @@ -497,37 +524,31 @@ func ConstructCreateTableSQL( if param.Tail.Fields.Terminated.Value == "" { fields += " TERMINATED BY \"\"" } else { - fields += fmt.Sprintf(" TERMINATED BY '%s'", param.Tail.Fields.Terminated.Value) + fields += " TERMINATED BY " + formatStrLit(param.Tail.Fields.Terminated.Value) } } escape := func(value byte) string { if value == byte(0) { return "" - } else if value == byte('\\') { - return "\\\\" } return fmt.Sprintf("%c", value) } if param.Tail.Fields.EnclosedBy != nil { - fields += " ENCLOSED BY '" + escape(param.Tail.Fields.EnclosedBy.Value) + "'" + fields += " ENCLOSED BY " + formatStrLit(escape(param.Tail.Fields.EnclosedBy.Value)) } if param.Tail.Fields.EscapedBy != nil { - fields += " ESCAPED BY '" + escape(param.Tail.Fields.EscapedBy.Value) + "'" + fields += " ESCAPED BY " + formatStrLit(escape(param.Tail.Fields.EscapedBy.Value)) } } line := "" if param.Tail != nil && param.Tail.Lines != nil { if param.Tail.Lines.StartingBy != "" { - line += fmt.Sprintf(" STARTING BY '%s'", param.Tail.Lines.StartingBy) + line += " STARTING BY " + formatStrLit(param.Tail.Lines.StartingBy) } if param.Tail.Lines.TerminatedBy != nil { - if param.Tail.Lines.TerminatedBy.Value == "\n" || param.Tail.Lines.TerminatedBy.Value == "\r\n" { - line += " TERMINATED BY '\\\\n'" - } else { - line += fmt.Sprintf(" TERMINATED BY '%s'", param.Tail.Lines.TerminatedBy) - } + line += " TERMINATED BY " + formatStrLit(param.Tail.Lines.TerminatedBy.Value) } } @@ -560,11 +581,17 @@ func FormatColType(colType plan.Type) string { if typ.Oid.IsDecimal() { ts = "DECIMAL" } + if isSetPlanType(&colType) { + ts = "SET" + } + if subtype := geometrySubtypeName(&colType); subtype != "" { + ts = subtype + } suffix := "" switch types.T(colType.Id) { - case types.T_enum: //types.T_set: - elements := strings.Split(colType.GetEnumvalues(), ",") + case types.T_enum: + elements, _ := types.DecodeEnumValues(colType.GetEnumvalues()) // format enum as ENUM ('e1', 'e2') elems := make([]string, 0, len(elements)) for _, e := range elements { @@ -572,6 +599,20 @@ func FormatColType(colType plan.Type) string { elems = append(elems, e) } suffix = fmt.Sprintf("('%s')", strings.Join(elems, "','")) + case types.T_uint64: + if !isEnumOrSetPlanType(&colType) { + break + } + elements, err := types.DecodeSetValues(colType.GetEnumvalues()) + if err != nil { + elements = strings.Split(colType.GetEnumvalues(), ",") + } + elems := make([]string, 0, len(elements)) + for _, e := range elements { + e = EscapeFormat(e) + elems = append(elems, e) + } + suffix = fmt.Sprintf("('%s')", strings.Join(elems, "','")) case types.T_timestamp, types.T_datetime, types.T_time: if colType.Width > 0 { @@ -597,11 +638,17 @@ func FormatColType(colType plan.Type) string { } // Character replace mapping maps certain special characters to their escape sequences. +// Backslash must be doubled first (conceptually, though map iteration order is +// irrelevant because EscapeFormat walks the input exactly once): if it is left +// bare, a round-trip through the MySQL scanner collapses \ to the unescaped +// form (e.g. "a\b" re-parses as "a" + 0x08, not "a\\b"), silently mutating +// ENUM/SET member values. var replaceMap = map[rune]string{ '\000': "\\0", '\'': "''", '\n': "\\n", '\r': "\\r", + '\\': "\\\\", } // EscapeFormat output escape character with backslash. @@ -617,16 +664,50 @@ func EscapeFormat(s string) string { return buf.String() } -func formatStr(str string) string { - tmp := strings.Replace(str, "`", "``", -1) - strLen := len(tmp) - if strLen < 2 { - return tmp - } - if tmp[0] == '\'' && tmp[strLen-1] == '\'' { - return "'" + strings.Replace(tmp[1:strLen-1], "'", "''", -1) + "'" +// formatIdent escapes a string for use inside a backtick-quoted identifier, +// i.e. when the caller wraps the result in `...`. Embedded backticks are +// doubled per MySQL's identifier-quoting rules. +// +// Do NOT use this on free-form SQL text (e.g. an expression default like +// concat(`col`, 'x')) — that text is not inside a backtick-quoted identifier +// and doubling interior backticks corrupts the original SQL. +func formatIdent(s string) string { + return strings.ReplaceAll(s, "`", "``") +} + +// formatStrLit returns s as a MySQL single-quoted string literal with both +// backslashes and single quotes escaped so the output round-trips through +// the parser unchanged. The MySQL scanner treats \ as an escape — \b +// becomes 0x08, \n becomes newline, etc. — so a value containing a literal +// backslash must be emitted as \\ or the re-parsed result mutates. +// +// NOTE: this helper is for call sites whose input is *raw* text. Column +// and table comments are stored in pre-quote-escaped form +// (util.DealCommentString doubles ' at parse time) and go through a plain +// '...' concatenation instead; do not switch them to this helper without +// also rethinking the pre-escape contract. +func formatStrLit(s string) string { + var buf strings.Builder + buf.Grow(len(s) + 2) + buf.WriteByte('\'') + for i := 0; i < len(s); i++ { + switch s[i] { + case '\\': + buf.WriteString("\\\\") + case '\'': + buf.WriteString("''") + case '\n': + buf.WriteString("\\n") + case '\r': + buf.WriteString("\\r") + case '\x00': + buf.WriteString("\\0") + default: + buf.WriteByte(s[i]) + } } - return strings.Replace(tmp, "'", "''", -1) + buf.WriteByte('\'') + return buf.String() } func getTimeStampByTsHint(ctx CompilerContext, AtTsExpr *tree.AtTimeStamp) (snapshot *plan.Snapshot, err error) { diff --git a/pkg/sql/plan/build_show_util_test.go b/pkg/sql/plan/build_show_util_test.go index f0ad0e4ce9a6a..1164f58632fa2 100644 --- a/pkg/sql/plan/build_show_util_test.go +++ b/pkg/sql/plan/build_show_util_test.go @@ -15,12 +15,15 @@ package plan import ( + "context" + "fmt" "strings" "testing" "github.com/matrixorigin/matrixone/pkg/catalog" "github.com/matrixorigin/matrixone/pkg/pb/plan" "github.com/matrixorigin/matrixone/pkg/sql/parsers/dialect/mysql" + "github.com/matrixorigin/matrixone/pkg/sql/parsers/tree" "github.com/stretchr/testify/require" ) @@ -236,3 +239,218 @@ func buildTestShowCreateTable(sql string) (string, error) { } return showSQL, nil } + +// formatIdent and formatStrLit split the old formatStr responsibilities. +// Identifier escape (backticks -> doubled backticks), string literal escape +// (single quotes -> doubled quotes). Free-form expression text is never +// passed through either — callers emit it verbatim. +func TestFormatIdentEscapesBackticks(t *testing.T) { + require.Equal(t, "a``b", formatIdent("a`b")) + require.Equal(t, "plain", formatIdent("plain")) + // Must not treat single quotes specially — they are allowed inside an + // identifier name. + require.Equal(t, "o'brien", formatIdent("o'brien")) +} + +func TestFormatStrLitEscapesSingleQuotes(t *testing.T) { + require.Equal(t, "'o''brien'", formatStrLit("o'brien")) + require.Equal(t, "''", formatStrLit("")) + // Backticks are NOT doubled inside a string literal. + require.Equal(t, "'a`b'", formatStrLit("a`b")) + // Multiple interior quotes must all be doubled. + require.Equal(t, "'''hi''there'''", formatStrLit("'hi'there'")) +} + +// TestFormatStrLitEscapesBackslashes pins the round-trip contract for raw +// strings that contain a literal backslash. The MySQL scanner collapses +// \b / \n / \r / \t / \Z / \0 into their control-char equivalents, so a +// value like "a\b" must be emitted as 'a\\b' — otherwise re-parsing the +// SHOW CREATE output silently turns it into "a" + 0x08. +func TestFormatStrLitEscapesBackslashes(t *testing.T) { + require.Equal(t, `'a\\b'`, formatStrLit(`a\b`)) + // Combined quote + backslash still escapes both. + require.Equal(t, `'o''\\brien'`, formatStrLit(`o'\brien`)) +} + +// TestEscapeFormatEscapesBackslashes guards the ENUM/SET member formatter. +// A SET member declared as SET('a\\b') is stored with one literal backslash; +// the old EscapeFormat replaceMap did not include '\\' -> "\\\\", so +// FormatColType emitted SET('a\b'), which re-parses as "a" + 0x08. +func TestEscapeFormatEscapesBackslashes(t *testing.T) { + require.Equal(t, `a\\b`, EscapeFormat(`a\b`)) +} + +func TestCommentBackslashEscape(t *testing.T) { + colDef := &plan.ColDef{ + Name: "c1", + Comment: `path\to\file`, + Typ: plan.Type{Id: int32(22)}, // T_int32 + Default: &plan.Default{NullAbility: true}, + } + tableDef := &plan.TableDef{ + Name: "t_comment", + TableType: catalog.SystemOrdinaryRel, + Cols: []*plan.ColDef{colDef}, + } + mock := NewMockOptimizer(false) + got, _, err := ConstructCreateTableSQL(&mock.ctxt, tableDef, nil, false, nil) + require.NoError(t, err) + require.Contains(t, got, `COMMENT 'path\\to\\file'`) +} + +func TestTableCommentBackslashEscape(t *testing.T) { + colDef := &plan.ColDef{ + Name: "c1", + Typ: plan.Type{Id: int32(22)}, // T_int32 + Default: &plan.Default{NullAbility: true}, + } + tableDef := &plan.TableDef{ + Name: "t_tbl_comment", + TableType: catalog.SystemOrdinaryRel, + Cols: []*plan.ColDef{colDef}, + Defs: []*plan.TableDef_DefType{ + { + Def: &plan.TableDef_DefType_Properties{ + Properties: &plan.PropertiesDef{ + Properties: []*plan.Property{ + {Key: catalog.SystemRelAttr_Comment, Value: `back\slash`}, + }, + }, + }, + }, + }, + } + mock := NewMockOptimizer(false) + got, _, err := ConstructCreateTableSQL(&mock.ctxt, tableDef, nil, false, nil) + require.NoError(t, err) + require.Contains(t, got, `COMMENT='back\\slash'`) +} + +func TestOnUpdateOriginString(t *testing.T) { + colDef := &plan.ColDef{ + Name: "updated_at", + Typ: plan.Type{Id: int32(53)}, // T_timestamp + Default: &plan.Default{ + NullAbility: true, + OriginString: "CURRENT_TIMESTAMP()", + }, + OnUpdate: &plan.OnUpdate{ + Expr: &plan.Expr{}, + OriginString: "CURRENT_TIMESTAMP()", + }, + } + tableDef := &plan.TableDef{ + Name: "t_on_update", + TableType: catalog.SystemOrdinaryRel, + Cols: []*plan.ColDef{colDef}, + } + mock := NewMockOptimizer(false) + got, _, err := ConstructCreateTableSQL(&mock.ctxt, tableDef, nil, false, nil) + require.NoError(t, err) + require.Contains(t, got, "ON UPDATE CURRENT_TIMESTAMP()") +} + +func TestFormatStrLitBackslashNoDoubleEscape(t *testing.T) { + require.Equal(t, `'\\'`, formatStrLit(`\`)) + require.Equal(t, `'"'`, formatStrLit(`"`)) +} + +func TestFormatStrLitCRLF(t *testing.T) { + require.Equal(t, `'\r\n'`, formatStrLit("\r\n")) + require.Equal(t, `'\n'`, formatStrLit("\n")) + require.NotEqual(t, formatStrLit("\n"), formatStrLit("\r\n")) +} + +func TestFormatStrLitNUL(t *testing.T) { + require.Equal(t, `'\0'`, formatStrLit("\x00")) +} + +// TestShowCreateSetMemberCasePreservation verifies the SHOW CREATE column +// loop only lower-cases the leading "SET" keyword and keeps the declared +// member-name case, so SET('Read','Write') round-trips as set('Read','Write') +// instead of set('read','write'). +func TestShowCreateSetMemberCasePreservation(t *testing.T) { + setType := plan.Type{Id: int32(28), Enumvalues: "Read,Write"} // T_uint64 with SET members + raw := FormatColType(setType) + require.Equal(t, "SET('Read','Write')", raw) + + // Mirror the branch added to build_show_util.go: lower-case only the + // type keyword, keep members intact. + lowered := strings.ToLower(raw[:3]) + raw[3:] + require.Equal(t, "set('Read','Write')", lowered) + require.NotEqual(t, strings.ToLower(raw), lowered, + "plain strings.ToLower would damage member names; keep the fix in place") +} + +// TestEscapeForDoubleQuotedLiteralRoundTrip covers the outer wrapper in +// buildShowCreateTable / buildShowCreateView. The DDL text carries +// literal backslashes and double quotes (e.g. from comments like +// `异常描述[\"..\"]`); when it is spliced into `SELECT "..." AS ...` +// both must survive the outer scanner pass. The MySQL scanner folds +// `\\` to `\` and `\"` to `"`, so the helper must emit both escapes. +func TestEscapeForDoubleQuotedLiteralRoundTrip(t *testing.T) { + cases := []string{ + `plain`, + `path\to\file`, + `has "quote" inside`, + `mixed \" and \\`, + // The actual payload from BVT comment.sql row 132/237: + `COMMENT '异常描述[\"表面有磨损\",\"表面有裂痕\"]'`, + // A single trailing backslash — must not collapse into the + // closing quote of the outer literal. + `tail\`, + ``, + } + for _, in := range cases { + escaped := escapeForDoubleQuotedLiteral(in) + wrapped := `"` + escaped + `"` + // Run through the same scanner pipeline the server uses. + toks, err := mysql.Parse(context.Background(), + "SELECT "+wrapped+" AS x", 1) + require.NoErrorf(t, err, "input=%q wrapped=%q", in, wrapped) + require.Len(t, toks, 1) + sel, ok := toks[0].(*tree.Select) + require.Truef(t, ok, "unexpected stmt type for input %q", in) + clause, ok := sel.Select.(*tree.SelectClause) + require.True(t, ok) + require.Len(t, clause.Exprs, 1) + numVal, ok := clause.Exprs[0].Expr.(*tree.NumVal) + require.Truef(t, ok, "expected NumVal for %q, got %T", in, clause.Exprs[0].Expr) + require.Equalf(t, in, numVal.String(), "round-trip mismatch for %q", in) + } +} + +// TestShowCreateWrapperEscapesObjectName guards the first "%s" slot in +// the SHOW CREATE DATABASE/TABLE/VIEW wrapper templates. The object name +// is user-controlled (CREATE TABLE `a\"b` is legal) and previously +// flowed into `SELECT "%s" AS ...` verbatim, breaking the outer literal. +// Verify the escape helper neutralizes both " and \. +func TestShowCreateWrapperEscapesObjectName(t *testing.T) { + cases := []string{ + `plain`, + `with"quote`, + `with\backslash`, + `trail\`, + `mix\"both`, + } + for _, name := range cases { + // Reproduce the format string used in buildShowCreateTable + // (same shape as Database/View wrappers for this check). + tmpl := "SELECT \"%s\" AS `Table`, \"%s\" AS `Create Table`" + sql := fmt.Sprintf(tmpl, + escapeForDoubleQuotedLiteral(name), + escapeForDoubleQuotedLiteral("CREATE TABLE `t` (...)")) + + toks, err := mysql.Parse(context.Background(), sql, 1) + require.NoErrorf(t, err, "wrapper must parse for object name %q: %s", name, sql) + require.Len(t, toks, 1) + sel, ok := toks[0].(*tree.Select) + require.True(t, ok) + clause, ok := sel.Select.(*tree.SelectClause) + require.True(t, ok) + require.Len(t, clause.Exprs, 2) + numVal, ok := clause.Exprs[0].Expr.(*tree.NumVal) + require.Truef(t, ok, "expected NumVal for name=%q, got %T", name, clause.Exprs[0].Expr) + require.Equalf(t, name, numVal.String(), "round-trip mismatch for name %q", name) + } +} diff --git a/pkg/sql/plan/build_util.go b/pkg/sql/plan/build_util.go index f40751c08e181..cac933cd162ed 100644 --- a/pkg/sql/plan/build_util.go +++ b/pkg/sql/plan/build_util.go @@ -199,7 +199,12 @@ func getTypeFromAst(ctx context.Context, typ tree.ResolvableTypeReference) (plan return plan.Type{Id: int32(types.T_datetime), Width: n.InternalType.DisplayWith, Scale: n.InternalType.Scale}, nil case defines.MYSQL_TYPE_TIMESTAMP: return plan.Type{Id: int32(types.T_timestamp), Width: n.InternalType.DisplayWith, Scale: n.InternalType.Scale}, nil + case defines.MYSQL_TYPE_YEAR: + return plan.Type{Id: int32(types.T_year), Width: 4}, nil case defines.MYSQL_TYPE_DECIMAL: + if n.InternalType.DisplayWith > 38 { + return plan.Type{Id: int32(types.T_decimal256), Width: n.InternalType.DisplayWith, Scale: n.InternalType.Scale}, nil + } if n.InternalType.DisplayWith > 16 { return plan.Type{Id: int32(types.T_decimal128), Width: n.InternalType.DisplayWith, Scale: n.InternalType.Scale}, nil } @@ -218,6 +223,12 @@ func getTypeFromAst(ctx context.Context, typ tree.ResolvableTypeReference) (plan return plan.Type{Id: int32(types.T_text)}, nil case defines.MYSQL_TYPE_JSON: return plan.Type{Id: int32(types.T_json)}, nil + case defines.MYSQL_TYPE_GEOMETRY: + typ := plan.Type{Id: int32(types.T_geometry)} + if subtype := normalizeGeometrySubtype(n.InternalType.FamilyString); subtype != "" { + typ.Enumvalues = subtype + } + return typ, nil case defines.MYSQL_TYPE_UUID: return plan.Type{Id: int32(types.T_uuid)}, nil case defines.MYSQL_TYPE_TINY_BLOB: @@ -234,7 +245,13 @@ func getTypeFromAst(ctx context.Context, typ tree.ResolvableTypeReference) (plan return plan.Type{}, moerr.NewNYI(ctx, "enum type length err") } - return plan.Type{Id: int32(types.T_enum), Enumvalues: strings.Join(n.InternalType.EnumValues, ",")}, nil + return plan.Type{Id: int32(types.T_enum), Enumvalues: types.EncodeEnumValues(n.InternalType.EnumValues)}, nil + case defines.MYSQL_TYPE_SET: + setValues, err := types.NormalizeSetValues(n.InternalType.EnumValues) + if err != nil { + return plan.Type{}, err + } + return plan.Type{Id: int32(types.T_uint64), Enumvalues: types.EncodeSetValues(setValues)}, nil default: return plan.Type{}, moerr.NewNYIf(ctx, "data type: '%s'", tree.String(&n.InternalType, dialect.MYSQL)) } @@ -289,6 +306,31 @@ func buildDefaultExpr(col *tree.ColumnTableDef, typ plan.Type, proc *process.Pro } } + fmtCtx := tree.NewFmtCtx(dialect.MYSQL, tree.WithSingleQuoteString()) + fmtCtx.PrintExpr(expr, expr, false) + + // SET columns need SET-aware resolution (match value against the set + // members), not the generic varchar -> uint64 cast that makePlan2CastExpr + // wraps on top of funcCastForSetType. Fold the raw expression first so + // that constant-foldable non-literals like concat('read','') collapse to a + // literal we can hand directly to funcCastForSetType, and reject anything + // that cannot be folded to a constant. + if isSetPlanType(&typ) { + folded, foldErr := ConstantFold(batch.EmptyForConstFoldBatch, DeepCopyExpr(planExpr), proc, false, true) + if foldErr != nil || folded.GetLit() == nil { + return nil, moerr.NewInvalidInputf(proc.Ctx, "invalid default value for column '%s'", colNameOrigin) + } + castedExpr, err := funcCastForSetType(proc.Ctx, folded, typ) + if err != nil { + return nil, err + } + return &plan.Default{ + NullAbility: nullAbility, + Expr: castedExpr, + OriginString: fmtCtx.String(), + }, nil + } + defaultExpr, err := makePlan2CastExpr(proc.Ctx, planExpr, typ) if err != nil { return nil, err @@ -300,8 +342,6 @@ func buildDefaultExpr(col *tree.ColumnTableDef, typ plan.Type, proc *process.Pro return nil, err } - fmtCtx := tree.NewFmtCtx(dialect.MYSQL, tree.WithSingleQuoteString()) - fmtCtx.PrintExpr(expr, expr, false) return &plan.Default{ NullAbility: nullAbility, Expr: newExpr, @@ -329,25 +369,45 @@ func buildOnUpdate(col *tree.ColumnTableDef, typ plan.Type, proc *process.Proces return nil, err } - onUpdateExpr, err := makePlan2CastExpr(proc.Ctx, planExpr, typ) - if err != nil { - return nil, err - } + var onUpdateExpr *plan.Expr - // try to calculate on update value, return err if fails - executor, err := colexec.NewExpressionExecutor(proc, onUpdateExpr) - if err != nil { - return nil, err - } - defer executor.Free() - _, err = executor.Eval(proc, []*batch.Batch{batch.EmptyForConstFoldBatch}, nil) - if err != nil { - return nil, err + if isSetPlanType(&typ) { + // Match the buildDefaultExpr contract for SET: fold to a literal and + // run it through funcCastForSetType so the stored expression resolves + // by set-member lookup, not by generic varchar -> uint64 cast. + folded, foldErr := ConstantFold(batch.EmptyForConstFoldBatch, DeepCopyExpr(planExpr), proc, false, true) + if foldErr != nil || folded.GetLit() == nil { + return nil, moerr.NewInvalidInputf(proc.Ctx, "SET column on-update value must be a constant expression") + } + castedExpr, valErr := funcCastForSetType(proc.Ctx, folded, typ) + if valErr != nil { + return nil, valErr + } + onUpdateExpr = castedExpr + } else { + onUpdateExpr, err = makePlan2CastExpr(proc.Ctx, planExpr, typ) + if err != nil { + return nil, err + } + + // try to calculate on update value, return err if fails + executor, err := colexec.NewExpressionExecutor(proc, onUpdateExpr) + if err != nil { + return nil, err + } + defer executor.Free() + _, err = executor.Eval(proc, []*batch.Batch{batch.EmptyForConstFoldBatch}, nil) + if err != nil { + return nil, err + } } + fmtCtx := tree.NewFmtCtx(dialect.MYSQL, tree.WithSingleQuoteString()) + fmtCtx.PrintExpr(expr, expr, false) + ret := &plan.OnUpdate{ Expr: onUpdateExpr, - OriginString: tree.String(expr, dialect.MYSQL), + OriginString: fmtCtx.String(), } return ret, nil } diff --git a/pkg/sql/plan/build_util_test.go b/pkg/sql/plan/build_util_test.go index ba220d26d22a8..9c78ee1fa572b 100644 --- a/pkg/sql/plan/build_util_test.go +++ b/pkg/sql/plan/build_util_test.go @@ -16,12 +16,18 @@ package plan import ( "context" + "math" "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/matrixorigin/matrixone/pkg/container/types" + "github.com/matrixorigin/matrixone/pkg/defines" "github.com/matrixorigin/matrixone/pkg/pb/plan" + "github.com/matrixorigin/matrixone/pkg/sql/parsers/tree" "github.com/matrixorigin/matrixone/pkg/sql/plan/function" + "github.com/matrixorigin/matrixone/pkg/testutil" ) func Test_replaceFuncId(t *testing.T) { @@ -59,3 +65,472 @@ func Test_replaceFuncId(t *testing.T) { assert.NoError(t, err) assert.NotNil(t, case1Expr) } + +func TestGetTypeFromAstMySQLCompatibilityTypes(t *testing.T) { + ctx := context.Background() + + yearType, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_YEAR), + }}) + require.NoError(t, err) + require.Equal(t, int32(types.T_year), yearType.Id) + require.Equal(t, int32(4), yearType.Width) + + decimalType, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_DECIMAL), + DisplayWith: 65, + Scale: 30, + }}) + require.NoError(t, err) + require.Equal(t, int32(types.T_decimal256), decimalType.Id) + require.Equal(t, int32(65), decimalType.Width) + require.Equal(t, int32(30), decimalType.Scale) + + setType, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_SET), + EnumValues: []string{"read", "write", "execute"}, + }}) + require.NoError(t, err) + require.Equal(t, int32(types.T_uint64), setType.Id) + require.Equal(t, "read,write,execute", setType.Enumvalues) + require.Equal(t, "SET('read','write','execute')", FormatColType(setType)) + + geometryType, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + FamilyString: "geometry", + }}) + require.NoError(t, err) + require.Equal(t, int32(types.T_geometry), geometryType.Id) + require.Equal(t, "GEOMETRY", FormatColType(geometryType)) + + pointType, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_GEOMETRY), + FamilyString: "point", + }}) + require.NoError(t, err) + require.Equal(t, int32(types.T_geometry), pointType.Id) + require.Equal(t, "POINT", pointType.Enumvalues) + require.Equal(t, "POINT", FormatColType(pointType)) +} + +func TestMakePlan2DecimalExprWithTypeUsesDecimal256(t *testing.T) { + expr, err := makePlan2DecimalExprWithType(context.Background(), "123456789012345678901234567890123456789") + require.NoError(t, err) + require.Equal(t, int32(types.T_decimal256), expr.Typ.Id) + require.Equal(t, int32(65), expr.Typ.Width) + require.Equal(t, int32(0), expr.Typ.Scale) +} + +// TestMakePlan2DecimalExprWithTypeMalformedInputNotRecovered verifies that +// when Parse128 fails for a non-range reason (e.g. malformed input), we do +// NOT silently fall through to Parse256 and present its "beyond the range" +// error to the user. The original Decimal128 "illegal string" error is the +// right diagnostic. +func TestMakePlan2DecimalExprWithTypeMalformedInputNotRecovered(t *testing.T) { + _, err := makePlan2DecimalExprWithType(context.Background(), "not-a-number") + require.Error(t, err) + require.Contains(t, err.Error(), "illegal string", + "malformed decimal literal should surface the parser's illegal-string error, not a Decimal256 range error; got %v", err) + require.NotContains(t, err.Error(), "Decimal256", + "malformed decimal literal should not have been retried against Decimal256") +} + +func TestDefaultBinderUntypedDecimalLiteralUsesDecimal256(t *testing.T) { + binder := NewDefaultBinder(context.Background(), nil, nil, plan.Type{}, nil) + decimal := "123456789012345678901234567890123456789" + expr, err := binder.BindExpr(tree.NewNumVal(decimal, decimal, false, tree.P_decimal), 0, true) + require.NoError(t, err) + require.Equal(t, int32(types.T_decimal256), expr.Typ.Id) + require.Equal(t, int32(65), expr.Typ.Width) + require.Equal(t, int32(0), expr.Typ.Scale) +} + +func TestSetDefaultAndOnUpdateUseSetMembers(t *testing.T) { + proc := testutil.NewProcess(t) + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write"} + + defaultCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeDefault{Expr: tree.NewNumVal("read,write", "read,write", false, tree.P_char)}, + }, + ) + defaultValue, err := buildDefaultExpr(defaultCol, setType, proc) + require.NoError(t, err) + require.Equal(t, uint64(3), defaultValue.Expr.GetLit().GetU64Val()) + + onUpdateCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeOnUpdate{Expr: tree.NewNumVal("write", "write", false, tree.P_char)}, + }, + ) + onUpdate, err := buildOnUpdate(onUpdateCol, setType, proc) + require.NoError(t, err) + require.NotNil(t, onUpdate.Expr) +} + +func TestBuildDefaultExprCoversErrorBranches(t *testing.T) { + proc := testutil.NewProcess(t) + + // No default attribute at all: non-null column with nullAbility=true. + noDefaultCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("c"), + nil, + nil, + ) + defaultVal, err := buildDefaultExpr(noDefaultCol, plan.Type{Id: int32(types.T_int32)}, proc) + require.NoError(t, err) + require.Nil(t, defaultVal.Expr) + require.True(t, defaultVal.NullAbility) + + // JSON column with explicit default value is rejected. + jsonCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("c"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeDefault{Expr: tree.NewNumVal("{}", "{}", false, tree.P_char)}, + }, + ) + _, err = buildDefaultExpr(jsonCol, plan.Type{Id: int32(types.T_json)}, proc) + require.Error(t, err) + + // NOT NULL column with an explicit NULL default is rejected. + notNullCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("c"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeNull{Is: false}, + &tree.AttributeDefault{Expr: tree.NewNumVal("null", "null", false, tree.P_null)}, + }, + ) + _, err = buildDefaultExpr(notNullCol, plan.Type{Id: int32(types.T_int32)}, proc) + require.Error(t, err) + + // uuid() default on a non-UUID column is rejected. + uuidCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("c"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeDefault{Expr: &tree.FuncExpr{ + Func: tree.FuncName2ResolvableFunctionReference(tree.NewUnresolvedColName("uuid")), + Exprs: tree.Exprs{}, + }}, + }, + ) + _, err = buildDefaultExpr(uuidCol, plan.Type{Id: int32(types.T_varchar), Width: 36}, proc) + require.Error(t, err) +} + +func TestBuildOnUpdateNoAttribute(t *testing.T) { + proc := testutil.NewProcess(t) + + noAttrCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("c"), + nil, + nil, + ) + onUpdate, err := buildOnUpdate(noAttrCol, plan.Type{Id: int32(types.T_int32)}, proc) + require.NoError(t, err) + require.Nil(t, onUpdate) +} + +func TestSetDefaultAndOnUpdateFoldNonLiteral(t *testing.T) { + proc := testutil.NewProcess(t) + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write,execute"} + + // Default: concat('read','') folds to the literal "read" and should resolve + // against the SET members, giving bit 0b001. + defaultCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeDefault{Expr: &tree.FuncExpr{ + Func: tree.FuncName2ResolvableFunctionReference(tree.NewUnresolvedColName("concat")), + Exprs: tree.Exprs{ + tree.NewNumVal("read", "read", false, tree.P_char), + tree.NewNumVal("", "", false, tree.P_char), + }, + }}, + }, + ) + d, err := buildDefaultExpr(defaultCol, setType, proc) + require.NoError(t, err) + require.Equal(t, uint64(1), d.Expr.GetLit().GetU64Val(), + "folded non-literal default should be resolved by SET members") + + // Default: concat('read','qq') folds to "readqq" which is not a set member; + // should be rejected as an invalid default instead of silently cast to 0. + badCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeDefault{Expr: &tree.FuncExpr{ + Func: tree.FuncName2ResolvableFunctionReference(tree.NewUnresolvedColName("concat")), + Exprs: tree.Exprs{ + tree.NewNumVal("read", "read", false, tree.P_char), + tree.NewNumVal("qq", "qq", false, tree.P_char), + }, + }}, + }, + ) + _, err = buildDefaultExpr(badCol, setType, proc) + require.Error(t, err) + + // On update: concat('read,write','') folds to "read,write", bits 0b011. + onUpdateCol := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeOnUpdate{Expr: &tree.FuncExpr{ + Func: tree.FuncName2ResolvableFunctionReference(tree.NewUnresolvedColName("concat")), + Exprs: tree.Exprs{ + tree.NewNumVal("read,write", "read,write", false, tree.P_char), + tree.NewNumVal("", "", false, tree.P_char), + }, + }}, + }, + ) + u, err := buildOnUpdate(onUpdateCol, setType, proc) + require.NoError(t, err) + require.Equal(t, uint64(3), u.Expr.GetLit().GetU64Val()) +} + +func TestSetDefaultRejectsSignedNumericOverflow(t *testing.T) { + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write"} + expr := makePlan2Int64ConstExprWithType(8) + _, err := funcCastForSetType(context.Background(), expr, setType) + require.Error(t, err) + + expr = makePlan2Int64ConstExprWithType(-1) + _, err = funcCastForSetType(context.Background(), expr, setType) + require.Error(t, err) + + expr = makePlan2Int64ConstExprWithType(3) + casted, err := funcCastForSetType(context.Background(), expr, setType) + require.NoError(t, err) + require.Equal(t, uint64(3), casted.GetLit().GetU64Val()) +} + +func TestFuncCastForSetTypeCoversAllLiteralShapes(t *testing.T) { + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write,execute"} + + // string -> ParseSet + out, err := funcCastForSetType(context.Background(), makePlan2StringConstExprWithType("read,execute"), setType) + require.NoError(t, err) + require.Equal(t, uint64(5), out.GetLit().GetU64Val()) + + // u64 value + out, err = funcCastForSetType(context.Background(), makePlan2Uint64ConstExprWithType(3), setType) + require.NoError(t, err) + require.Equal(t, uint64(3), out.GetLit().GetU64Val()) + + // narrower unsigned ints (uint8/16/32) + out, err = funcCastForSetType(context.Background(), makePlan2Uint8ConstExprWithType(1), setType) + require.NoError(t, err) + require.Equal(t, uint64(1), out.GetLit().GetU64Val()) + out, err = funcCastForSetType(context.Background(), makePlan2Uint16ConstExprWithType(2), setType) + require.NoError(t, err) + require.Equal(t, uint64(2), out.GetLit().GetU64Val()) + out, err = funcCastForSetType(context.Background(), makePlan2Uint32ConstExprWithType(4), setType) + require.NoError(t, err) + require.Equal(t, uint64(4), out.GetLit().GetU64Val()) + + // signed narrower ints + out, err = funcCastForSetType(context.Background(), makePlan2Int8ConstExprWithType(1), setType) + require.NoError(t, err) + require.Equal(t, uint64(1), out.GetLit().GetU64Val()) + out, err = funcCastForSetType(context.Background(), makePlan2Int16ConstExprWithType(2), setType) + require.NoError(t, err) + require.Equal(t, uint64(2), out.GetLit().GetU64Val()) + out, err = funcCastForSetType(context.Background(), makePlan2Int32ConstExprWithType(4), setType) + require.NoError(t, err) + require.Equal(t, uint64(4), out.GetLit().GetU64Val()) + + // non-set type returns the expression untouched + intType := plan.Type{Id: int32(types.T_int64)} + pass, err := funcCastForSetType(context.Background(), makePlan2Int64ConstExprWithType(5), intType) + require.NoError(t, err) + require.Equal(t, int64(5), pass.GetLit().GetI64Val()) + + // null literal passes through unchanged + nullExpr := &plan.Expr{Typ: setType, Expr: &plan.Expr_Lit{Lit: &plan.Literal{Isnull: true}}} + passNull, err := funcCastForSetType(context.Background(), nullExpr, setType) + require.NoError(t, err) + require.True(t, passNull.GetLit().Isnull) + + // out-of-range value bubbles up an error + _, err = funcCastForSetType(context.Background(), makePlan2Uint64ConstExprWithType(16), setType) + require.Error(t, err) +} + +// TestFuncCastForSetType_FloatLiteral covers folded float literals (e.g. +// 1e0, 1.0, 1.5). Integer-valued floats must coerce like the signed +// path; fractional floats must be rejected — otherwise SET DEFAULT / +// ON UPDATE silently stores a garbage literal. +func TestFuncCastForSetType_FloatLiteral(t *testing.T) { + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write,execute"} + + // 1e0 (makePlan2Float32ConstExpr path) == 1.0 — bits 0b001 valid. + f32ok := &plan.Expr{Typ: setType, Expr: makePlan2Float32ConstExpr(1.0)} + out, err := funcCastForSetType(context.Background(), f32ok, setType) + require.NoError(t, err) + require.Equal(t, uint64(1), out.GetLit().GetU64Val()) + + // 3.0 (dval path) — bits 0b011 valid. + f64ok := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(3.0)} + out, err = funcCastForSetType(context.Background(), f64ok, setType) + require.NoError(t, err) + require.Equal(t, uint64(3), out.GetLit().GetU64Val()) + + // 1.5 — fractional must be rejected, not silently truncated. + f64frac := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(1.5)} + _, err = funcCastForSetType(context.Background(), f64frac, setType) + require.Error(t, err, "fractional float default must be rejected for SET") + + // Negative float — invalid for a bitset. + f64neg := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(-1.0)} + _, err = funcCastForSetType(context.Background(), f64neg, setType) + require.Error(t, err) + + // NaN must be rejected. + nan := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(math.NaN())} + _, err = funcCastForSetType(context.Background(), nan, setType) + require.Error(t, err) + + // +Inf must be rejected. + inf := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(math.Inf(1))} + _, err = funcCastForSetType(context.Background(), inf, setType) + require.Error(t, err) + + // 16 (bits referencing non-existent 4th member) must be rejected. + f64bad := &plan.Expr{Typ: setType, Expr: makePlan2Float64ConstExpr(16.0)} + _, err = funcCastForSetType(context.Background(), f64bad, setType) + require.Error(t, err) +} + +// TestFuncCastForSetType_DecimalLiteral verifies decimal literals (1, +// 1.5, 1.0) are handled like floats: integer-valued accepted, fractional +// rejected. +func TestFuncCastForSetType_DecimalLiteral(t *testing.T) { + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write,execute"} + + // decimal64 "3" at scale 0 — bits 0b011. + d64ok := &plan.Expr{ + Typ: plan.Type{Id: int32(types.T_decimal64), Scale: 0}, + Expr: &plan.Expr_Lit{Lit: &plan.Literal{ + Value: &plan.Literal_Decimal64Val{Decimal64Val: &plan.Decimal64{A: 3}}, + }}, + } + out, err := funcCastForSetType(context.Background(), d64ok, setType) + require.NoError(t, err) + require.Equal(t, uint64(3), out.GetLit().GetU64Val()) + + // decimal64 "1.5" at scale 1 (raw = 15, pow10(1)=10) — must reject. + d64frac := &plan.Expr{ + Typ: plan.Type{Id: int32(types.T_decimal64), Scale: 1}, + Expr: &plan.Expr_Lit{Lit: &plan.Literal{ + Value: &plan.Literal_Decimal64Val{Decimal64Val: &plan.Decimal64{A: 15}}, + }}, + } + _, err = funcCastForSetType(context.Background(), d64frac, setType) + require.Error(t, err, "fractional decimal64 must be rejected for SET") + + // decimal128 "1.00" at scale 2 — equals 1, must accept. + d128ok := &plan.Expr{ + Typ: plan.Type{Id: int32(types.T_decimal128), Scale: 2}, + Expr: &plan.Expr_Lit{Lit: &plan.Literal{ + Value: &plan.Literal_Decimal128Val{Decimal128Val: &plan.Decimal128{A: 100, B: 0}}, + }}, + } + out, err = funcCastForSetType(context.Background(), d128ok, setType) + require.NoError(t, err) + require.Equal(t, uint64(1), out.GetLit().GetU64Val()) + + // decimal128 "1.50" at scale 2 — fractional, must reject. + d128frac := &plan.Expr{ + Typ: plan.Type{Id: int32(types.T_decimal128), Scale: 2}, + Expr: &plan.Expr_Lit{Lit: &plan.Literal{ + Value: &plan.Literal_Decimal128Val{Decimal128Val: &plan.Decimal128{A: 150, B: 0}}, + }}, + } + _, err = funcCastForSetType(context.Background(), d128frac, setType) + require.Error(t, err, "fractional decimal128 must be rejected for SET") +} + +// TestFuncCastForSetType_UnsupportedLiteral: any literal shape we do +// not know how to interpret as a SET bitset (bytes, boolean…) must be +// rejected rather than silently transiting as-is. +func TestFuncCastForSetType_UnsupportedLiteral(t *testing.T) { + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write"} + + boolLit := &plan.Expr{ + Typ: setType, + Expr: &plan.Expr_Lit{Lit: &plan.Literal{ + Value: &plan.Literal_Bval{Bval: true}, + }}, + } + _, err := funcCastForSetType(context.Background(), boolLit, setType) + require.Error(t, err, "boolean literal must not be silently accepted for SET") +} + +// Exercise the SET error branches in buildDefaultExpr / buildOnUpdate that +// otherwise show as uncovered (ConstantFold failure and funcCastForSetType +// mismatch on the on-update path). +func TestSetDefaultAndOnUpdateErrorBranches(t *testing.T) { + proc := testutil.NewProcess(t) + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: "read,write"} + + // On-update with a non-foldable value (unresolved column reference). + // We can't build one through the binder because BindExpr rejects unknown + // columns, so instead use a func expr referencing a non-constant like + // now() which the binder accepts but that ConstantFold will not reduce + // to a literal. + onUpdateNonConst := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeOnUpdate{Expr: &tree.FuncExpr{ + Func: tree.FuncName2ResolvableFunctionReference(tree.NewUnresolvedColName("now")), + Exprs: tree.Exprs{}, + }}, + }, + ) + _, err := buildOnUpdate(onUpdateNonConst, setType, proc) + require.Error(t, err, "non-constant SET on-update expression must be rejected") + + // On-update that folds to a value not in the SET members: funcCastForSetType + // returns an error. + onUpdateBadMember := tree.NewColumnTableDef( + tree.NewUnresolvedColName("perm"), + nil, + []tree.ColumnAttribute{ + &tree.AttributeOnUpdate{Expr: tree.NewNumVal("nope", "nope", false, tree.P_char)}, + }, + ) + _, err = buildOnUpdate(onUpdateBadMember, setType, proc) + require.Error(t, err, "SET on-update with non-member literal must be rejected") +} + +// Trigger NormalizeSetValues error inside getTypeFromAst by passing zero +// enum/set members (length == 0 is the empty-input branch). +func TestGetTypeFromAstRejectsEmptySet(t *testing.T) { + ctx := context.Background() + _, err := getTypeFromAst(ctx, &tree.T{InternalType: tree.InternalType{ + Oid: uint32(defines.MYSQL_TYPE_SET), + EnumValues: nil, + }}) + require.Error(t, err) +} + +func TestSetEmptyMemberFormatting(t *testing.T) { + setValues, err := types.NormalizeSetValues([]string{"", "a"}) + require.NoError(t, err) + encoded := types.EncodeSetValues(setValues) + require.NotEqual(t, ",a", encoded) + + setType := plan.Type{Id: int32(types.T_uint64), Enumvalues: encoded} + require.Equal(t, "SET('','a')", FormatColType(setType)) +} diff --git a/pkg/sql/plan/dup_entry_rewrite.go b/pkg/sql/plan/dup_entry_rewrite.go new file mode 100644 index 0000000000000..1693fcf24d1ac --- /dev/null +++ b/pkg/sql/plan/dup_entry_rewrite.go @@ -0,0 +1,120 @@ +// Copyright 2026 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 plan + +import ( + "regexp" + + "github.com/matrixorigin/matrixone/pkg/catalog" + "github.com/matrixorigin/matrixone/pkg/common/moerr" + "github.com/matrixorigin/matrixone/pkg/pb/plan" +) + +// hiddenDupKeyRe matches duplicate-entry messages whose key name is an +// internal hidden-index column. Lower-level engines (e.g. tae DedupSnapByPK, +// the Optimistic commit-time dedup in disttae) only see the hidden index +// table and surface the internal column name: +// - single-column UNIQUE: the hidden-index table's PK is __mo_index_idx_col. +// - composite UNIQUE: the hidden-index table's PK is __mo_cpkey_col +// (compound primary key column). +// +// __mo_cpkey_col is ALSO used on regular user tables with a composite primary +// key, so we only rewrite that variant when the plan is writing into a hidden +// index table — otherwise a user-table composite-PK duplicate would be +// mis-rewritten as the first unique-index name we happen to find. +var hiddenDupKeyRe = regexp.MustCompile( + `^Duplicate entry '(.*)' for key '(` + catalog.IndexTableIndexColName + + `|` + catalog.CPrimaryKeyColName + `)'$`, +) + +// RewriteHiddenIndexDupEntry rewrites duplicate-entry errors that surface an +// internal hidden-index column name. It walks the plan to find the unique +// index being written, then substitutes the user-visible column name (for a +// single-column unique index) or the index name (for a composite one). +// When multiple unique indexes exist on the target table, we cannot tell from +// the engine-level error which one was hit, so we fall back to the original +// error to avoid misattributing the key. +func RewriteHiddenIndexDupEntry(p *plan.Plan, err error) error { + if err == nil || p == nil { + return err + } + msg := err.Error() + m := hiddenDupKeyRe.FindStringSubmatch(msg) + if m == nil { + return err + } + entry := m[1] + matchedKey := m[2] + + qry, ok := p.Plan.(*plan.Plan_Query) + if !ok || qry.Query == nil { + return err + } + + type uniqueKey struct { + parts []string + indexName string + } + var uniques []uniqueKey + var hasHiddenIndexTarget bool + for _, n := range qry.Query.Nodes { + if n == nil || n.TableDef == nil { + continue + } + if catalog.IsHiddenTable(n.TableDef.Name) { + hasHiddenIndexTarget = true + } + if len(uniques) > 0 { + // All DML plans share a single target user-table; the first node + // carrying unique-index definitions is authoritative. Keep scanning + // subsequent nodes only to detect hidden-index targets. + continue + } + for _, idx := range n.TableDef.Indexes { + if !idx.Unique { + continue + } + uniques = append(uniques, uniqueKey{parts: idx.Parts, indexName: idx.IndexName}) + } + } + + // __mo_cpkey_col is shared with user tables that have a composite PK. + // Only rewrite it when the plan is actually writing into a hidden index + // table, otherwise a PK duplicate on a regular table would be + // mislabelled as a unique-index hit. + if matchedKey == catalog.CPrimaryKeyColName && !hasHiddenIndexTarget { + return err + } + + if len(uniques) != 1 { + // TODO: when multiple unique indexes exist, extract the duplicated + // value from the error and match it against each index's declared + // column type so we can pick the right key name. For now we + // deliberately keep the raw internal-column message because + // misattribution is worse than a leaked internal name. + return err + } + u := uniques[0] + var indexKey string + if len(u.parts) == 1 { + indexKey = catalog.ResolveAlias(u.parts[0]) + } else { + indexKey = u.indexName + } + if indexKey == "" { + return err + } + return moerr.NewDuplicateEntryNoCtx(entry, indexKey) +} diff --git a/pkg/sql/plan/dup_entry_rewrite_test.go b/pkg/sql/plan/dup_entry_rewrite_test.go new file mode 100644 index 0000000000000..b1c65cb488de3 --- /dev/null +++ b/pkg/sql/plan/dup_entry_rewrite_test.go @@ -0,0 +1,178 @@ +// Copyright 2026 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 plan + +import ( + "testing" + + "github.com/matrixorigin/matrixone/pkg/catalog" + "github.com/matrixorigin/matrixone/pkg/common/moerr" + "github.com/matrixorigin/matrixone/pkg/pb/plan" + "github.com/stretchr/testify/require" +) + +func TestRewriteHiddenIndexDupEntrySingleColumn(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "decimal15", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "a_index", Parts: []string{"a"}}, + }, + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("271.21212", catalog.IndexTableIndexColName) + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, "Duplicate entry '271.21212' for key 'a'", rewritten.Error()) +} + +func TestRewriteHiddenIndexDupEntryCompositeIndex(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "t1", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "tempKey", Parts: []string{"col1", "col2"}}, + }, + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("(1,2)", catalog.IndexTableIndexColName) + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, "Duplicate entry '(1,2)' for key 'tempKey'", rewritten.Error()) +} + +func TestRewriteHiddenIndexDupEntryUnchanged(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "t1", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "a_index", Parts: []string{"a"}}, + }, + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("v", "pk") + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, src.Error(), rewritten.Error()) +} + +func TestRewriteHiddenIndexDupEntryMultipleUniqueIndexesUnchanged(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "t1", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "a_index", Parts: []string{"a"}}, + {Unique: true, IndexName: "b_index", Parts: []string{"b"}}, + }, + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("1", catalog.IndexTableIndexColName) + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, src.Error(), rewritten.Error(), + "with multiple unique indexes we cannot tell which one was hit, so keep the original error") +} + +// Composite hidden UNIQUE index: the hidden index table's PK column is +// __mo_cpkey_col (compound primary key), not __mo_index_idx_col. The plan +// carries both the user-table node (with the unique-index definition) and a +// hidden-index-table scan node, so we pick the composite index's IndexName. +func TestRewriteHiddenIndexDupEntryCompositeUniqueOnCpkeyCol(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "t1", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "uk_ab", Parts: []string{"a", "b"}}, + }, + }, + }, + { + TableDef: &plan.TableDef{ + Name: catalog.UniqueIndexTableNamePrefix + "abcd", + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("(1,2)", catalog.CPrimaryKeyColName) + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, "Duplicate entry '(1,2)' for key 'uk_ab'", rewritten.Error()) +} + +// A user table with a composite PRIMARY KEY also carries __mo_cpkey_col as +// the PK column name, and such tables may happen to have a unique index too. +// A PK dedup error must NOT be rewritten as the unique index's name — leave +// it alone when no hidden-index-table node is in the plan. +func TestRewriteHiddenIndexDupEntryUserCompositePkUnchanged(t *testing.T) { + p := &plan.Plan{ + Plan: &plan.Plan_Query{ + Query: &plan.Query{ + Nodes: []*plan.Node{ + { + TableDef: &plan.TableDef{ + Name: "t1", + Indexes: []*plan.IndexDef{ + {Unique: true, IndexName: "uk_c", Parts: []string{"c"}}, + }, + }, + }, + }, + }, + }, + } + + src := moerr.NewDuplicateEntryNoCtx("(1,2)", catalog.CPrimaryKeyColName) + rewritten := RewriteHiddenIndexDupEntry(p, src) + require.Equal(t, src.Error(), rewritten.Error(), + "user-table composite PK dedup error must keep __mo_cpkey_col, not be rewritten as the unique index name") +} diff --git a/pkg/sql/plan/function/arithmetic.go b/pkg/sql/plan/function/arithmetic.go index f9310188646a4..451442ee46121 100644 --- a/pkg/sql/plan/function/arithmetic.go +++ b/pkg/sql/plan/function/arithmetic.go @@ -257,12 +257,12 @@ func plusFn(parameters []*vector.Vector, result vector.FunctionResultWrapper, pr return v1 + v2 }, selectList) case types.T_float32: - return opBinaryFixedFixedToFixed[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) float32 { - return v1 + v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) (float32, error) { + return addFloat32WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_float64: - return opBinaryFixedFixedToFixed[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) float64 { - return v1 + v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) (float64, error) { + return addFloat64WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_decimal64: return decimalArith[types.Decimal64](parameters, result, proc, length, func(v1, v2 types.Decimal64, scale1, scale2 int32) (types.Decimal64, error) { @@ -330,12 +330,12 @@ func minusFn(parameters []*vector.Vector, result vector.FunctionResultWrapper, p return v1 - v2 }, selectList) case types.T_float32: - return opBinaryFixedFixedToFixed[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) float32 { - return v1 - v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) (float32, error) { + return subFloat32WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_float64: - return opBinaryFixedFixedToFixed[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) float64 { - return v1 - v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) (float64, error) { + return subFloat64WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_decimal64: return decimalArith[types.Decimal64](parameters, result, proc, length, func(v1, v2 types.Decimal64, scale1, scale2 int32) (types.Decimal64, error) { @@ -415,12 +415,12 @@ func multiFn(parameters []*vector.Vector, result vector.FunctionResultWrapper, p return v1 * v2 }, selectList) case types.T_float32: - return opBinaryFixedFixedToFixed[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) float32 { - return v1 * v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) (float32, error) { + return mulFloat32WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_float64: - return opBinaryFixedFixedToFixed[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) float64 { - return v1 * v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) (float64, error) { + return mulFloat64WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_decimal64: return decimalArith2(parameters, result, proc, length, func(x, y types.Decimal128, scale1, scale2 int32) (types.Decimal128, error) { @@ -452,12 +452,18 @@ func divFn(parameters []*vector.Vector, result vector.FunctionResultWrapper, pro paramType := parameters[0].GetType() switch paramType.Oid { case types.T_float32: - return specialTemplateForDivFunction[float32, float32](parameters, result, proc, length, func(v1, v2 float32) float32 { - return v1 / v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float32, float32, float32](parameters, result, proc, length, func(v1, v2 float32) (float32, error) { + if v2 == 0 { + return 0, moerr.NewDivByZeroNoCtx() + } + return divFloat32WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_float64: - return specialTemplateForDivFunction[float64, float64](parameters, result, proc, length, func(v1, v2 float64) float64 { - return v1 / v2 + return opBinaryFixedFixedToFixedWithErrorCheck[float64, float64, float64](parameters, result, proc, length, func(v1, v2 float64) (float64, error) { + if v2 == 0 { + return 0, moerr.NewDivByZeroNoCtx() + } + return divFloat64WithOverflowCheck(proc.Ctx, v1, v2) }, selectList) case types.T_decimal64: return decimalArith2(parameters, result, proc, length, func(x, y types.Decimal128, scale1, scale2 int32) (types.Decimal128, error) { @@ -813,55 +819,71 @@ func modFn(parameters []*vector.Vector, result vector.FunctionResultWrapper, pro panic("unreached code") } -func plusFnArray[T types.RealNumbers](v1, v2 []byte) ([]byte, error) { +// arrayFloatResultCheck rejects Inf and NaN elements so array arithmetic +// cannot silently propagate them as results. Callers rely on range/NaN +// errors surfacing instead of being encoded into stored vectors. +func arrayFloatResultCheck[T types.RealNumbers](r []T) error { + for _, elem := range r { + f := float64(elem) + if math.IsInf(f, 0) { + return moerr.NewOutOfRangeNoCtx("float", "FLOAT/DOUBLE array value is out of range") + } + if math.IsNaN(f) { + return moerr.NewInvalidInputNoCtx("FLOAT/DOUBLE array value is NaN") + } + } + return nil +} +func plusFnArray[T types.RealNumbers](v1, v2 []byte) ([]byte, error) { _v1 := types.BytesToArray[T](v1) _v2 := types.BytesToArray[T](v2) - r, err := moarray.Add(_v1, _v2) if err != nil { return nil, err } - + if err := arrayFloatResultCheck(r); err != nil { + return nil, err + } return types.ArrayToBytes[T](r), nil } func minusFnArray[T types.RealNumbers](v1, v2 []byte) ([]byte, error) { - _v1 := types.BytesToArray[T](v1) _v2 := types.BytesToArray[T](v2) - r, err := moarray.Subtract(_v1, _v2) if err != nil { return nil, err } - + if err := arrayFloatResultCheck(r); err != nil { + return nil, err + } return types.ArrayToBytes[T](r), nil } func multiFnArray[T types.RealNumbers](v1, v2 []byte) ([]byte, error) { - _v1 := types.BytesToArray[T](v1) _v2 := types.BytesToArray[T](v2) - r, err := moarray.Multiply(_v1, _v2) if err != nil { return nil, err } - + if err := arrayFloatResultCheck(r); err != nil { + return nil, err + } return types.ArrayToBytes[T](r), nil } func divFnArray[T types.RealNumbers](v1, v2 []byte) ([]byte, error) { - _v1 := types.BytesToArray[T](v1) _v2 := types.BytesToArray[T](v2) - r, err := moarray.Divide(_v1, _v2) if err != nil { return nil, err } - + if err := arrayFloatResultCheck(r); err != nil { + return nil, err + } return types.ArrayToBytes[T](r), nil } diff --git a/pkg/sql/plan/function/arithmetic_float_overflow.go b/pkg/sql/plan/function/arithmetic_float_overflow.go new file mode 100644 index 0000000000000..abe07bc310dc5 --- /dev/null +++ b/pkg/sql/plan/function/arithmetic_float_overflow.go @@ -0,0 +1,86 @@ +// Copyright 2026 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 function + +import ( + "context" + "math" + + "github.com/matrixorigin/matrixone/pkg/common/moerr" +) + +func addFloat64WithOverflowCheck(ctx context.Context, v1, v2 float64) (float64, error) { + result := v1 + v2 + if math.IsInf(result, 0) { + return 0, moerr.NewOutOfRangef(ctx, "float64", "DOUBLE value is out of range in '(%v + %v)'", v1, v2) + } + return result, nil +} + +func addFloat32WithOverflowCheck(ctx context.Context, v1, v2 float32) (float32, error) { + result := v1 + v2 + if math.IsInf(float64(result), 0) { + return 0, moerr.NewOutOfRangef(ctx, "float32", "FLOAT value is out of range in '(%v + %v)'", v1, v2) + } + return result, nil +} + +func subFloat64WithOverflowCheck(ctx context.Context, v1, v2 float64) (float64, error) { + result := v1 - v2 + if math.IsInf(result, 0) { + return 0, moerr.NewOutOfRangef(ctx, "float64", "DOUBLE value is out of range in '(%v - %v)'", v1, v2) + } + return result, nil +} + +func subFloat32WithOverflowCheck(ctx context.Context, v1, v2 float32) (float32, error) { + result := v1 - v2 + if math.IsInf(float64(result), 0) { + return 0, moerr.NewOutOfRangef(ctx, "float32", "FLOAT value is out of range in '(%v - %v)'", v1, v2) + } + return result, nil +} + +func mulFloat64WithOverflowCheck(ctx context.Context, v1, v2 float64) (float64, error) { + result := v1 * v2 + if math.IsInf(result, 0) { + return 0, moerr.NewOutOfRangef(ctx, "float64", "DOUBLE value is out of range in '(%v * %v)'", v1, v2) + } + return result, nil +} + +func mulFloat32WithOverflowCheck(ctx context.Context, v1, v2 float32) (float32, error) { + result := v1 * v2 + if math.IsInf(float64(result), 0) { + return 0, moerr.NewOutOfRangef(ctx, "float32", "FLOAT value is out of range in '(%v * %v)'", v1, v2) + } + return result, nil +} + +func divFloat64WithOverflowCheck(ctx context.Context, v1, v2 float64) (float64, error) { + result := v1 / v2 + if math.IsInf(result, 0) { + return 0, moerr.NewOutOfRangef(ctx, "float64", "DOUBLE value is out of range in '(%v / %v)'", v1, v2) + } + return result, nil +} + +func divFloat32WithOverflowCheck(ctx context.Context, v1, v2 float32) (float32, error) { + result := v1 / v2 + if math.IsInf(float64(result), 0) { + return 0, moerr.NewOutOfRangef(ctx, "float32", "FLOAT value is out of range in '(%v / %v)'", v1, v2) + } + return result, nil +} diff --git a/pkg/sql/plan/function/arithmetic_float_overflow_test.go b/pkg/sql/plan/function/arithmetic_float_overflow_test.go new file mode 100644 index 0000000000000..ebf71ba7c6691 --- /dev/null +++ b/pkg/sql/plan/function/arithmetic_float_overflow_test.go @@ -0,0 +1,219 @@ +// Copyright 2026 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 function + +import ( + "context" + "math" + "testing" + + "github.com/matrixorigin/matrixone/pkg/container/types" + "github.com/matrixorigin/matrixone/pkg/container/vector" + "github.com/matrixorigin/matrixone/pkg/testutil" + "github.com/matrixorigin/matrixone/pkg/vm/process" + "github.com/stretchr/testify/require" +) + +func TestFloatArithmeticOverflowReturnsError(t *testing.T) { + proc := testutil.NewProcess(t) + tc := tcTemp{ + info: "float64 addition overflow returns out-of-range error", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.T_float64.ToType(), []float64{math.MaxFloat64}, nil), + NewFunctionTestInput(types.T_float64.ToType(), []float64{math.MaxFloat64}, nil), + }, + expect: NewFunctionTestResult(types.T_float64.ToType(), true, []float64{0}, nil), + } + + tcc := NewFunctionTestCase(proc, tc.inputs, tc.expect, plusFn) + succeed, info := tcc.Run() + require.True(t, succeed, tc.info, info) +} + +func TestFloatArithmeticHelpers(t *testing.T) { + ctx := context.Background() + + // addFloat64 / addFloat32 + if v, err := addFloat64WithOverflowCheck(ctx, 1.0, 2.0); err != nil || v != 3.0 { + t.Fatalf("addFloat64 normal: v=%v err=%v", v, err) + } + if _, err := addFloat64WithOverflowCheck(ctx, math.MaxFloat64, math.MaxFloat64); err == nil { + t.Fatal("addFloat64 overflow expected error") + } + if v, err := addFloat32WithOverflowCheck(ctx, 1.0, 2.0); err != nil || v != 3.0 { + t.Fatalf("addFloat32 normal: v=%v err=%v", v, err) + } + if _, err := addFloat32WithOverflowCheck(ctx, math.MaxFloat32, math.MaxFloat32); err == nil { + t.Fatal("addFloat32 overflow expected error") + } + + // subFloat64 / subFloat32 + if v, err := subFloat64WithOverflowCheck(ctx, 3.0, 1.0); err != nil || v != 2.0 { + t.Fatalf("subFloat64 normal: v=%v err=%v", v, err) + } + if _, err := subFloat64WithOverflowCheck(ctx, -math.MaxFloat64, math.MaxFloat64); err == nil { + t.Fatal("subFloat64 overflow expected error") + } + if v, err := subFloat32WithOverflowCheck(ctx, 3.0, 1.0); err != nil || v != 2.0 { + t.Fatalf("subFloat32 normal: v=%v err=%v", v, err) + } + if _, err := subFloat32WithOverflowCheck(ctx, -math.MaxFloat32, math.MaxFloat32); err == nil { + t.Fatal("subFloat32 overflow expected error") + } + + // mulFloat64 / mulFloat32 + if v, err := mulFloat64WithOverflowCheck(ctx, 2.0, 3.0); err != nil || v != 6.0 { + t.Fatalf("mulFloat64 normal: v=%v err=%v", v, err) + } + if _, err := mulFloat64WithOverflowCheck(ctx, math.MaxFloat64, 2.0); err == nil { + t.Fatal("mulFloat64 overflow expected error") + } + if v, err := mulFloat32WithOverflowCheck(ctx, 2.0, 3.0); err != nil || v != 6.0 { + t.Fatalf("mulFloat32 normal: v=%v err=%v", v, err) + } + if _, err := mulFloat32WithOverflowCheck(ctx, math.MaxFloat32, 2.0); err == nil { + t.Fatal("mulFloat32 overflow expected error") + } + + // divFloat64 / divFloat32 — overflow when dividing by a tiny number. + if v, err := divFloat64WithOverflowCheck(ctx, 6.0, 2.0); err != nil || v != 3.0 { + t.Fatalf("divFloat64 normal: v=%v err=%v", v, err) + } + if _, err := divFloat64WithOverflowCheck(ctx, math.MaxFloat64, math.SmallestNonzeroFloat64); err == nil { + t.Fatal("divFloat64 overflow expected error") + } + if v, err := divFloat32WithOverflowCheck(ctx, 6.0, 2.0); err != nil || v != 3.0 { + t.Fatalf("divFloat32 normal: v=%v err=%v", v, err) + } + if _, err := divFloat32WithOverflowCheck(ctx, math.MaxFloat32, math.SmallestNonzeroFloat32); err == nil { + t.Fatal("divFloat32 overflow expected error") + } +} + +func TestFloatArithmeticOverflowThroughFunctions(t *testing.T) { + proc := testutil.NewProcess(t) + + cases := []struct { + name string + fn func([]*vector.Vector, vector.FunctionResultWrapper, *process.Process, int, *FunctionSelectList) error + a, b float64 + }{ + {"minusFn float64 overflow", minusFn, -math.MaxFloat64, math.MaxFloat64}, + {"multiFn float64 overflow", multiFn, math.MaxFloat64, 2}, + {"divFn float64 overflow", divFn, math.MaxFloat64, math.SmallestNonzeroFloat64}, + } + for _, c := range cases { + tc := tcTemp{ + info: c.name, + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.T_float64.ToType(), []float64{c.a}, nil), + NewFunctionTestInput(types.T_float64.ToType(), []float64{c.b}, nil), + }, + expect: NewFunctionTestResult(types.T_float64.ToType(), true, []float64{0}, nil), + } + tcc := NewFunctionTestCase(proc, tc.inputs, tc.expect, c.fn) + succeed, info := tcc.Run() + require.True(t, succeed, c.name, info) + } + + // float32 variants exercise the float32-specific helpers + cases32 := []struct { + name string + fn func([]*vector.Vector, vector.FunctionResultWrapper, *process.Process, int, *FunctionSelectList) error + a, b float32 + }{ + {"plusFn float32 overflow", plusFn, math.MaxFloat32, math.MaxFloat32}, + {"minusFn float32 overflow", minusFn, -math.MaxFloat32, math.MaxFloat32}, + {"multiFn float32 overflow", multiFn, math.MaxFloat32, 2}, + {"divFn float32 overflow", divFn, math.MaxFloat32, math.SmallestNonzeroFloat32}, + } + for _, c := range cases32 { + tc := tcTemp{ + info: c.name, + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.T_float32.ToType(), []float32{c.a}, nil), + NewFunctionTestInput(types.T_float32.ToType(), []float32{c.b}, nil), + }, + expect: NewFunctionTestResult(types.T_float32.ToType(), true, []float32{0}, nil), + } + tcc := NewFunctionTestCase(proc, tc.inputs, tc.expect, c.fn) + succeed, info := tcc.Run() + require.True(t, succeed, c.name, info) + } +} + +// Each array arithmetic function has a post-op IsInf scan; drive a pair of +// large-magnitude vecf32 arrays through them so those branches execute. +func TestArrayArithmeticInfScanRejected(t *testing.T) { + // Build two float32 arrays whose element-wise add/sub/mul/div overflows + // float32 range. The helpers take raw bytes: encode via ArrayToBytes. + a32 := types.ArrayToBytes[float32]([]float32{math.MaxFloat32}) + b32Big := types.ArrayToBytes[float32]([]float32{math.MaxFloat32}) + b32Small := types.ArrayToBytes[float32]([]float32{math.SmallestNonzeroFloat32}) + + _, err := plusFnArray[float32](a32, b32Big) + require.Error(t, err, "float32 array plus overflow must be rejected") + + _, err = minusFnArray[float32](a32, types.ArrayToBytes[float32]([]float32{-math.MaxFloat32})) + require.Error(t, err, "float32 array minus overflow must be rejected") + + _, err = multiFnArray[float32](a32, types.ArrayToBytes[float32]([]float32{2})) + require.Error(t, err, "float32 array multiply overflow must be rejected") + + _, err = divFnArray[float32](a32, b32Small) + require.Error(t, err, "float32 array divide overflow must be rejected") + + // Sanity: well-within-range arrays succeed. + _, err = plusFnArray[float32]( + types.ArrayToBytes[float32]([]float32{1}), + types.ArrayToBytes[float32]([]float32{2})) + require.NoError(t, err) +} + +// TestArrayArithmeticNaNRejected asserts NaN results from array arithmetic +// surface as errors instead of being silently stored. Divide 0 by 0 +// yields NaN (moarray.Divide tolerates zero divisors element-wise), +// and we also exercise the plus/minus/multi NaN paths via Inf-minus-Inf +// and Inf*0 constructions that moarray.* passes through. +func TestArrayArithmeticNaNRejected(t *testing.T) { + // 0/0 => NaN + zero := types.ArrayToBytes[float32]([]float32{0}) + _, err := divFnArray[float32](zero, zero) + require.Error(t, err, "array divide 0/0 must be rejected as NaN") + + // Inf - Inf => NaN via the minusFn post-scan. + inf32 := types.ArrayToBytes[float32]([]float32{float32(math.Inf(1))}) + _, err = minusFnArray[float32](inf32, inf32) + require.Error(t, err, "array Inf-Inf must be rejected as NaN or Inf") + + // 0 * Inf => NaN for multiply. + _, err = multiFnArray[float32](zero, inf32) + require.Error(t, err, "array 0*Inf must be rejected as NaN or Inf") +} + +func TestExpOverflowReturnsError(t *testing.T) { + proc := testutil.NewProcess(t) + tc := tcTemp{ + info: "exp overflow returns out-of-range error", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.T_float64.ToType(), []float64{1000}, nil), + }, + expect: NewFunctionTestResult(types.T_float64.ToType(), true, []float64{0}, nil), + } + + tcc := NewFunctionTestCase(proc, tc.inputs, tc.expect, builtInExp) + succeed, info := tcc.Run() + require.True(t, succeed, tc.info, info) +} diff --git a/pkg/sql/plan/function/func_builtin.go b/pkg/sql/plan/function/func_builtin.go index 4b98f698f8ccb..cc3430a5877f1 100644 --- a/pkg/sql/plan/function/func_builtin.go +++ b/pkg/sql/plan/function/func_builtin.go @@ -292,7 +292,7 @@ func builtInMoShowVisibleBinEnum(parameters []*vector.Vector, result vector.Func } // get enum values - enums := strings.Split(enumStr, ",") + enums, _ := types.DecodeEnumValues(enumStr) enumVal := "" for i, e := range enums { enumVal += fmt.Sprintf("'%s'", e) diff --git a/pkg/sql/plan/function/func_cast.go b/pkg/sql/plan/function/func_cast.go index 7fd3c7f1cc957..4029cd29b5926 100644 --- a/pkg/sql/plan/function/func_cast.go +++ b/pkg/sql/plan/function/func_cast.go @@ -47,9 +47,9 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_json, types.T_binary, types.T_varbinary, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_array_float32, types.T_array_float64, types.T_datalink, }, @@ -84,7 +84,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_datalink, @@ -97,7 +97,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_datalink, @@ -110,7 +110,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_datalink, @@ -123,7 +123,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_enum, types.T_datalink, @@ -136,7 +136,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_enum, types.T_datalink, @@ -149,7 +149,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_enum, types.T_datalink, @@ -162,7 +162,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_enum, types.T_datalink, @@ -175,7 +175,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, types.T_decimal64, types.T_decimal128, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_enum, types.T_datalink, @@ -190,6 +190,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_decimal64, types.T_decimal128, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, + types.T_year, types.T_datalink, }, @@ -202,6 +203,7 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_decimal64, types.T_decimal128, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, + types.T_year, types.T_datalink, }, @@ -269,17 +271,28 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_datalink, }, + types.T_decimal256: { + types.T_bit, + types.T_float32, types.T_float64, + types.T_int8, types.T_int16, types.T_int32, types.T_int64, + types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, + types.T_decimal64, types.T_decimal128, types.T_decimal256, + types.T_char, types.T_varchar, types.T_blob, types.T_text, + types.T_binary, types.T_varbinary, + types.T_datalink, + }, + types.T_char: { types.T_bit, types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_json, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_datalink, @@ -290,12 +303,12 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_json, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_array_float32, types.T_array_float64, @@ -308,11 +321,11 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_varbinary, types.T_binary, types.T_datalink, @@ -323,11 +336,11 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_datalink, @@ -338,12 +351,12 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_json, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_array_float32, types.T_array_float64, @@ -355,22 +368,30 @@ var supportedTypeCast = map[types.T][]types.T{ types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_json, types.T_uuid, types.T_date, types.T_datetime, - types.T_time, types.T_timestamp, + types.T_time, types.T_timestamp, types.T_year, types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary, types.T_array_float32, types.T_array_float64, }, + types.T_year: { + types.T_year, + types.T_int8, types.T_int16, types.T_int32, types.T_int64, + types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, + types.T_float32, types.T_float64, + types.T_char, types.T_varchar, types.T_blob, types.T_text, + types.T_binary, types.T_varbinary, + }, types.T_datalink: { types.T_bit, types.T_int8, types.T_int16, types.T_int32, types.T_int64, types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, types.T_float32, types.T_float64, - types.T_decimal64, types.T_decimal128, + types.T_decimal64, types.T_decimal128, types.T_decimal256, types.T_bool, types.T_json, types.T_uuid, @@ -484,6 +505,9 @@ func NewCast(parameters []*vector.Vector, result vector.FunctionResultWrapper, p case types.T_decimal128: s := vector.GenerateFunctionFixedTypeParameter[types.Decimal128](from) err = decimal128ToOthers(proc.Ctx, s, *toType, result, length, selectList) + case types.T_decimal256: + s := vector.GenerateFunctionFixedTypeParameter[types.Decimal256](from) + err = decimal256ToOthers(proc.Ctx, s, *toType, result, length, selectList) case types.T_date: s := vector.GenerateFunctionFixedTypeParameter[types.Date](from) err = dateToOthers(proc, s, *toType, result, length, selectList) @@ -496,6 +520,9 @@ func NewCast(parameters []*vector.Vector, result vector.FunctionResultWrapper, p case types.T_timestamp: s := vector.GenerateFunctionFixedTypeParameter[types.Timestamp](from) err = timestampToOthers(proc, s, *toType, result, length, selectList) + case types.T_year: + s := vector.GenerateFunctionFixedTypeParameter[types.MoYear](from) + err = yearToOthers(proc.Ctx, s, *toType, result, length, selectList) case types.T_char, types.T_varchar, types.T_binary, types.T_varbinary, types.T_blob, types.T_text, types.T_datalink: s := vector.GenerateFunctionStrParameter(from) err = strTypeToOthers(proc, s, *toType, result, length, selectList) @@ -565,6 +592,8 @@ func scalarNullToOthers(ctx context.Context, return appendNulls[types.Decimal64](result, length, selectList) case types.T_decimal128: return appendNulls[types.Decimal128](result, length, selectList) + case types.T_decimal256: + return appendNulls[types.Decimal256](result, length, selectList) case types.T_date: return appendNulls[types.Date](result, length, selectList) case types.T_datetime: @@ -573,6 +602,8 @@ func scalarNullToOthers(ctx context.Context, return appendNulls[types.Time](result, length, selectList) case types.T_timestamp: return appendNulls[types.Timestamp](result, length, selectList) + case types.T_year: + return appendNulls[types.MoYear](result, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from NULL to %s", totype)) } @@ -743,6 +774,9 @@ func int8ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from int8 to %s", toType)) } @@ -804,6 +838,9 @@ func int16ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from int16 to %s", toType)) } @@ -865,6 +902,9 @@ func int32ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from int32 to %s", toType)) } @@ -929,6 +969,9 @@ func int64ToOthers(ctx context.Context, case types.T_enum: rs := vector.MustFunctionResult[types.Enum](result) return integerToEnum(ctx, source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from int64 to %s", toType)) } @@ -989,6 +1032,9 @@ func uint8ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) case types.T_enum: rs := vector.MustFunctionResult[types.Enum](result) return integerToEnum(ctx, source, rs, length, selectList) @@ -1052,6 +1098,9 @@ func uint16ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) case types.T_enum: rs := vector.MustFunctionResult[types.Enum](result) return integerToEnum(ctx, source, rs, length, selectList) @@ -1115,6 +1164,9 @@ func uint32ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) case types.T_enum: rs := vector.MustFunctionResult[types.Enum](result) return integerToEnum(ctx, source, rs, length, selectList) @@ -1178,6 +1230,9 @@ func uint64ToOthers(ctx context.Context, case types.T_timestamp: rs := vector.MustFunctionResult[types.Timestamp](result) return integerToTimestamp(source, rs, length, selectList) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return integerToYear(ctx, source, rs, length, selectList) case types.T_enum: rs := vector.MustFunctionResult[types.Enum](result) return integerToEnum(ctx, source, rs, length, selectList) @@ -1241,6 +1296,9 @@ func float32ToOthers(ctx context.Context, types.T_binary, types.T_text, types.T_varbinary, types.T_datalink: rs := vector.MustFunctionResult[types.Varlena](result) return floatToStr(ctx, source, rs, length, toType) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return floatToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from float32 to %s", toType)) } @@ -1301,6 +1359,9 @@ func float64ToOthers(ctx context.Context, types.T_binary, types.T_text, types.T_varbinary, types.T_datalink: rs := vector.MustFunctionResult[types.Varlena](result) return floatToStr(ctx, source, rs, length, toType) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return floatToYear(ctx, source, rs, length, selectList) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from float64 to %s", toType)) } @@ -1576,8 +1637,7 @@ func decimal128ToOthers(ctx context.Context, if err := rs.DupFromParameter(source, length); err != nil { return err } - v := source.GetSourceVector() - v.SetType(toType) + rs.TempSetType(toType) return nil } return decimal128ToDecimal128(source, rs, length, selectList) @@ -1601,6 +1661,275 @@ func decimal128ToOthers(ctx context.Context, return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from decimal128 to %s", toType)) } +func decimal256ToOthers(ctx context.Context, + source vector.FunctionParameterWrapper[types.Decimal256], + toType types.Type, result vector.FunctionResultWrapper, length int, selectList *FunctionSelectList) error { + switch toType.Oid { + case types.T_bit: + rs := vector.MustFunctionResult[uint64](result) + return decimal256ToBit(ctx, source, rs, int(toType.Width), length) + case types.T_int8: + rs := vector.MustFunctionResult[int8](result) + return decimal256ToSigned(ctx, source, rs, 8, length) + case types.T_int16: + rs := vector.MustFunctionResult[int16](result) + return decimal256ToSigned(ctx, source, rs, 16, length) + case types.T_int32: + rs := vector.MustFunctionResult[int32](result) + return decimal256ToSigned(ctx, source, rs, 32, length) + case types.T_int64: + rs := vector.MustFunctionResult[int64](result) + return decimal256ToSigned(ctx, source, rs, 64, length) + case types.T_uint8: + rs := vector.MustFunctionResult[uint8](result) + return decimal256ToUnsigned(ctx, source, rs, 8, length) + case types.T_uint16: + rs := vector.MustFunctionResult[uint16](result) + return decimal256ToUnsigned(ctx, source, rs, 16, length) + case types.T_uint32: + rs := vector.MustFunctionResult[uint32](result) + return decimal256ToUnsigned(ctx, source, rs, 32, length) + case types.T_uint64: + rs := vector.MustFunctionResult[uint64](result) + return decimal256ToUnsigned(ctx, source, rs, 64, length) + case types.T_decimal64: + rs := vector.MustFunctionResult[types.Decimal64](result) + return decimal256ToDecimal64(ctx, source, rs, length) + case types.T_decimal128: + rs := vector.MustFunctionResult[types.Decimal128](result) + return decimal256ToDecimal128(ctx, source, rs, length) + case types.T_decimal256: + rs := vector.MustFunctionResult[types.Decimal256](result) + return decimal256ToDecimal256(source, rs, length) + case types.T_float32: + rs := vector.MustFunctionResult[float32](result) + return decimal256ToFloat(ctx, source, rs, length, 32) + case types.T_float64: + rs := vector.MustFunctionResult[float64](result) + return decimal256ToFloat(ctx, source, rs, length, 64) + case types.T_char, types.T_varchar, types.T_blob, + types.T_binary, types.T_varbinary, types.T_text, types.T_datalink: + rs := vector.MustFunctionResult[types.Varlena](result) + return decimal256ToStr(ctx, source, rs, length, toType) + } + return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from decimal256 to %s", toType)) +} + +func decimal256ToSigned[T constraints.Signed]( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[T], bitSize int, length int) error { + fromTyp := from.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + x, _ := v.Scale(-fromTyp.Scale) + xStr := x.Format(0) + result, err := strconv.ParseInt(xStr, 10, bitSize) + if err != nil { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("int%d", bitSize), "value '%v'", xStr) + } + if err = to.Append(T(result), false); err != nil { + return err + } + } + return nil +} + +func decimal256ToUnsigned[T constraints.Unsigned]( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[T], bitSize int, length int) error { + fromType := from.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + xStr := v.Format(fromType.Scale) + xStr = strings.Split(xStr, ".")[0] + result, err := strconv.ParseUint(xStr, 10, bitSize) + if err != nil { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("uint%d", bitSize), "value '%v'", xStr) + } + if err = to.Append(T(result), false); err != nil { + return err + } + } + return nil +} + +func decimal256ToBit( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[uint64], bitSize int, length int) error { + fromType := from.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(uint64(0), true); err != nil { + return err + } + continue + } + xStr := v.Format(fromType.Scale) + xStr = strings.Split(xStr, ".")[0] + result, err := strconv.ParseUint(xStr, 10, bitSize) + if err != nil { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("bit(%d)", bitSize), "value '%v'", xStr) + } + if err = to.Append(result, false); err != nil { + return err + } + } + return nil +} + +func decimal256ToDecimal64( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[types.Decimal64], length int) error { + var dft types.Decimal64 + fromType := from.GetType() + toType := to.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(dft, true); err != nil { + return err + } + continue + } + dec := v.Format(fromType.Scale) + result, err := types.ParseDecimal64(dec, toType.Width, toType.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } + return nil +} + +func decimal256ToDecimal128( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[types.Decimal128], length int) error { + var dft types.Decimal128 + fromType := from.GetType() + toType := to.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(dft, true); err != nil { + return err + } + continue + } + dec := v.Format(fromType.Scale) + result, err := types.ParseDecimal128(dec, toType.Width, toType.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } + return nil +} + +func decimal256ToDecimal256( + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[types.Decimal256], length int) error { + var dft types.Decimal256 + fromType := from.GetType() + toType := to.GetType() + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(dft, true); err != nil { + return err + } + continue + } + if toType.Width < fromType.Width { + dec := v.Format(fromType.Scale) + result, err := types.ParseDecimal256(dec, toType.Width, toType.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } else { + result, err := v.Scale(toType.Scale - fromType.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } + } + return nil +} + +func decimal256ToStr( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[types.Varlena], length int, toType types.Type) error { + fromType := from.GetType() + // Match decimal128ToStr: cast(x AS binary[(n)]) right-pads with NUL. + if toType.Oid == types.T_binary && toType.Scale == -1 { + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + v1 := []byte(v.Format(fromType.Scale)) + if err := explicitCastToBinary(toType, v1, null, to); err != nil { + return err + } + } + return nil + } + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.AppendBytes(nil, true); err != nil { + return err + } + continue + } + result := []byte(v.Format(fromType.Scale)) + if toType.Oid == types.T_binary || toType.Oid == types.T_varbinary { + if int32(len(result)) > toType.Width { + return moerr.NewDataTruncatedNoCtx("Decimal256", "truncated for binary/varbinary") + } + } + if toType.Oid == types.T_binary && len(result) < int(toType.Width) { + add0 := int(toType.Width) - len(result) + for ; add0 != 0; add0-- { + result = append(result, 0) + } + } + if len(result) > int(toType.Width) && toType.Oid != types.T_text && toType.Oid != types.T_blob && toType.Oid != types.T_datalink { + return formatCastError(ctx, from.GetSourceVector(), toType, fmt.Sprintf( + "%v is larger than Dest length %v", v.Format(fromType.Scale), toType.Width)) + } + if err := to.AppendBytes(result, false); err != nil { + return err + } + } + return nil +} + func strTypeToOthers(proc *process.Process, source vector.FunctionParameterWrapper[types.Varlena], toType types.Type, result vector.FunctionResultWrapper, length int, selectList *FunctionSelectList) error { @@ -1665,6 +1994,9 @@ func strTypeToOthers(proc *process.Process, case types.T_decimal128: rs := vector.MustFunctionResult[types.Decimal128](result) return strToDecimal128(source, rs, length, selectList) + case types.T_decimal256: + rs := vector.MustFunctionResult[types.Decimal256](result) + return strToDecimal256(source, rs, length, selectList) case types.T_bool: rs := vector.MustFunctionResult[bool](result) return strToBool(source, rs, length, selectList) @@ -1700,6 +2032,9 @@ func strTypeToOthers(proc *process.Process, case types.T_array_float64: rs := vector.MustFunctionResult[types.Varlena](result) return strToArray[float64](ctx, source, rs, length, toType) + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return strToYear(ctx, source, rs, length, selectList, fromType) } return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from %s to %s", source.GetType(), toType)) } @@ -2218,7 +2553,29 @@ func numericToBit[T constraints.Integer | constraints.Float]( var val uint64 switch any(v).(type) { case float32, float64: - val = uint64(math.Round(float64(v))) + // uint64(NaN)/uint64(+Inf)/uint64(negative) produce + // platform-specific garbage (NaN -> 0, Inf -> MaxUint64, + // negative -> bit-wrapped). Reject them explicitly so + // cast( as bit(n)) matches integer-cast semantics + // instead of silently writing a magic value. + f := float64(v) + if math.IsNaN(f) { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("bit(%d)", bitSize), "value 'NaN'") + } + if math.IsInf(f, 0) { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("bit(%d)", bitSize), "value '%v'", f) + } + if f < 0 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("bit(%d)", bitSize), "value '%v'", f) + } + // float64(math.MaxUint64) rounds up to 2^64, so comparing + // against that constant misses values in (MaxUint64, 2^64], + // which then become implementation-defined when converted to + // uint64. Compare against the smallest unrepresentable float. + if math.Round(f) >= maxUint64FloatExclusive { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("bit(%d)", bitSize), "value '%v'", f) + } + val = uint64(math.Round(f)) default: val = uint64(v) } @@ -3879,6 +4236,15 @@ func decimal128ToFloat[T constraints.Float]( } } else { xStr := v.Format(fromType.Scale) + // First parse at the target bitSize to reject values that do not + // fit into float32's magnitude range. Then, if bitSize==32, re-parse + // at 64 so that floatNumToFixFloat below sees the full-precision + // decimal literal when comparing against the (Width,Scale) range. + // Without this widening, floatNumToFixFloat gets the float32- + // quantized value and a boundary case like cast + // decimal(30,3)=999.995 -> float(5,2) would be treated as 999.99 + // (in-range) instead of 1000 (out-of-range). to.Append(T(result)) + // still applies the float32 rounding for storage. result, err := strconv.ParseFloat(xStr, bitSize) if err != nil { return moerr.NewOutOfRangef(ctx, "float32", "value '%v'", xStr) @@ -3904,31 +4270,72 @@ func decimal128ToFloat[T constraints.Float]( return nil } -func decimal64ToDecimal64( - from vector.FunctionParameterWrapper[types.Decimal64], - to *vector.FunctionResult[types.Decimal64], length int, selectList *FunctionSelectList) error { +func decimal256ToFloat[T constraints.Float]( + ctx context.Context, + from vector.FunctionParameterWrapper[types.Decimal256], + to *vector.FunctionResult[T], length int, bitSize int) error { var i uint64 l := uint64(length) - var dft types.Decimal64 - fromtype := from.GetType() - totype := to.GetType() + fromType := from.GetType() for i = 0; i < l; i++ { v, null := from.GetValue(i) if null { - if err := to.Append(dft, true); err != nil { + if err := to.Append(0, true); err != nil { return err } } else { - if totype.Width < fromtype.Width { - dec := v.Format(fromtype.Scale) - result, err := types.ParseDecimal64(dec, totype.Width, totype.Scale) - if err != nil { - return err - } - if err = to.Append(result, false); err != nil { - return err - } - } else { + xStr := v.Format(fromType.Scale) + // See decimal128ToFloat for why we re-parse at 64 when bitSize==32. + result, err := strconv.ParseFloat(xStr, bitSize) + if err != nil { + return moerr.NewOutOfRangef(ctx, "float32", "value '%v'", xStr) + } + if bitSize == 32 { + result, _ = strconv.ParseFloat(xStr, 64) + } + if to.GetType().Scale < 0 || to.GetType().Width == 0 { + if err = to.Append(T(result), false); err != nil { + return err + } + } else { + v2, err := floatNumToFixFloat(ctx, result, to, xStr) + if err != nil { + return err + } + if err = to.Append(T(v2), false); err != nil { + return err + } + } + } + } + return nil +} + +func decimal64ToDecimal64( + from vector.FunctionParameterWrapper[types.Decimal64], + to *vector.FunctionResult[types.Decimal64], length int, selectList *FunctionSelectList) error { + var i uint64 + l := uint64(length) + var dft types.Decimal64 + fromtype := from.GetType() + totype := to.GetType() + for i = 0; i < l; i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(dft, true); err != nil { + return err + } + } else { + if totype.Width < fromtype.Width { + dec := v.Format(fromtype.Scale) + result, err := types.ParseDecimal64(dec, totype.Width, totype.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } else { result, err := v.Scale(totype.Scale - fromtype.Scale) if err != nil { return err @@ -4288,6 +4695,20 @@ func strToSigned[T constraints.Signed]( } } r = int64(num) + switch bitSize { + case 8: + if r < math.MinInt8 || r > math.MaxInt8 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("int%d", bitSize), "value '%d'", r) + } + case 16: + if r < math.MinInt16 || r > math.MaxInt16 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("int%d", bitSize), "value '%d'", r) + } + case 32: + if r < math.MinInt32 || r > math.MaxInt32 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("int%d", bitSize), "value '%d'", r) + } + } result = T(r) } else { s := strings.TrimSpace(convertByteSliceToString(v)) @@ -4339,6 +4760,22 @@ func strToUnsigned[T constraints.Unsigned]( s := hex.EncodeToString(v) res = &s val, tErr = strconv.ParseUint(s, 16, 64) + if tErr == nil { + switch bitSize { + case 8: + if val > math.MaxUint8 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("uint%d", bitSize), "value '%s'", s) + } + case 16: + if val > math.MaxUint16 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("uint%d", bitSize), "value '%s'", s) + } + case 32: + if val > math.MaxUint32 { + return moerr.NewOutOfRangef(ctx, fmt.Sprintf("uint%d", bitSize), "value '%s'", s) + } + } + } } else { s := strings.TrimSpace(convertByteSliceToString(v)) res = &s @@ -4505,6 +4942,252 @@ func strToDecimal128( return nil } +func strToDecimal256( + from vector.FunctionParameterWrapper[types.Varlena], + to *vector.FunctionResult[types.Decimal256], length int, selectList *FunctionSelectList, +) error { + var i uint64 + var l = uint64(length) + var dft types.Decimal256 + totype := to.GetType() + isb := from.GetSourceVector().GetIsBin() + for i = 0; i < l; i++ { + v, null := from.GetStrValue(i) + if null { + if err := to.Append(dft, true); err != nil { + return err + } + } else { + s := convertByteSliceToString(v) + if !isb { + result, err := types.ParseDecimal256(s, totype.Width, totype.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } else { + result, err := types.ParseDecimal256FromByte(s, totype.Width, totype.Scale) + if err != nil { + return err + } + if err = to.Append(result, false); err != nil { + return err + } + } + } + } + return nil +} + +func strToYear(ctx context.Context, + from vector.FunctionParameterWrapper[types.Varlena], + to *vector.FunctionResult[types.MoYear], length int, selectList *FunctionSelectList, + fromType types.Type, +) error { + // BINARY(N) right-pads with NUL bytes, so trimming '\x00' is necessary to + // reach the logical value. VARBINARY / BLOB carry arbitrary payload and + // must not be trimmed, otherwise data like []byte{'0', 0x00} would be + // silently accepted as YEAR 0. + trimNul := fromType.Oid == types.T_binary + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetStrValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + s := convertByteSliceToString(v) + if trimNul { + s = strings.TrimRight(s, "\x00") + } + year, err := types.ParseMoYear(s) + if err != nil { + return err + } + if err := to.Append(year, false); err != nil { + return err + } + } + return nil +} + +func floatToYear[T constraints.Float](ctx context.Context, + from vector.FunctionParameterWrapper[T], + to *vector.FunctionResult[types.MoYear], length int, selectList *FunctionSelectList, +) error { + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + // MySQL rounds float values before narrowing to YEAR (e.g. 2155.6 + // becomes 2156, which is then rejected as out-of-range). A direct + // int64(v) conversion truncates toward zero and silently accepts + // 2155.6 as YEAR 2155. Round first, then validate. + rounded := math.Round(float64(v)) + if math.IsNaN(rounded) || math.IsInf(rounded, 0) || + rounded < math.MinInt64 || rounded > math.MaxInt64 { + return moerr.NewInvalidInputf(ctx, "year value out of range: %v", v) + } + year, err := types.ParseMoYearFromInt(int64(rounded)) + if err != nil { + return err + } + if err := to.Append(year, false); err != nil { + return err + } + } + return nil +} + +func integerToYear[T constraints.Integer](ctx context.Context, + from vector.FunctionParameterWrapper[T], + to *vector.FunctionResult[types.MoYear], length int, selectList *FunctionSelectList, +) error { + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + year, err := types.ParseMoYearFromInt(int64(v)) + if err != nil { + return err + } + if err := to.Append(year, false); err != nil { + return err + } + } + return nil +} + +func yearToOthers(ctx context.Context, + from vector.FunctionParameterWrapper[types.MoYear], + toType types.Type, result vector.FunctionResultWrapper, length int, selectList *FunctionSelectList, +) error { + switch toType.Oid { + case types.T_year: + rs := vector.MustFunctionResult[types.MoYear](result) + return rs.DupFromParameter(from, length) + case types.T_int8: + rs := vector.MustFunctionResult[int8](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_int16: + rs := vector.MustFunctionResult[int16](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_int32: + rs := vector.MustFunctionResult[int32](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_int64: + rs := vector.MustFunctionResult[int64](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_uint8: + rs := vector.MustFunctionResult[uint8](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_uint16: + rs := vector.MustFunctionResult[uint16](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_uint32: + rs := vector.MustFunctionResult[uint32](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_uint64: + rs := vector.MustFunctionResult[uint64](result) + return yearToInteger(ctx, from, rs, length, selectList) + case types.T_float32: + rs := vector.MustFunctionResult[float32](result) + return yearToFloat(ctx, from, rs, length, selectList) + case types.T_float64: + rs := vector.MustFunctionResult[float64](result) + return yearToFloat(ctx, from, rs, length, selectList) + case types.T_char, types.T_varchar, types.T_blob, types.T_text, types.T_binary, types.T_varbinary: + rs := vector.MustFunctionResult[types.Varlena](result) + return yearToStr(ctx, from, rs, length, toType) + } + return moerr.NewInternalError(ctx, fmt.Sprintf("unsupported cast from year to %s", toType)) +} + +func yearToInteger[T constraints.Integer](ctx context.Context, + from vector.FunctionParameterWrapper[types.MoYear], + to *vector.FunctionResult[T], length int, selectList *FunctionSelectList, +) error { + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + r := int16(v) + if err := overflowForNumericToNumeric[int16, T](ctx, []int16{r}, nil); err != nil { + return err + } + if err := to.Append(T(r), false); err != nil { + return err + } + } + return nil +} + +func yearToFloat[T constraints.Float](ctx context.Context, + from vector.FunctionParameterWrapper[types.MoYear], + to *vector.FunctionResult[T], length int, selectList *FunctionSelectList, +) error { + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.Append(0, true); err != nil { + return err + } + continue + } + if err := to.Append(T(v), false); err != nil { + return err + } + } + return nil +} + +func yearToStr(ctx context.Context, + from vector.FunctionParameterWrapper[types.MoYear], + to *vector.FunctionResult[types.Varlena], length int, toType types.Type, +) error { + totype := to.GetType() + destLen := int(totype.Width) + for i := uint64(0); i < uint64(length); i++ { + v, null := from.GetValue(i) + if null { + if err := to.AppendBytes(nil, true); err != nil { + return err + } + continue + } + value := []byte(v.String()) + if toType.Oid == types.T_binary && toType.Scale == -1 { + if err := explicitCastToBinary(toType, value, false, to); err != nil { + return err + } + continue + } + if toType.Oid != types.T_text && destLen != 0 && utf8.RuneCount(value) > destLen { + return formatCastError(ctx, from.GetSourceVector(), totype, fmt.Sprintf( + "Src length %v is larger than Dest length %v", len(value), destLen)) + } + if err := to.AppendBytes(value, false); err != nil { + return err + } + } + return nil +} + func strToBool( from vector.FunctionParameterWrapper[types.Varlena], to *vector.FunctionResult[bool], length int, selectList *FunctionSelectList) error { @@ -4715,10 +5398,6 @@ func strToStr( } return nil } - // Get source type to check if it's TEXT - fromType := from.GetSourceVector().GetType() - isSourceText := fromType.Oid == types.T_text - if totype.Oid != types.T_text && destLen != 0 { for i = 0; i < l; i++ { v, null := from.GetStrValue(i) @@ -4728,26 +5407,8 @@ func strToStr( } continue } - // check the length. s := convertByteSliceToString(v) - // For explicit CAST operations (e.g., CAST(text_col AS CHAR(1))), we should - // always perform length validation, even if source is TEXT, because the user - // explicitly requested a specific type with a length limit. - // - // However, for implicit conversions in UPDATE statements where the target - // column is actually TEXT but misidentified as CHAR/VARCHAR, we should skip - // length validation. We distinguish this by checking the target width: - // - Small widths (like 1, 10, etc.) are likely explicit CASTs and should be validated - // - Large widths (>= 255) might be misidentified TEXT columns in UPDATE operations - // - // The threshold of 255 is chosen because: - // 1. It's a common default width for TEXT columns that get misidentified - // 2. Explicit CASTs to CHAR(255) are rare, and when they occur, the user - // likely expects validation (though we skip it for compatibility) - // 3. This allows UPDATE operations on TEXT columns to work correctly - shouldSkipLengthCheck := isSourceText && (toType.Oid == types.T_char || toType.Oid == types.T_varchar) && destLen >= 255 - - if !shouldSkipLengthCheck && utf8.RuneCountInString(s) > destLen { + if utf8.RuneCountInString(s) > destLen { return formatCastError(ctx, from.GetSourceVector(), totype, fmt.Sprintf( "Src length %v is larger than Dest length %v", len(s), destLen)) } @@ -4862,7 +5523,9 @@ func blobToArray[T types.RealNumbers]( } } else { arr := types.BytesToArray[T](v) - if int(toType.Width) != len(arr) { + // bypass the dimension check if width is max dimension — + // mirrors strToArray for unsized ARRAY targets. + if int(toType.Width) != types.MaxArrayDimension && int(toType.Width) != len(arr) { return moerr.NewArrayDefMismatchNoCtx(int(toType.Width), len(arr)) } @@ -4875,12 +5538,14 @@ func blobToArray[T types.RealNumbers]( } func arrayToArray[I types.RealNumbers, O types.RealNumbers]( - _ context.Context, + ctx context.Context, from vector.FunctionParameterWrapper[types.Varlena], to *vector.FunctionResult[types.Varlena], length int, _ types.Type) error { var i uint64 var l = uint64(length) + targetWidth := int(to.GetType().Width) + for i = 0; i < l; i++ { v, null := from.GetStrValue(i) if null { @@ -4890,18 +5555,16 @@ func arrayToArray[I types.RealNumbers, O types.RealNumbers]( continue } - // NOTE: During ARRAY --> ARRAY conversion, if you do width check - // `to.GetType().Width != from.GetType().Width` - // cases b/b and b+sqrt(b) fails. + _v := types.BytesToArray[I](v) + if targetWidth > 0 && targetWidth != types.MaxArrayDimension && len(_v) != targetWidth { + return moerr.NewOutOfRangef(ctx, "array", "array dimension %d does not match target dimension %d", len(_v), targetWidth) + } if from.GetType().Oid == to.GetType().Oid { - // Eg:- VECF32(3) --> VECF32(3) if err := to.AppendBytes(v, false); err != nil { return err } } else { - // Eg:- VECF32(3) --> VECF64(3) - _v := types.BytesToArray[I](v) cast, err := moarray.Cast[I, O](_v) if err != nil { return err @@ -5364,50 +6027,66 @@ func overflowForNumericToNumeric[T1, T2 constraints.Integer | constraints.Float] switch ri.(type) { case *int8: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxInt8 { - return moerr.NewOutOfRangef(ctx, "int8", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), math.MinInt8, math.MaxInt8, "int8"); err != nil { + return err + } } } case *int16: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxInt16 { - return moerr.NewOutOfRangef(ctx, "int16", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), math.MinInt16, math.MaxInt16, "int16"); err != nil { + return err + } } } case *int32: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxInt32 { - return moerr.NewOutOfRangef(ctx, "int32", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), math.MinInt32, math.MaxInt32, "int32"); err != nil { + return err + } } } case *int64: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxInt64 { - return moerr.NewOutOfRangef(ctx, "int64", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), math.MinInt64, math.MaxInt64, "int64"); err != nil { + return err + } } } case *uint8: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxUint8 { - return moerr.NewOutOfRangef(ctx, "uint8", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), 0, math.MaxUint8, "uint8"); err != nil { + return err + } } } case *uint16: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxUint16 { - return moerr.NewOutOfRangef(ctx, "uint16", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), 0, math.MaxUint16, "uint16"); err != nil { + return err + } } } case *uint32: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxUint32 { - return moerr.NewOutOfRangef(ctx, "uint32", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), 0, math.MaxUint32, "uint32"); err != nil { + return err + } } } case *uint64: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(float64(x)) > math.MaxUint64 { - return moerr.NewOutOfRangef(ctx, "uint64", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, float64(x), 0, math.MaxUint64, "uint64"); err != nil { + return err + } } } } @@ -5416,56 +6095,71 @@ func overflowForNumericToNumeric[T1, T2 constraints.Integer | constraints.Float] switch ri.(type) { case *int8: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxInt8 { - return moerr.NewOutOfRangef(ctx, "int8", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, math.MinInt8, math.MaxInt8, "int8"); err != nil { + return err + } } } case *int16: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxInt16 { - return moerr.NewOutOfRangef(ctx, "int16", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, math.MinInt16, math.MaxInt16, "int16"); err != nil { + return err + } } } case *int32: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxInt32 { - return moerr.NewOutOfRangef(ctx, "int32", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, math.MinInt32, math.MaxInt32, "int32"); err != nil { + return err + } } } case *int64: for i, x := range slice { - if !nsp.Contains(uint64(i)) && - (math.Round(x) > math.MaxInt64 || math.Round(x) < math.MinInt64) { - return moerr.NewOutOfRangef(ctx, "int64", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, math.MinInt64, math.MaxInt64, "int64"); err != nil { + return err + } } } case *uint8: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxUint8 { - return moerr.NewOutOfRangef(ctx, "uint8", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, 0, math.MaxUint8, "uint8"); err != nil { + return err + } } } case *uint16: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxUint16 { - return moerr.NewOutOfRangef(ctx, "uint16", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, 0, math.MaxUint16, "uint16"); err != nil { + return err + } } } case *uint32: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxUint32 { - return moerr.NewOutOfRangef(ctx, "uint32", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, 0, math.MaxUint32, "uint32"); err != nil { + return err + } } } case *uint64: for i, x := range slice { - if !nsp.Contains(uint64(i)) && math.Round(x) > math.MaxUint64 { - return moerr.NewOutOfRangef(ctx, "uint64", "value '%v'", x) + if !nsp.Contains(uint64(i)) { + if err := checkFloatForInteger(ctx, x, 0, math.MaxUint64, "uint64"); err != nil { + return err + } } } case *float32: for i, x := range slice { - if !nsp.Contains(uint64(i)) && x > math.MaxFloat32 { + if !nsp.Contains(uint64(i)) && (x > math.MaxFloat32 || x < -math.MaxFloat32) { return moerr.NewOutOfRangef(ctx, "float32", "value '%v'", x) } } @@ -5475,6 +6169,50 @@ func overflowForNumericToNumeric[T1, T2 constraints.Integer | constraints.Float] return nil } +// float64 boundaries for int64/uint64 are not exactly representable: +// - math.MaxInt64 = 2^63 - 1, but float64(math.MaxInt64) = 2^63. +// - math.MaxUint64 = 2^64 - 1, but float64(math.MaxUint64) = 2^64. +// +// So `rounded > float64(MaxInt64)` misses `rounded == 2^63` even though the +// real int64 range ends at 2^63 - 1, after which T2(float64) behaviour is +// implementation-defined. Reject using the smallest float that already +// overflows the integer range. Lower bounds (MinInt64, 0) are exactly +// representable, so a normal `<` comparison is fine. +var ( + maxInt64FloatExclusive = math.Pow(2, 63) // first float > MaxInt64 + maxUint64FloatExclusive = math.Pow(2, 64) // first float > MaxUint64 +) + +// checkFloatForInteger rejects NaN, Inf, and values that round outside the +// target integer range. For int64/uint64 the upper bound is compared against +// a pre-computed "smallest unrepresentable float" because float64 cannot +// represent MaxInt64 / MaxUint64 exactly; for all narrower targets the +// typed max is exactly representable and a regular > compare is sufficient. +func checkFloatForInteger(ctx context.Context, x, minV, maxV float64, typeName string) error { + if math.IsNaN(x) { + return moerr.NewOutOfRangef(ctx, typeName, "value 'NaN'") + } + if math.IsInf(x, 0) { + return moerr.NewOutOfRangef(ctx, typeName, "value '%v'", x) + } + rounded := math.Round(x) + switch typeName { + case "int64": + if rounded >= maxInt64FloatExclusive || rounded < minV { + return moerr.NewOutOfRangef(ctx, typeName, "value '%v'", x) + } + case "uint64": + if rounded >= maxUint64FloatExclusive || rounded < 0 { + return moerr.NewOutOfRangef(ctx, typeName, "value '%v'", x) + } + default: + if rounded > maxV || rounded < minV { + return moerr.NewOutOfRangef(ctx, typeName, "value '%v'", x) + } + } + return nil +} + func appendNulls[T types.FixedSizeT](result vector.FunctionResultWrapper, length int, selectList *FunctionSelectList) error { if r, ok := result.(*vector.FunctionResult[types.Varlena]); ok { var i uint64 diff --git a/pkg/sql/plan/function/func_cast_test.go b/pkg/sql/plan/function/func_cast_test.go index 8d4c104eff1e3..20a43ad05ddec 100644 --- a/pkg/sql/plan/function/func_cast_test.go +++ b/pkg/sql/plan/function/func_cast_test.go @@ -1978,20 +1978,20 @@ func Test_strToStr_TextToCharVarchar(t *testing.T) { errMsg string }{ { - name: "TEXT to CHAR(255) with length 260 - should succeed", + name: "TEXT to CHAR(255) with length 260 - should fail", inputs: []string{longString260}, fromType: types.T_text.ToType(), toType: types.New(types.T_char, 255, 0), - want: []string{longString260}, // Should keep original length - wantErr: false, + wantErr: true, + errMsg: "larger than Dest length", }, { - name: "TEXT to VARCHAR(255) with length 260 - should succeed", + name: "TEXT to VARCHAR(255) with length 260 - should fail", inputs: []string{longString260}, fromType: types.T_text.ToType(), toType: types.New(types.T_varchar, 255, 0), - want: []string{longString260}, // Should keep original length - wantErr: false, + wantErr: true, + errMsg: "larger than Dest length", }, { name: "TEXT to CHAR(255) with NULL - should handle NULL", @@ -2044,12 +2044,12 @@ func Test_strToStr_TextToCharVarchar(t *testing.T) { wantErr: false, }, { - name: "TEXT to CHAR(255) with multiple values", - inputs: []string{"short", longString260, "medium length string"}, + name: "TEXT to CHAR(255) with value exceeding limit", + inputs: []string{longString260}, fromType: types.T_text.ToType(), toType: types.New(types.T_char, 255, 0), - want: []string{"short", longString260, "medium length string"}, - wantErr: false, + wantErr: true, + errMsg: "larger than Dest length", }, } @@ -2112,6 +2112,598 @@ func Test_strToStr_TextToCharVarchar(t *testing.T) { } } +func Test_strToDecimal256(t *testing.T) { + mp := mpool.MustNewZero() + inputVec := testutil.MakeVarcharVector( + []string{"123456789012345678901234567890.1234", "", "1e+06"}, + []uint64{1}, + ) + defer inputVec.Free(mp) + + from := vector.GenerateFunctionStrParameter(inputVec) + resultType := types.New(types.T_decimal256, 65, 4) + to := vector.NewFunctionResultWrapper(resultType, mp).(*vector.FunctionResult[types.Decimal256]) + defer to.Free() + + require.NoError(t, to.PreExtendAndReset(3)) + require.NoError(t, strToDecimal256(from, to, 3, nil)) + + resultVec := to.GetResultVector() + require.True(t, resultVec.GetNulls().Contains(1)) + values := vector.MustFixedColNoTypeCheck[types.Decimal256](resultVec) + require.Equal(t, "123456789012345678901234567890.1234", values[0].Format(4)) + require.Equal(t, "1000000.0000", values[2].Format(4)) +} + +func TestDecimal256ToFloat64Cast(t *testing.T) { + ctx := context.Background() + fromType := types.New(types.T_decimal256, 65, 16) + toType := types.T_float64.ToType() + _, err := GetFunctionByName(ctx, "cast", []types.Type{fromType, toType}) + require.NoError(t, err) + + mp := mpool.MustNewZero() + inputVec := vector.NewVec(fromType) + defer inputVec.Free(mp) + + value, err := types.ParseDecimal256( + "12421512141241241241241241849912840129402.1241124124241241", + 65, + 16, + ) + require.NoError(t, err) + require.NoError(t, vector.AppendFixedList(inputVec, []types.Decimal256{value}, nil, mp)) + + targetVec := vector.NewVec(toType) + defer targetVec.Free(mp) + + result := vector.NewFunctionResultWrapper(toType, mp).(*vector.FunctionResult[float64]) + defer result.Free() + require.NoError(t, result.PreExtendAndReset(1)) + + proc := testutil.NewProcess(t) + require.NoError(t, NewCast([]*vector.Vector{inputVec, targetVec}, result, proc, 1, nil)) + + resultValues := vector.MustFixedColNoTypeCheck[float64](result.GetResultVector()) + require.InDelta(t, 1.2421512141241241e40, resultValues[0], 1e27) +} + +func TestYearCastHelpers(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + inputVec := testutil.MakeVarcharVector([]string{"69", "1901", "0"}, nil) + defer inputVec.Free(mp) + from := vector.GenerateFunctionStrParameter(inputVec) + to := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer to.Free() + + require.NoError(t, to.PreExtendAndReset(3)) + require.NoError(t, strToYear(ctx, from, to, 3, nil, types.T_varchar.ToType())) + + yearVec := to.GetResultVector() + years := vector.MustFixedColNoTypeCheck[types.MoYear](yearVec) + require.Equal(t, types.MoYear(2069), years[0]) + require.Equal(t, types.MoYear(1901), years[1]) + require.Equal(t, types.MoYear(0), years[2]) + + strResult := vector.NewFunctionResultWrapper(types.T_varchar.ToType(), mp).(*vector.FunctionResult[types.Varlena]) + defer strResult.Free() + require.NoError(t, strResult.PreExtendAndReset(3)) + require.NoError(t, yearToStr(ctx, vector.GenerateFunctionFixedTypeParameter[types.MoYear](yearVec), strResult, 3, types.T_varchar.ToType())) + strParam := vector.GenerateFunctionStrParameter(strResult.GetResultVector()) + got, null := strParam.GetStrValue(0) + require.False(t, null) + require.Equal(t, "2069", string(got)) +} + +func TestYearCastRejectsInvalidValues(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + inputVec := testutil.MakeVarcharVector([]string{"2156", "abcd"}, nil) + defer inputVec.Free(mp) + strResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer strResult.Free() + require.NoError(t, strResult.PreExtendAndReset(2)) + require.Error(t, strToYear(ctx, vector.GenerateFunctionStrParameter(inputVec), strResult, 2, nil, types.T_varchar.ToType())) + + // VARBINARY / BLOB payloads must not be NUL-trimmed: ['0', 0x00] must not + // be silently accepted as YEAR 0. + varBinPayload := []byte{'0', 0x00} + varBinVec := testutil.MakeVarcharVector([]string{string(varBinPayload)}, nil) + defer varBinVec.Free(mp) + varBinResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer varBinResult.Free() + require.NoError(t, varBinResult.PreExtendAndReset(1)) + require.Error(t, strToYear(ctx, vector.GenerateFunctionStrParameter(varBinVec), varBinResult, 1, nil, types.T_varbinary.ToType())) + + // Fixed-length BINARY right-pads with NUL; keep that behavior and still + // parse the logical value. '0' padded with NUL should become YEAR 0. + binVec := testutil.MakeVarcharVector([]string{string(varBinPayload)}, nil) + defer binVec.Free(mp) + binResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer binResult.Free() + require.NoError(t, binResult.PreExtendAndReset(1)) + require.NoError(t, strToYear(ctx, vector.GenerateFunctionStrParameter(binVec), binResult, 1, nil, types.T_binary.ToType())) + + intVec := vector.NewVec(types.T_int64.ToType()) + defer intVec.Free(mp) + require.NoError(t, vector.AppendFixedList(intVec, []int64{2156}, nil, mp)) + intResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer intResult.Free() + require.NoError(t, intResult.PreExtendAndReset(1)) + require.Error(t, integerToYear(ctx, vector.GenerateFunctionFixedTypeParameter[int64](intVec), intResult, 1, nil)) +} + +func TestFloatToYearRoundsBeforeRangeCheck(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + // 2155.6 should round to 2156 and be rejected as out-of-range (not silently + // truncated to 2155 as the old int64(v) cast did). + floatVec := vector.NewVec(types.T_float64.ToType()) + defer floatVec.Free(mp) + require.NoError(t, vector.AppendFixedList(floatVec, []float64{2155.6}, nil, mp)) + floatResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer floatResult.Free() + require.NoError(t, floatResult.PreExtendAndReset(1)) + require.Error(t, floatToYear(ctx, vector.GenerateFunctionFixedTypeParameter[float64](floatVec), floatResult, 1, nil)) + + // 2069.4 rounds to 2069, which maps to year 2069 via the century window. + okVec := vector.NewVec(types.T_float64.ToType()) + defer okVec.Free(mp) + require.NoError(t, vector.AppendFixedList(okVec, []float64{69.4}, nil, mp)) + okResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer okResult.Free() + require.NoError(t, okResult.PreExtendAndReset(1)) + require.NoError(t, floatToYear(ctx, vector.GenerateFunctionFixedTypeParameter[float64](okVec), okResult, 1, nil)) + years := vector.MustFixedColNoTypeCheck[types.MoYear](okResult.GetResultVector()) + require.Equal(t, types.MoYear(2069), years[0]) + + // NaN / Inf are rejected up front. + nanVec := vector.NewVec(types.T_float64.ToType()) + defer nanVec.Free(mp) + require.NoError(t, vector.AppendFixedList(nanVec, []float64{math.NaN()}, nil, mp)) + nanResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer nanResult.Free() + require.NoError(t, nanResult.PreExtendAndReset(1)) + require.Error(t, floatToYear(ctx, vector.GenerateFunctionFixedTypeParameter[float64](nanVec), nanResult, 1, nil)) + + // Null float propagates as null-year without error. + nullVec := vector.NewVec(types.T_float64.ToType()) + defer nullVec.Free(mp) + require.NoError(t, vector.AppendFixedList(nullVec, []float64{0}, []bool{true}, mp)) + nullResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer nullResult.Free() + require.NoError(t, nullResult.PreExtendAndReset(1)) + require.NoError(t, floatToYear(ctx, vector.GenerateFunctionFixedTypeParameter[float64](nullVec), nullResult, 1, nil)) + nullYears := vector.MustFixedColNoTypeCheck[types.MoYear](nullResult.GetResultVector()) + require.Equal(t, types.MoYear(0), nullYears[0]) +} + +// TestDecimalToFloatRangeCheckUsesFullPrecision exercises the boundary case +// where a decimal literal rounds to a float(W,S) range violation only when +// compared at full precision. 999.995 stored in decimal(30,3) must be +// rejected when cast to float(5,2) — but if the fixed-range check sees the +// float32-quantized value (~999.9949951) it will truncate to 999.99 and let +// it through. This guards the intentional re-parse-at-64 that +// decimal128ToFloat / decimal256ToFloat do when bitSize==32. +func TestDecimalToFloatRangeCheckUsesFullPrecision(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + // Custom-Width/Scale float types can't be used at vector allocation time + // (PreExtend trips a div-by-zero), so we create the result wrapper with + // the default float32 type and override with SetType before the cast. + floatTyp := types.Type{Oid: types.T_float32, Width: 5, Scale: 2} + + // decimal128 -> float32(5,2): 999.995 must raise out-of-range + d128Vec := vector.NewVec(types.T_decimal128.ToType()) + defer d128Vec.Free(mp) + d128, err := types.ParseDecimal128("999.995", 30, 3) + require.NoError(t, err) + require.NoError(t, vector.AppendFixedList(d128Vec, []types.Decimal128{d128}, nil, mp)) + d128Vec.SetType(types.Type{Oid: types.T_decimal128, Width: 30, Scale: 3}) + + f32Res := vector.NewFunctionResultWrapper(types.T_float32.ToType(), mp).(*vector.FunctionResult[float32]) + defer f32Res.Free() + require.NoError(t, f32Res.PreExtendAndReset(1)) + f32Res.GetResultVector().SetType(floatTyp) + err = decimal128ToFloat[float32]( + ctx, + vector.GenerateFunctionFixedTypeParameter[types.Decimal128](d128Vec), + f32Res, 1, 32) + require.Error(t, err, "decimal128(30,3)=999.995 must overflow float(5,2)") + require.Contains(t, err.Error(), "999.995", + "range-check error should reference the original decimal literal") + + // decimal256 -> float32(5,2): same guard + d256Vec := vector.NewVec(types.T_decimal256.ToType()) + defer d256Vec.Free(mp) + d256, err := types.ParseDecimal256("999.995", 65, 3) + require.NoError(t, err) + require.NoError(t, vector.AppendFixedList(d256Vec, []types.Decimal256{d256}, nil, mp)) + d256Vec.SetType(types.Type{Oid: types.T_decimal256, Width: 65, Scale: 3}) + + f32Res2 := vector.NewFunctionResultWrapper(types.T_float32.ToType(), mp).(*vector.FunctionResult[float32]) + defer f32Res2.Free() + require.NoError(t, f32Res2.PreExtendAndReset(1)) + f32Res2.GetResultVector().SetType(floatTyp) + err = decimal256ToFloat[float32]( + ctx, + vector.GenerateFunctionFixedTypeParameter[types.Decimal256](d256Vec), + f32Res2, 1, 32) + require.Error(t, err, "decimal256(65,3)=999.995 must overflow float(5,2)") + require.Contains(t, err.Error(), "999.995", + "range-check error should reference the original decimal literal") +} + +// TestDecimal256ToOthersRouting sanity-checks the cast-target matrix wired +// through decimal256ToOthers by invoking each helper with a small input. +// Having these helpers in place means CAST(decimal256_col AS VARCHAR) and +// similar statements no longer hit "unsupported cast". +func TestDecimal256ToOthersRouting(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + d256Typ := types.T_decimal256.ToType() + d256, err := types.ParseDecimal256("42", 65, 0) + require.NoError(t, err) + srcVec := vector.NewVec(d256Typ) + defer srcVec.Free(mp) + require.NoError(t, vector.AppendFixedList(srcVec, []types.Decimal256{d256}, nil, mp)) + src := vector.GenerateFunctionFixedTypeParameter[types.Decimal256](srcVec) + + // int64 + intRes := vector.NewFunctionResultWrapper(types.T_int64.ToType(), mp).(*vector.FunctionResult[int64]) + defer intRes.Free() + require.NoError(t, intRes.PreExtendAndReset(1)) + require.NoError(t, decimal256ToSigned[int64](ctx, src, intRes, 64, 1)) + require.Equal(t, int64(42), vector.MustFixedColNoTypeCheck[int64](intRes.GetResultVector())[0]) + + // uint32 + uRes := vector.NewFunctionResultWrapper(types.T_uint32.ToType(), mp).(*vector.FunctionResult[uint32]) + defer uRes.Free() + require.NoError(t, uRes.PreExtendAndReset(1)) + require.NoError(t, decimal256ToUnsigned[uint32](ctx, src, uRes, 32, 1)) + require.Equal(t, uint32(42), vector.MustFixedColNoTypeCheck[uint32](uRes.GetResultVector())[0]) + + // bit + bitRes := vector.NewFunctionResultWrapper(types.T_bit.ToType(), mp).(*vector.FunctionResult[uint64]) + defer bitRes.Free() + require.NoError(t, bitRes.PreExtendAndReset(1)) + require.NoError(t, decimal256ToBit(ctx, src, bitRes, 64, 1)) + require.Equal(t, uint64(42), vector.MustFixedColNoTypeCheck[uint64](bitRes.GetResultVector())[0]) + + // decimal64 + d64Res := vector.NewFunctionResultWrapper(types.T_decimal64.ToType(), mp).(*vector.FunctionResult[types.Decimal64]) + defer d64Res.Free() + require.NoError(t, d64Res.PreExtendAndReset(1)) + require.NoError(t, decimal256ToDecimal64(ctx, src, d64Res, 1)) + + // decimal128 + d128Res := vector.NewFunctionResultWrapper(types.T_decimal128.ToType(), mp).(*vector.FunctionResult[types.Decimal128]) + defer d128Res.Free() + require.NoError(t, d128Res.PreExtendAndReset(1)) + require.NoError(t, decimal256ToDecimal128(ctx, src, d128Res, 1)) + + // decimal256 -> decimal256 narrow + d256bRes := vector.NewFunctionResultWrapper(types.T_decimal256.ToType(), mp).(*vector.FunctionResult[types.Decimal256]) + defer d256bRes.Free() + require.NoError(t, d256bRes.PreExtendAndReset(1)) + require.NoError(t, decimal256ToDecimal256(src, d256bRes, 1)) + + // varchar + vcTyp := types.T_varchar.ToType() + vcTyp.Width = 64 + vcRes := vector.NewFunctionResultWrapper(vcTyp, mp).(*vector.FunctionResult[types.Varlena]) + defer vcRes.Free() + require.NoError(t, vcRes.PreExtendAndReset(1)) + require.NoError(t, decimal256ToStr(ctx, src, vcRes, 1, vcTyp)) + strParam := vector.GenerateFunctionStrParameter(vcRes.GetResultVector()) + got, null := strParam.GetStrValue(0) + require.False(t, null) + require.Equal(t, "42", string(got)) +} + +// TestDecimal256ToOthersDispatcher drives every arm of decimal256ToOthers, +// including the null/error branches inside each helper and the unsupported +// target-type fallback. This is what lights up the routing table's +// coverage the most — calling the helpers directly (as the routing test +// above does) skips the dispatcher case rows. +func TestDecimal256ToOthersDispatcher(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + d256Typ := types.T_decimal256.ToType() + buildSrc := func(values []types.Decimal256, nulls []bool) vector.FunctionParameterWrapper[types.Decimal256] { + srcVec := vector.NewVec(d256Typ) + t.Cleanup(func() { srcVec.Free(mp) }) + require.NoError(t, vector.AppendFixedList(srcVec, values, nulls, mp)) + return vector.GenerateFunctionFixedTypeParameter[types.Decimal256](srcVec) + } + + d42, err := types.ParseDecimal256("42", 65, 0) + require.NoError(t, err) + src := buildSrc([]types.Decimal256{d42}, nil) + + // Feed every supported Oid. We're not asserting numeric correctness here + // (that belongs in per-helper tests); the point is to execute each case + // branch of the switch so the dispatcher table is covered. + targets := []types.T{ + types.T_bit, + types.T_int8, types.T_int16, types.T_int32, types.T_int64, + types.T_uint8, types.T_uint16, types.T_uint32, types.T_uint64, + types.T_decimal64, types.T_decimal128, types.T_decimal256, + types.T_float32, types.T_float64, + types.T_char, types.T_varchar, types.T_blob, types.T_text, + types.T_binary, types.T_varbinary, types.T_datalink, + } + for _, oid := range targets { + toType := oid.ToType() + if oid == types.T_char || oid == types.T_varchar || oid == types.T_binary || + oid == types.T_varbinary { + toType.Width = 64 + } + res := vector.NewFunctionResultWrapper(toType, mp) + require.NoError(t, res.PreExtendAndReset(1)) + err := decimal256ToOthers(ctx, src, toType, res, 1, nil) + // Some combinations (e.g. 42 fits int8) are ok; others reject by + // design (e.g. too-narrow decimal). Either is fine — we just want + // the case to execute. + _ = err + res.Free() + } + + // Unsupported target hits the default arm. + err = decimal256ToOthers(ctx, src, types.T_uuid.ToType(), + vector.NewFunctionResultWrapper(types.T_uuid.ToType(), mp), 1, nil) + require.Error(t, err) + + // Null input lights up every helper's null-append arm. + srcNull := buildSrc([]types.Decimal256{{}}, []bool{true}) + for _, oid := range []types.T{ + types.T_bit, types.T_int16, types.T_uint16, + types.T_decimal64, types.T_decimal128, types.T_decimal256, + types.T_float32, types.T_varchar, + } { + toType := oid.ToType() + if oid == types.T_varchar { + toType.Width = 64 + } + res := vector.NewFunctionResultWrapper(toType, mp) + require.NoError(t, res.PreExtendAndReset(1)) + require.NoError(t, decimal256ToOthers(ctx, srcNull, toType, res, 1, nil)) + res.Free() + } + + // Out-of-range for narrow integer types goes through each helper's + // ParseInt/ParseUint error branch. + dLarge, err := types.ParseDecimal256("99999999999999", 65, 0) + require.NoError(t, err) + srcLarge := buildSrc([]types.Decimal256{dLarge}, nil) + for _, oid := range []types.T{types.T_int8, types.T_uint8, types.T_bit} { + toType := oid.ToType() + if oid == types.T_bit { + toType.Width = 4 + } + res := vector.NewFunctionResultWrapper(toType, mp) + require.NoError(t, res.PreExtendAndReset(1)) + require.Error(t, decimal256ToOthers(ctx, srcLarge, toType, res, 1, nil)) + res.Free() + } + + // decimal256ToStr with a small binary target exercises the Width-bound + // rejection path inside decimal256ToStr. + tinyBin := types.T_binary.ToType() + tinyBin.Width = 1 + res := vector.NewFunctionResultWrapper(tinyBin, mp) + require.NoError(t, res.PreExtendAndReset(1)) + // 42 is 2 characters, exceeds Width=1 — expect error. + require.Error(t, decimal256ToStr(ctx, src, res.(*vector.FunctionResult[types.Varlena]), 1, tinyBin)) + res.Free() +} + +func TestIntegerToYearAcrossWidths(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + // all integer widths feeding a valid and an invalid YEAR value + cases := []struct { + name string + valid int64 + valOK types.MoYear + invalid int64 + }{ + {"int8", 69, 2069, -1}, + {"int16", 2155, 2155, 2156}, + {"int32", 1901, 1901, 1900}, + {"int64", 69, 2069, 3000}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + okVec := vector.NewVec(types.T_int64.ToType()) + defer okVec.Free(mp) + require.NoError(t, vector.AppendFixedList(okVec, []int64{c.valid}, nil, mp)) + okResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer okResult.Free() + require.NoError(t, okResult.PreExtendAndReset(1)) + require.NoError(t, integerToYear(ctx, vector.GenerateFunctionFixedTypeParameter[int64](okVec), okResult, 1, nil)) + years := vector.MustFixedColNoTypeCheck[types.MoYear](okResult.GetResultVector()) + require.Equal(t, c.valOK, years[0]) + + badVec := vector.NewVec(types.T_int64.ToType()) + defer badVec.Free(mp) + require.NoError(t, vector.AppendFixedList(badVec, []int64{c.invalid}, nil, mp)) + badResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer badResult.Free() + require.NoError(t, badResult.PreExtendAndReset(1)) + require.Error(t, integerToYear(ctx, vector.GenerateFunctionFixedTypeParameter[int64](badVec), badResult, 1, nil)) + }) + } + + // null integer propagates as null-year. + nullVec := vector.NewVec(types.T_int64.ToType()) + defer nullVec.Free(mp) + require.NoError(t, vector.AppendFixedList(nullVec, []int64{0}, []bool{true}, mp)) + nullResult := vector.NewFunctionResultWrapper(types.T_year.ToType(), mp).(*vector.FunctionResult[types.MoYear]) + defer nullResult.Free() + require.NoError(t, nullResult.PreExtendAndReset(1)) + require.NoError(t, integerToYear(ctx, vector.GenerateFunctionFixedTypeParameter[int64](nullVec), nullResult, 1, nil)) + nullYears := vector.MustFixedColNoTypeCheck[types.MoYear](nullResult.GetResultVector()) + require.Equal(t, types.MoYear(0), nullYears[0]) +} + +func TestYearToStringPath(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + // year 2024 -> "2024" + yearVec := vector.NewVec(types.T_year.ToType()) + defer yearVec.Free(mp) + require.NoError(t, vector.AppendFixedList(yearVec, []types.MoYear{2024}, nil, mp)) + strResult := vector.NewFunctionResultWrapper(types.T_varchar.ToType(), mp).(*vector.FunctionResult[types.Varlena]) + defer strResult.Free() + require.NoError(t, strResult.PreExtendAndReset(1)) + require.NoError(t, yearToStr(ctx, vector.GenerateFunctionFixedTypeParameter[types.MoYear](yearVec), strResult, 1, types.T_varchar.ToType())) + strParam := vector.GenerateFunctionStrParameter(strResult.GetResultVector()) + got, null := strParam.GetStrValue(0) + require.False(t, null) + require.Equal(t, "2024", string(got)) + + // null year -> null string + nullYear := vector.NewVec(types.T_year.ToType()) + defer nullYear.Free(mp) + require.NoError(t, vector.AppendFixedList(nullYear, []types.MoYear{0}, []bool{true}, mp)) + nullStrResult := vector.NewFunctionResultWrapper(types.T_varchar.ToType(), mp).(*vector.FunctionResult[types.Varlena]) + defer nullStrResult.Free() + require.NoError(t, nullStrResult.PreExtendAndReset(1)) + require.NoError(t, yearToStr(ctx, vector.GenerateFunctionFixedTypeParameter[types.MoYear](nullYear), nullStrResult, 1, types.T_varchar.ToType())) +} + +func TestYearToOthersCoversSupportedNumericMatrix(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + yearVec := vector.NewVec(types.T_year.ToType()) + defer yearVec.Free(mp) + require.NoError(t, vector.AppendFixedList(yearVec, []types.MoYear{0}, nil, mp)) + from := vector.GenerateFunctionFixedTypeParameter[types.MoYear](yearVec) + + targets := []types.Type{ + types.T_int8.ToType(), + types.T_int16.ToType(), + types.T_int32.ToType(), + types.T_int64.ToType(), + types.T_uint8.ToType(), + types.T_uint16.ToType(), + types.T_uint32.ToType(), + types.T_uint64.ToType(), + types.T_float32.ToType(), + types.T_float64.ToType(), + types.T_char.ToType(), + types.T_varchar.ToType(), + types.T_blob.ToType(), + types.T_text.ToType(), + types.T_binary.ToType(), + types.T_varbinary.ToType(), + } + + for _, target := range targets { + t.Run(target.Oid.String(), func(t *testing.T) { + result := vector.NewFunctionResultWrapper(target, mp) + defer result.Free() + require.NoError(t, result.PreExtendAndReset(1)) + require.NoError(t, yearToOthers(ctx, from, target, result, 1, nil)) + require.False(t, result.GetResultVector().IsNull(0)) + }) + } +} + +func TestYearToIntegerRejectsOverflow(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + yearVec := vector.NewVec(types.T_year.ToType()) + defer yearVec.Free(mp) + require.NoError(t, vector.AppendFixedList(yearVec, []types.MoYear{2024}, nil, mp)) + from := vector.GenerateFunctionFixedTypeParameter[types.MoYear](yearVec) + + int8Result := vector.NewFunctionResultWrapper(types.T_int8.ToType(), mp).(*vector.FunctionResult[int8]) + defer int8Result.Free() + require.NoError(t, int8Result.PreExtendAndReset(1)) + require.Error(t, yearToOthers(ctx, from, types.T_int8.ToType(), int8Result, 1, nil)) + + uint8Result := vector.NewFunctionResultWrapper(types.T_uint8.ToType(), mp).(*vector.FunctionResult[uint8]) + defer uint8Result.Free() + require.NoError(t, uint8Result.PreExtendAndReset(1)) + require.Error(t, yearToOthers(ctx, from, types.T_uint8.ToType(), uint8Result, 1, nil)) + + int16Result := vector.NewFunctionResultWrapper(types.T_int16.ToType(), mp).(*vector.FunctionResult[int16]) + defer int16Result.Free() + require.NoError(t, int16Result.PreExtendAndReset(1)) + require.NoError(t, yearToOthers(ctx, from, types.T_int16.ToType(), int16Result, 1, nil)) +} + +func TestYearToStringRespectsTargetWidthAndBinaryPadding(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + yearVec := vector.NewVec(types.T_year.ToType()) + defer yearVec.Free(mp) + require.NoError(t, vector.AppendFixedList(yearVec, []types.MoYear{2024}, nil, mp)) + from := vector.GenerateFunctionFixedTypeParameter[types.MoYear](yearVec) + + charType := types.New(types.T_char, 2, 0) + charResult := vector.NewFunctionResultWrapper(charType, mp).(*vector.FunctionResult[types.Varlena]) + defer charResult.Free() + require.NoError(t, charResult.PreExtendAndReset(1)) + require.Error(t, yearToOthers(ctx, from, charType, charResult, 1, nil)) + + binaryType := types.New(types.T_binary, 6, -1) + binaryResult := vector.NewFunctionResultWrapper(binaryType, mp).(*vector.FunctionResult[types.Varlena]) + defer binaryResult.Free() + require.NoError(t, binaryResult.PreExtendAndReset(1)) + require.NoError(t, yearToOthers(ctx, from, binaryType, binaryResult, 1, nil)) + binaryParam := vector.GenerateFunctionStrParameter(binaryResult.GetResultVector()) + got, null := binaryParam.GetStrValue(0) + require.False(t, null) + require.Equal(t, []byte{'2', '0', '2', '4', 0, 0}, got) + + varbinaryType := types.New(types.T_varbinary, 4, 0) + varbinaryResult := vector.NewFunctionResultWrapper(varbinaryType, mp).(*vector.FunctionResult[types.Varlena]) + defer varbinaryResult.Free() + require.NoError(t, varbinaryResult.PreExtendAndReset(1)) + require.NoError(t, yearToOthers(ctx, from, varbinaryType, varbinaryResult, 1, nil)) + varbinaryParam := vector.GenerateFunctionStrParameter(varbinaryResult.GetResultVector()) + got, null = varbinaryParam.GetStrValue(0) + require.False(t, null) + require.Equal(t, []byte("2024"), got) +} + +func TestScalarNullToDecimal256(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + resultType := types.New(types.T_decimal256, 65, 4) + result := vector.NewFunctionResultWrapper(resultType, mp) + defer result.Free() + + require.NoError(t, result.PreExtendAndReset(1)) + require.NoError(t, scalarNullToOthers(ctx, resultType, result, 1, nil)) + require.True(t, result.GetResultVector().IsNull(0)) +} + +func TestAnyCastMatrixIncludesYearAndDecimal256(t *testing.T) { + ctx := context.Background() + _, err := GetFunctionByName(ctx, "cast", []types.Type{types.T_any.ToType(), types.T_year.ToType()}) + require.NoError(t, err) + + decimal256Type := types.New(types.T_decimal256, 65, 30) + _, err = GetFunctionByName(ctx, "cast", []types.Type{types.T_any.ToType(), decimal256Type}) + require.NoError(t, err) +} + // Test_strToArray_DimensionCheck tests that strToArray correctly validates // vector dimension against the target type's width (vecf32(N) / vecf64(N)). // This is the regression test for https://github.com/matrixorigin/matrixone/issues/23872 @@ -2187,6 +2779,51 @@ func Test_strToArray_DimensionCheck(t *testing.T) { require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc5.info, info)) } +// TestBlobToArray_UnsizedBypassDim checks that blobToArray accepts any +// dimension when the target ARRAY is unsized (toType.Width == +// MaxArrayDimension), matching strToArray's behavior. +func TestBlobToArray_UnsizedBypassDim(t *testing.T) { + proc := testutil.NewProcess(t) + + // Encode a 5-element float32 array as blob bytes; target is + // unsized ARRAY — should NOT error on dimension. + arr := []float32{1, 2, 3, 4, 5} + blob := types.ArrayToBytes[float32](arr) + + rs := vector.NewFunctionResultWrapper(types.T_array_float32.ToType(), proc.Mp()) + defer rs.Free() + require.NoError(t, rs.PreExtendAndReset(1)) + + src := vector.NewVec(types.T_blob.ToType()) + require.NoError(t, vector.AppendBytes(src, blob, false, proc.Mp())) + dst := vector.NewVec(types.T_array_float32.ToType()) + + require.NoError(t, NewCast([]*vector.Vector{src, dst}, rs, proc, 1, nil)) + + got := vector.MustArrayCol[float32](rs.GetResultVector()) + require.Equal(t, [][]float32{arr}, got) +} + +// TestBlobToArray_SizedDimMismatch verifies the existing sized path +// still rejects mismatched dimensions. +func TestBlobToArray_SizedDimMismatch(t *testing.T) { + proc := testutil.NewProcess(t) + + arr := []float32{1, 2, 3, 4, 5} + blob := types.ArrayToBytes[float32](arr) + + rs := vector.NewFunctionResultWrapper(types.New(types.T_array_float32, 3, 0), proc.Mp()) + defer rs.Free() + require.NoError(t, rs.PreExtendAndReset(1)) + + src := vector.NewVec(types.T_blob.ToType()) + require.NoError(t, vector.AppendBytes(src, blob, false, proc.Mp())) + dst := vector.NewVec(types.New(types.T_array_float32, 3, 0)) + + err := NewCast([]*vector.Vector{src, dst}, rs, proc, 1, nil) + require.Error(t, err) +} + func TestCastJsonLargeIntegerPrecision(t *testing.T) { proc := testutil.NewProcess(t) @@ -2357,3 +2994,317 @@ func TestCastJsonStringNumeric(t *testing.T) { }, bad, proc, 1, nil) require.Error(t, err) } + +// TestFloatCastNegativeOverflowAndNaN asserts that float32/float64 -> float32 +// rejects both positive and negative magnitude overflow, and that float -> +// integer rejects NaN, +/-Inf, and negative overflow (not just positive). +// Prior to this fix only the positive bound was checked. +func TestFloatCastNegativeOverflowAndNaN(t *testing.T) { + ctx := context.Background() + + // float64 -> float32: negative overflow must be rejected symmetrically. + require.Error(t, + OverflowForNumericToNumeric[float64, float32](ctx, []float64{-math.MaxFloat32 * 2}, nil), + "float64=-large must not silently narrow to -Inf") + require.NoError(t, + OverflowForNumericToNumeric[float64, float32](ctx, []float64{math.MaxFloat32}, nil)) + + // float64 -> int8: NaN, +/-Inf, and negative overflow must all fail. + require.Error(t, + OverflowForNumericToNumeric[float64, int8](ctx, []float64{math.NaN()}, nil), + "NaN must not be converted to an integer silently") + require.Error(t, + OverflowForNumericToNumeric[float64, int8](ctx, []float64{math.Inf(1)}, nil)) + require.Error(t, + OverflowForNumericToNumeric[float64, int8](ctx, []float64{math.Inf(-1)}, nil)) + require.Error(t, + OverflowForNumericToNumeric[float64, int8](ctx, []float64{-1e9}, nil), + "negative overflow must be caught, not only positive") + require.NoError(t, + OverflowForNumericToNumeric[float64, int8](ctx, []float64{-128}, nil)) + + // float64 -> uint8: negative values must fail. + require.Error(t, + OverflowForNumericToNumeric[float64, uint8](ctx, []float64{-1}, nil), + "negative float must not fit into unsigned integer") + + // float32 versions (smaller ranges exercise the helper the same way). + require.Error(t, + OverflowForNumericToNumeric[float32, int16](ctx, []float32{float32(math.Inf(1))}, nil)) + require.Error(t, + OverflowForNumericToNumeric[float32, int16](ctx, []float32{-40000}, nil)) +} + +// TestFloatToInt64Uint64BoundaryPrecision guards the precision hole around +// 2^63 / 2^64 where math.MaxInt64 / math.MaxUint64 are not exactly +// representable as float64. Before the fix, float64(2^63) passed the +// "rounded > float64(MaxInt64)" test (since float64(MaxInt64) == 2^63) and +// then int64(2^63) produced an implementation-defined wrap-around. +func TestFloatToInt64Uint64BoundaryPrecision(t *testing.T) { + ctx := context.Background() + + // 2^63 is the smallest float > MaxInt64; must be rejected. + require.Error(t, + OverflowForNumericToNumeric[float64, int64](ctx, []float64{math.Pow(2, 63)}, nil), + "float64(2^63) -> int64 must be rejected, not cast to MinInt64") + + // The largest float64 that is <= MaxInt64 is 9223372036854774784 + // (= 2^63 - 1024). That must still pass. + require.NoError(t, + OverflowForNumericToNumeric[float64, int64](ctx, []float64{9223372036854774784}, nil)) + + // 2^64 is the smallest float > MaxUint64; must be rejected. + require.Error(t, + OverflowForNumericToNumeric[float64, uint64](ctx, []float64{math.Pow(2, 64)}, nil), + "float64(2^64) -> uint64 must be rejected, not wrap to 0") + + // The largest exactly-representable float64 below 2^64 is + // 18446744073709549568 (= 2^64 - 2048). Must still pass. + require.NoError(t, + OverflowForNumericToNumeric[float64, uint64](ctx, []float64{18446744073709549568}, nil)) + + // -1 rejected for uint64. + require.Error(t, + OverflowForNumericToNumeric[float64, uint64](ctx, []float64{-1}, nil)) +} + +// TestNumericToBitRejectsInvalidFloat ensures cast(x as bit(n)) for a +// float source rejects NaN, Inf, negative values, and values above +// uint64's range — previously uint64(math.Round(...)) silently produced +// 0 or a bit-wrapped value for those inputs. +func TestNumericToBitRejectsInvalidFloat(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + run := func(t *testing.T, val float64, wantErr bool, description string) { + vec := vector.NewVec(types.T_float64.ToType()) + defer vec.Free(mp) + require.NoError(t, vector.AppendFixedList(vec, []float64{val}, nil, mp)) + from := vector.GenerateFunctionFixedTypeParameter[float64](vec) + bitRes := vector.NewFunctionResultWrapper(types.T_bit.ToType(), mp).(*vector.FunctionResult[uint64]) + defer bitRes.Free() + require.NoError(t, bitRes.PreExtendAndReset(1)) + err := numericToBit[float64](ctx, from, bitRes, 64, 1, nil) + if wantErr { + require.Error(t, err, description) + } else { + require.NoError(t, err, description) + } + } + + run(t, math.NaN(), true, "NaN -> bit must be rejected") + run(t, math.Inf(1), true, "+Inf -> bit must be rejected") + run(t, math.Inf(-1), true, "-Inf -> bit must be rejected") + run(t, -1.0, true, "negative float -> bit must be rejected") + run(t, 1e30, true, "above uint64 range -> bit must be rejected") + // 2^64 is the smallest float > MaxUint64; must be rejected (regression + // guard for the float64(MaxUint64) imprecision). + run(t, math.Pow(2, 64), true, "float64(2^64) -> bit must be rejected") + run(t, 3.0, false, "valid small float rounds to 3") +} + +func Test_strToSigned_Binary_NarrowOverflow(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + tests := []struct { + name string + input []byte + bitSize int + wantErr bool + }{ + {"int8 max valid", []byte{0x7F}, 8, false}, + {"int8 overflow 128", []byte{0x00, 0x80}, 8, true}, + {"int16 max valid", []byte{0x7F, 0xFF}, 16, false}, + {"int16 overflow 32768", []byte{0x00, 0x80, 0x00}, 16, true}, + {"int32 max valid", []byte{0x7F, 0xFF, 0xFF, 0xFF}, 32, false}, + {"int32 overflow", []byte{0x00, 0x80, 0x00, 0x00, 0x00}, 32, true}, + {"int64 valid small", []byte{0x01, 0x00}, 64, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + inputVec := testutil.MakeVarlenaVector([][]byte{tt.input}, nil, mp) + defer inputVec.Free(mp) + inputVec.SetIsBin(true) + + from := vector.GenerateFunctionStrParameter(inputVec) + resultType := types.T_int64.ToType() + to := vector.NewFunctionResultWrapper(resultType, mp).(*vector.FunctionResult[int64]) + defer to.Free() + require.NoError(t, to.PreExtendAndReset(1)) + + err := strToSigned(ctx, from, to, tt.bitSize, 1, nil) + if tt.wantErr { + require.Error(t, err) + require.Contains(t, err.Error(), "out of range") + } else { + require.NoError(t, err) + } + }) + } +} + +func Test_strToUnsigned_Binary_NarrowOverflow(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + tests := []struct { + name string + input []byte + bitSize int + wantErr bool + }{ + {"uint8 max valid 255", []byte{0xFF}, 8, false}, + {"uint8 overflow 256", []byte{0x01, 0x00}, 8, true}, + {"uint16 max valid", []byte{0xFF, 0xFF}, 16, false}, + {"uint16 overflow", []byte{0x01, 0x00, 0x00}, 16, true}, + {"uint32 max valid", []byte{0xFF, 0xFF, 0xFF, 0xFF}, 32, false}, + {"uint32 overflow", []byte{0x01, 0x00, 0x00, 0x00, 0x00}, 32, true}, + {"uint64 valid small", []byte{0x01, 0x00}, 64, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + inputVec := testutil.MakeVarlenaVector([][]byte{tt.input}, nil, mp) + defer inputVec.Free(mp) + inputVec.SetIsBin(true) + + from := vector.GenerateFunctionStrParameter(inputVec) + resultType := types.T_uint64.ToType() + to := vector.NewFunctionResultWrapper(resultType, mp).(*vector.FunctionResult[uint64]) + defer to.Free() + require.NoError(t, to.PreExtendAndReset(1)) + + err := strToUnsigned(ctx, from, to, tt.bitSize, 1, nil) + if tt.wantErr { + require.Error(t, err) + require.Contains(t, err.Error(), "out of range") + } else { + require.NoError(t, err) + } + }) + } +} + +func Test_arrayToArray_WidthCheck(t *testing.T) { + proc := testutil.NewProcess(t) + + // vecf32(3) -> vecf32(3): dimension match should succeed + tc1 := tcTemp{ + info: "vecf32(3) -> vecf32(3) - match", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 3, 0), [][]float32{{1, 2, 3}}, nil), + NewFunctionTestInput(types.New(types.T_array_float32, 3, 0), [][]float32{}, nil), + }, + expect: NewFunctionTestResult(types.New(types.T_array_float32, 3, 0), false, + [][]float32{{1, 2, 3}}, []bool{false}), + } + fcTC := NewFunctionTestCase(proc, tc1.inputs, tc1.expect, NewCast) + s, info := fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc1.info, info)) + + // vecf32(5) -> vecf32(3): dimension mismatch should fail + tc2 := tcTemp{ + info: "vecf32(5) -> vecf32(3) - mismatch should error", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 5, 0), [][]float32{{1, 2, 3, 4, 5}}, nil), + NewFunctionTestInput(types.New(types.T_array_float32, 3, 0), [][]float32{}, nil), + }, + expect: NewFunctionTestResult(types.New(types.T_array_float32, 3, 0), true, nil, nil), + } + fcTC = NewFunctionTestCase(proc, tc2.inputs, tc2.expect, NewCast) + s, info = fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc2.info, info)) + + // vecf32(3) -> vecf64(3): cross-type with matching width should succeed + tc3 := tcTemp{ + info: "vecf32(3) -> vecf64(3) - cross-type match", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 3, 0), [][]float32{{1, 2, 3}}, nil), + NewFunctionTestInput(types.New(types.T_array_float64, 3, 0), [][]float64{}, nil), + }, + expect: NewFunctionTestResult(types.New(types.T_array_float64, 3, 0), false, + [][]float64{{1, 2, 3}}, []bool{false}), + } + fcTC = NewFunctionTestCase(proc, tc3.inputs, tc3.expect, NewCast) + s, info = fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc3.info, info)) + + // vecf32(5) -> vecf64(3): cross-type with mismatching width should fail + tc4 := tcTemp{ + info: "vecf32(5) -> vecf64(3) - cross-type mismatch should error", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 5, 0), [][]float32{{1, 2, 3, 4, 5}}, nil), + NewFunctionTestInput(types.New(types.T_array_float64, 3, 0), [][]float64{}, nil), + }, + expect: NewFunctionTestResult(types.New(types.T_array_float64, 3, 0), true, nil, nil), + } + fcTC = NewFunctionTestCase(proc, tc4.inputs, tc4.expect, NewCast) + s, info = fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc4.info, info)) + + // vecf32(3) -> vecf32(unsized/MaxDim): should succeed (bypass dimension check) + tc5 := tcTemp{ + info: "vecf32(3) -> vecf32(MaxDim) - unsized target should accept any dimension", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 3, 0), [][]float32{{1, 2, 3}}, nil), + NewFunctionTestInput(types.T_array_float32.ToType(), [][]float32{}, nil), + }, + expect: NewFunctionTestResult(types.T_array_float32.ToType(), false, + [][]float32{{1, 2, 3}}, []bool{false}), + } + fcTC = NewFunctionTestCase(proc, tc5.inputs, tc5.expect, NewCast) + s, info = fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc5.info, info)) + + // vecf32(5) -> vecf64(unsized/MaxDim): cross-type unsized should succeed + tc6 := tcTemp{ + info: "vecf32(5) -> vecf64(MaxDim) - cross-type unsized should accept any dimension", + inputs: []FunctionTestInput{ + NewFunctionTestInput(types.New(types.T_array_float32, 5, 0), [][]float32{{1, 2, 3, 4, 5}}, nil), + NewFunctionTestInput(types.T_array_float64.ToType(), [][]float64{}, nil), + }, + expect: NewFunctionTestResult(types.T_array_float64.ToType(), false, + [][]float64{{1, 2, 3, 4, 5}}, []bool{false}), + } + fcTC = NewFunctionTestCase(proc, tc6.inputs, tc6.expect, NewCast) + s, info = fcTC.Run() + require.True(t, s, fmt.Sprintf("case is '%s', err info is '%s'", tc6.info, info)) +} + +func Test_strToStr_TextLengthCheck(t *testing.T) { + ctx := context.Background() + mp := mpool.MustNewZero() + + // TEXT -> VARCHAR(5): value fits, should succeed + inputVec := testutil.MakeVarlenaVector([][]byte{[]byte("hello")}, nil, mp) + defer inputVec.Free(mp) + inputVec.GetType().Oid = types.T_text + + from := vector.GenerateFunctionStrParameter(inputVec) + toType := types.New(types.T_varchar, 5, 0) + resultVec := vector.NewFunctionResultWrapper(toType, mp) + to := resultVec.(*vector.FunctionResult[types.Varlena]) + defer to.Free() + require.NoError(t, to.PreExtendAndReset(1)) + + err := strToStr(ctx, from, to, 1, toType) + require.NoError(t, err) + + // TEXT -> VARCHAR(3): value too long, should fail + inputVec2 := testutil.MakeVarlenaVector([][]byte{[]byte("hello")}, nil, mp) + defer inputVec2.Free(mp) + inputVec2.GetType().Oid = types.T_text + + from2 := vector.GenerateFunctionStrParameter(inputVec2) + toType2 := types.New(types.T_varchar, 3, 0) + resultVec2 := vector.NewFunctionResultWrapper(toType2, mp) + to2 := resultVec2.(*vector.FunctionResult[types.Varlena]) + defer to2.Free() + require.NoError(t, to2.PreExtendAndReset(1)) + + err = strToStr(ctx, from2, to2, 1, toType2) + require.Error(t, err) + require.Contains(t, err.Error(), "larger than Dest length") +} diff --git a/pkg/sql/plan/make.go b/pkg/sql/plan/make.go index 790c5eebb260e..1830f617d5691 100644 --- a/pkg/sql/plan/make.go +++ b/pkg/sql/plan/make.go @@ -16,9 +16,11 @@ package plan import ( "context" + "strings" "unicode/utf8" "github.com/matrixorigin/matrixone/pkg/catalog" + "github.com/matrixorigin/matrixone/pkg/common/moerr" "github.com/matrixorigin/matrixone/pkg/common/mpool" "github.com/matrixorigin/matrixone/pkg/container/types" "github.com/matrixorigin/matrixone/pkg/container/vector" @@ -64,25 +66,41 @@ func MakePlan2Decimal128ExprWithType(v types.Decimal128, typ *Type) *plan.Expr { } func makePlan2DecimalExprWithType(ctx context.Context, v string, isBin ...bool) (*plan.Expr, error) { - _, scale, err := types.Parse128(v) - if err != nil { - return nil, err - } var typ plan.Type - if scale < 18 && len(v) < 18 { + _, scale, err := types.Parse128(v) + if err == nil && scale < 18 && len(v) < 18 { typ = plan.Type{ Id: int32(types.T_decimal64), Width: 18, Scale: scale, NotNullable: true, } - } else { + } else if err == nil { typ = plan.Type{ Id: int32(types.T_decimal128), Width: 38, Scale: scale, NotNullable: true, } + } else { + // Only retry with Decimal256 when Parse128 failed because the value + // overflowed Decimal128's width (message contains "beyond the + // range"). For malformed inputs like "abc" or "1.2.3" the 128-bit + // error is already the right diagnostic — returning the 256-bit + // "beyond the range" message would mislead the user. + if !strings.Contains(err.Error(), "beyond the range") { + return nil, err + } + _, scale, err = types.Parse256(v) + if err != nil { + return nil, err + } + typ = plan.Type{ + Id: int32(types.T_decimal256), + Width: 65, + Scale: scale, + NotNullable: true, + } } return appendCastBeforeExpr(ctx, makePlan2StringConstExprWithType(v, isBin...), typ) } @@ -549,6 +567,12 @@ func MakePlan2NullTextConstExprWithType(v string) *plan.Expr { func makePlan2CastExpr(ctx context.Context, expr *Expr, targetType Type) (*Expr, error) { var err error + if isSetPlanType(&targetType) { + expr, err = funcCastForSetType(ctx, expr, targetType) + if err != nil { + return nil, err + } + } if isSameColumnType(expr.Typ, targetType) { return expr, nil } @@ -625,6 +649,228 @@ func funcCastForEnumType(ctx context.Context, expr *Expr, targetType Type) (*Exp return expr, nil } +func funcCastForSetType(ctx context.Context, expr *Expr, targetType Type) (*Expr, error) { + if !isSetPlanType(&targetType) { + return expr, nil + } + + lit := expr.GetLit() + if lit == nil || lit.Isnull { + return expr, nil + } + + switch value := lit.Value.(type) { + case *plan.Literal_Sval: + bits, err := types.ParseSet(targetType.Enumvalues, value.Sval) + if err != nil { + return nil, err + } + expr = makePlan2Uint64ConstExprWithType(bits) + expr.Typ = targetType + return expr, nil + case *plan.Literal_U64Val: + if _, err := types.ParseSetValue(targetType.Enumvalues, value.U64Val); err != nil { + return nil, err + } + expr = makePlan2Uint64ConstExprWithType(value.U64Val) + expr.Typ = targetType + return expr, nil + case *plan.Literal_I8Val: + return funcCastSignedLiteralForSetType(ctx, int64(value.I8Val), targetType) + case *plan.Literal_I16Val: + return funcCastSignedLiteralForSetType(ctx, int64(value.I16Val), targetType) + case *plan.Literal_I32Val: + return funcCastSignedLiteralForSetType(ctx, int64(value.I32Val), targetType) + case *plan.Literal_I64Val: + return funcCastSignedLiteralForSetType(ctx, value.I64Val, targetType) + case *plan.Literal_U8Val: + bits := uint64(value.U8Val) + if _, err := types.ParseSetValue(targetType.Enumvalues, bits); err != nil { + return nil, err + } + expr = makePlan2Uint64ConstExprWithType(bits) + expr.Typ = targetType + return expr, nil + case *plan.Literal_U16Val: + bits := uint64(value.U16Val) + if _, err := types.ParseSetValue(targetType.Enumvalues, bits); err != nil { + return nil, err + } + expr = makePlan2Uint64ConstExprWithType(bits) + expr.Typ = targetType + return expr, nil + case *plan.Literal_U32Val: + bits := uint64(value.U32Val) + if _, err := types.ParseSetValue(targetType.Enumvalues, bits); err != nil { + return nil, err + } + expr = makePlan2Uint64ConstExprWithType(bits) + expr.Typ = targetType + return expr, nil + case *plan.Literal_Fval: + return funcCastFloatLiteralForSetType(ctx, float64(value.Fval), targetType) + case *plan.Literal_Dval: + return funcCastFloatLiteralForSetType(ctx, value.Dval, targetType) + case *plan.Literal_Decimal64Val: + return funcCastDecimal64LiteralForSetType(ctx, value.Decimal64Val, expr.Typ.Scale, targetType) + case *plan.Literal_Decimal128Val: + return funcCastDecimal128LiteralForSetType(ctx, value.Decimal128Val, expr.Typ.Scale, targetType) + } + + // Any literal shape we do not recognise (e.g. bytes, date/time, array) + // cannot be safely coerced to a SET member — reject instead of + // silently passing through, which would otherwise bypass both + // member-name lookup and numeric-bits validation. + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") +} + +func funcCastSignedLiteralForSetType(ctx context.Context, value int64, targetType Type) (*Expr, error) { + if value < 0 { + return nil, moerr.NewInvalidInputf(ctx, "convert to MySQL set failed: negative value %d", value) + } + bits := uint64(value) + if _, err := types.ParseSetValue(targetType.Enumvalues, bits); err != nil { + return nil, err + } + expr := makePlan2Uint64ConstExprWithType(bits) + expr.Typ = targetType + return expr, nil +} + +// funcCastFloatLiteralForSetType rejects non-integer floats (e.g. 1.5, 1e-1) +// because SET values are bitsets and only make sense as whole non-negative +// integers. NaN/Inf are also rejected. A clean integer float is re-dispatched +// through the signed-literal path so it goes through ParseSetValue and fails +// if the bits reference a non-existent member. +func funcCastFloatLiteralForSetType(ctx context.Context, value float64, targetType Type) (*Expr, error) { + if value != value { // NaN check without importing math + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") + } + if value < 0 || value > float64(^uint64(0)) { + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") + } + if value != float64(int64(value)) { + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") + } + return funcCastSignedLiteralForSetType(ctx, int64(value), targetType) +} + +// funcCastDecimal64LiteralForSetType accepts a decimal64 literal only when +// its fractional digits are all zero (so it is a whole number) and the +// integer bits reference an existing SET member. +func funcCastDecimal64LiteralForSetType(ctx context.Context, v *plan.Decimal64, scale int32, targetType Type) (*Expr, error) { + if v == nil { + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") + } + d64 := types.Decimal64(uint64(v.A)) + intPart, err := decimal64ToIntegerBitsForSet(d64, scale) + if err != nil { + return nil, err + } + return funcCastSignedLiteralForSetType(ctx, intPart, targetType) +} + +// funcCastDecimal128LiteralForSetType mirrors the decimal64 path. +func funcCastDecimal128LiteralForSetType(ctx context.Context, v *plan.Decimal128, scale int32, targetType Type) (*Expr, error) { + if v == nil { + return nil, moerr.NewInvalidInputf(ctx, "invalid default value for SET column") + } + d128 := types.Decimal128{B0_63: uint64(v.A), B64_127: uint64(v.B)} + intPart, err := decimal128ToIntegerBitsForSet(d128, scale) + if err != nil { + return nil, err + } + return funcCastSignedLiteralForSetType(ctx, intPart, targetType) +} + +// decimal64ToIntegerBitsForSet truncates scale and rejects values with any +// fractional component or that overflow int64. Returns the signed integer +// representation so callers can reuse the signed path (which checks sign +// and member existence). +func decimal64ToIntegerBitsForSet(v types.Decimal64, scale int32) (int64, error) { + if scale > 0 { + pow := decimal64Pow10(scale) + if pow == 0 { + return 0, moerr.NewInvalidInputNoCtx("invalid default value for SET column") + } + d := int64(v) + if d%int64(pow) != 0 { + return 0, moerr.NewInvalidInputNoCtx("invalid default value for SET column") + } + return d / int64(pow), nil + } + return int64(v), nil +} + +func decimal128ToIntegerBitsForSet(v types.Decimal128, scale int32) (int64, error) { + // Collapse to int64 via string round-trip so we reject anything that + // overflows or has a fractional component in one shot. + s := v.Format(scale) + if dot := strings.IndexByte(s, '.'); dot >= 0 { + for _, c := range s[dot+1:] { + if c != '0' { + return 0, moerr.NewInvalidInputNoCtx("invalid default value for SET column") + } + } + s = s[:dot] + } + n, ok := parseInt64Strict(s) + if !ok { + return 0, moerr.NewInvalidInputNoCtx("invalid default value for SET column") + } + return n, nil +} + +func decimal64Pow10(scale int32) uint64 { + if scale < 0 || scale > 18 { + return 0 + } + r := uint64(1) + for i := int32(0); i < scale; i++ { + r *= 10 + } + return r +} + +func parseInt64Strict(s string) (int64, bool) { + if s == "" { + return 0, false + } + negative := false + i := 0 + if s[0] == '-' { + negative = true + i = 1 + } else if s[0] == '+' { + i = 1 + } + if i == len(s) { + return 0, false + } + var v uint64 + for ; i < len(s); i++ { + c := s[i] + if c < '0' || c > '9' { + return 0, false + } + next := v*10 + uint64(c-'0') + if next < v { + return 0, false + } + v = next + } + if negative { + if v > uint64(1)<<63 { + return 0, false + } + return -int64(v), true + } + if v > uint64(1)<<63-1 { + return 0, false + } + return int64(v), true +} + // if typ is decimal128 and decimal64 without scalar and width // set a default value for it. func rewriteDecimalTypeIfNecessary(typ *plan.Type) *plan.Type { @@ -711,10 +957,7 @@ func isSameColumnType(t1 Type, t2 Type) bool { if t1.Id != t2.Id { return false } - if t1.Width == t2.Width && t1.Scale == t2.Scale { - return true - } - return true + return t1.Width == t2.Width && t1.Scale == t2.Scale } // GetColDefFromTable Find the target column definition from the predefined diff --git a/pkg/sql/plan/make_test.go b/pkg/sql/plan/make_test.go index d26da8bbb0606..0b527d336db4f 100644 --- a/pkg/sql/plan/make_test.go +++ b/pkg/sql/plan/make_test.go @@ -48,3 +48,31 @@ func Test_MakePlan2Vecf32ConstExprWithType(t *testing.T) { actual := t1.Expr.(*plan.Expr_Lit).Lit.GetValue().(*plan.Literal_Sval).Sval require.Equal(t, "[1,2,3]", actual) } + +func Test_isSameColumnType(t *testing.T) { + // Same type entirely + require.True(t, isSameColumnType( + plan.Type{Id: int32(types.T_decimal64), Width: 10, Scale: 2}, + plan.Type{Id: int32(types.T_decimal64), Width: 10, Scale: 2}, + )) + // Different Id + require.False(t, isSameColumnType( + plan.Type{Id: int32(types.T_int32)}, + plan.Type{Id: int32(types.T_int64)}, + )) + // Same Id, different Width + require.False(t, isSameColumnType( + plan.Type{Id: int32(types.T_decimal64), Width: 10, Scale: 2}, + plan.Type{Id: int32(types.T_decimal64), Width: 18, Scale: 2}, + )) + // Same Id, different Scale + require.False(t, isSameColumnType( + plan.Type{Id: int32(types.T_decimal64), Width: 10, Scale: 2}, + plan.Type{Id: int32(types.T_decimal64), Width: 10, Scale: 4}, + )) + // VARCHAR with different widths + require.False(t, isSameColumnType( + plan.Type{Id: int32(types.T_varchar), Width: 100}, + plan.Type{Id: int32(types.T_varchar), Width: 255}, + )) +} diff --git a/pkg/sql/plan/mysql_special_types.go b/pkg/sql/plan/mysql_special_types.go new file mode 100644 index 0000000000000..de5cc37a9369e --- /dev/null +++ b/pkg/sql/plan/mysql_special_types.go @@ -0,0 +1,75 @@ +// Copyright 2026 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 plan + +import ( + "strings" + + "github.com/matrixorigin/matrixone/pkg/container/types" + "github.com/matrixorigin/matrixone/pkg/pb/plan" +) + +func isEnumPlanType(typ *plan.Type) bool { + return typ != nil && typ.Id == int32(types.T_enum) && typ.GetEnumvalues() != "" +} + +// isSetPlanType identifies SET columns by piggy-backing on T_uint64 storage +// plus a non-empty Enumvalues string. This is safe today because Enumvalues +// is only populated for ENUM/SET, but it is fragile — any future codepath +// that attaches metadata to that field on a plain uint64 column would be +// misidentified as a SET. +// +// TODO: promote SET to its own dedicated OID (e.g. T_set) once the backlog +// of uint64-storage consumers can be audited. Until then this discriminator +// is the least invasive way to avoid a breaking change across the vector / +// expr / encoding stack. +func isSetPlanType(typ *plan.Type) bool { + return typ != nil && typ.Id == int32(types.T_uint64) && typ.GetEnumvalues() != "" +} + +func isEnumOrSetPlanType(typ *plan.Type) bool { + return isEnumPlanType(typ) || isSetPlanType(typ) +} + +// isGeometryPlanType treats all spatial subtypes (POINT, LINESTRING, +// POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, +// GEOMETRYCOLLECTION, GEOMETRY) as the same storage-level OID; the +// subtype is only carried in FamilyString / Enumvalues and is purely +// declarative. Storage and comparison treat them identically. Good enough +// for the 3.0-dev compatibility scope, but a future revision may want a +// proper per-subtype discriminator for WKT/WKB validation. +func isGeometryPlanType(typ *plan.Type) bool { + return typ != nil && typ.Id == int32(types.T_geometry) +} + +func geometrySubtypeName(typ *plan.Type) string { + if !isGeometryPlanType(typ) { + return "" + } + subtype := strings.TrimSpace(typ.GetEnumvalues()) + if strings.EqualFold(subtype, "GEOMETRY") { + return "" + } + return strings.ToUpper(subtype) +} + +func normalizeGeometrySubtype(subtype string) string { + switch strings.ToUpper(strings.TrimSpace(subtype)) { + case "POINT", "LINESTRING", "POLYGON", "MULTIPOINT", "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION": + return strings.ToUpper(strings.TrimSpace(subtype)) + default: + return "" + } +} diff --git a/pkg/vectorize/moarray/external.go b/pkg/vectorize/moarray/external.go index 602e59db36e57..14367d508fd3f 100644 --- a/pkg/vectorize/moarray/external.go +++ b/pkg/vectorize/moarray/external.go @@ -373,8 +373,9 @@ func ScalarOp[T types.RealNumbers](v []T, operation string, scalar float64) ([]T // check overflow for i := range ret { - if math.IsInf(float64(ret[i]), 0) { - return nil, moerr.NewInternalErrorNoCtx("vector contains infinity values") + f := float64(ret[i]) + if math.IsInf(f, 0) || math.IsNaN(f) { + return nil, moerr.NewOutOfRangeNoCtx("float", "FLOAT/DOUBLE array value is out of range") } } return ret, nil @@ -423,6 +424,16 @@ func Cast[I types.RealNumbers, O types.RealNumbers](in []I) (out []O, err error) out = make([]O, n) for i := 0; i < n; i++ { out[i] = O(in[i]) + // When narrowing (e.g. float64 -> float32), a finite source element + // whose magnitude exceeds the target type's range becomes +/-Inf. Go's + // implicit numeric conversion does not report this. Raise the same + // out-of-range error SQL users already get from scalar float casts, + // so vecf64 -> vecf32 doesn't silently insert Inf. + src := float64(in[i]) + dst := float64(out[i]) + if !math.IsInf(src, 0) && math.IsInf(dst, 0) { + return nil, moerr.NewOutOfRangeNoCtxf("vector element", "value '%v' overflows target element type", src) + } } return out, nil diff --git a/pkg/vectorize/moarray/external_test.go b/pkg/vectorize/moarray/external_test.go index 7e27ab8c16d1e..6d4be87b040e9 100644 --- a/pkg/vectorize/moarray/external_test.go +++ b/pkg/vectorize/moarray/external_test.go @@ -15,10 +15,12 @@ package moarray import ( + "math" "reflect" "testing" "github.com/matrixorigin/matrixone/pkg/common/assertx" + "github.com/matrixorigin/matrixone/pkg/common/moerr" ) func TestAdd(t *testing.T) { @@ -355,6 +357,22 @@ func TestCast(t *testing.T) { } } +// Narrowing cast (float64 -> float32) of a finite element whose magnitude +// exceeds float32's range used to silently return +/-Inf. We now surface an +// out-of-range error, matching scalar float-cast behaviour. +func TestCastFloat64ToFloat32OverflowIsRejected(t *testing.T) { + _, err := Cast[float64, float32]([]float64{1e300}) + if err == nil { + t.Fatalf("Cast[float64,float32]([1e300]) should return out-of-range error, got nil") + } + + // An explicit +Inf on the source passes through without a new error — + // we only guard against silent finite -> Inf overflow. + if _, err := Cast[float64, float32]([]float64{math.Inf(1)}); err != nil { + t.Fatalf("Cast[float64,float32]([+Inf]) should pass through, got %v", err) + } +} + func TestAbs(t *testing.T) { type args struct { argF32 []float32 @@ -939,3 +957,55 @@ func TestScalarOp(t *testing.T) { }) } } + +func TestScalarOpOverflow(t *testing.T) { + maxF32 := float32(math.MaxFloat32) + maxF64 := math.MaxFloat64 + + // float32 overflow: MaxFloat32 * 2 → +Inf + _, err := ScalarOp[float32]([]float32{maxF32}, "*", 2) + if err == nil { + t.Fatal("expected out-of-range error for float32 overflow, got nil") + } + if !moerr.IsMoErrCode(err, moerr.ErrOutOfRange) { + t.Errorf("expected ErrOutOfRange, got %v", err) + } + + // float64 overflow: MaxFloat64 * 2 → +Inf + _, err = ScalarOp[float64]([]float64{maxF64}, "*", 2) + if err == nil { + t.Fatal("expected out-of-range error for float64 overflow, got nil") + } + if !moerr.IsMoErrCode(err, moerr.ErrOutOfRange) { + t.Errorf("expected ErrOutOfRange, got %v", err) + } + + // addition overflow: MaxFloat64 + MaxFloat64 → +Inf + _, err = ScalarOp[float64]([]float64{maxF64}, "+", maxF64) + if err == nil { + t.Fatal("expected out-of-range error for float64 add overflow, got nil") + } + if !moerr.IsMoErrCode(err, moerr.ErrOutOfRange) { + t.Errorf("expected ErrOutOfRange, got %v", err) + } +} + +func TestScalarOpNaN(t *testing.T) { + // 0 * Inf produces NaN, must be rejected + _, err := ScalarOp[float64]([]float64{0}, "*", math.Inf(1)) + if err == nil { + t.Fatal("expected out-of-range error for NaN result, got nil") + } + if !moerr.IsMoErrCode(err, moerr.ErrOutOfRange) { + t.Errorf("expected ErrOutOfRange, got %v", err) + } + + // float32: 0 * Inf also produces NaN + _, err = ScalarOp[float32]([]float32{0}, "*", float64(math.Inf(-1))) + if err == nil { + t.Fatal("expected out-of-range error for float32 NaN result, got nil") + } + if !moerr.IsMoErrCode(err, moerr.ErrOutOfRange) { + t.Errorf("expected ErrOutOfRange, got %v", err) + } +} diff --git a/pkg/vectorize/momath/math.go b/pkg/vectorize/momath/math.go index 561fde573ee44..5c3a29b903bab 100644 --- a/pkg/vectorize/momath/math.go +++ b/pkg/vectorize/momath/math.go @@ -48,7 +48,11 @@ func Cot(v float64) (float64, error) { } func Exp(v float64) (float64, error) { - return math.Exp(v), nil + r := math.Exp(v) + if math.IsInf(r, 0) { + return 0, moerr.NewOutOfRangeNoCtxf("float64", "DOUBLE value is out of range in 'exp(%v)'", v) + } + return r, nil } func Sqrt(v float64) (float64, error) { diff --git a/test/distributed/cases/array/array.result b/test/distributed/cases/array/array.result index 24f96fb2b8d8d..d50668523b3ff 100644 --- a/test/distributed/cases/array/array.result +++ b/test/distributed/cases/array/array.result @@ -543,7 +543,7 @@ a b c 3 [0.1726299, 3.2908857, 30.433094] [0.45052445, 2.1984527, 9.579752, 123.48039, 4635.894] 4 [8.560689, 6.790359, 821.9778] [0.46323407, 23.498016, 563.923, 56.076736, 8732.958] select cast("[76875768584509877574546435800000005,8955885757767774774774774456466]" as vecf32(2)) *623585864455; -internal error: vector contains infinity values +Data truncation: data out of range: data type float, FLOAT/DOUBLE array value is out of range select l2_distance("[0, 0, 0]", "[3, 4, 0]"), l2_distance_sq("[0, 0, 0]", "[3, 4, 0]"); l2_distance([0, 0, 0], [3, 4, 0]) l2_distance_sq([0, 0, 0], [3, 4, 0]) 5.0 25.0 diff --git a/test/distributed/cases/comment/comment.result b/test/distributed/cases/comment/comment.result index 14fe7ee2b584c..8a75ed6d5bf01 100644 --- a/test/distributed/cases/comment/comment.result +++ b/test/distributed/cases/comment/comment.result @@ -122,7 +122,7 @@ PRIMARY KEY (`id`) USING BTREE ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='设备点检标准表'; show create table `t_iot_equipment_inspection_stand`; Table Create Table -t_iot_equipment_inspection_stand CREATE TABLE `t_iot_equipment_inspection_stand` (\n `id` bigint NOT NULL,\n `tenant_id` varchar(50) NOT NULL COMMENT '租户ID',\n `equipment_category_id` bigint NOT NULL COMMENT '设备分类ID',\n `equipment_model_id` bigint NOT NULL,\n `name` varchar(50) NOT NULL COMMENT '点检项名称',\n `category` varchar(50) DEFAULT NULL COMMENT '检验分类：定性、定量、智能点检',\n `inspection_content` varchar(50) DEFAULT NULL COMMENT '点检内容',\n `inspection_tool` varchar(50) DEFAULT NULL COMMENT '点检工具',\n `inspection_method` varchar(50) DEFAULT NULL COMMENT '点检方法',\n `judgment_criteria` varchar(50) DEFAULT NULL COMMENT '判断标准',\n `inspection_exceptions` text DEFAULT NULL COMMENT '异常描述["表面有磨损","表面有裂痕"]',\n `major` text DEFAULT NULL COMMENT '点检专业',\n `cycle_unit` varchar(50) DEFAULT NULL COMMENT '执行周期,一次、年、季度、月、周、日、班次、小时',\n `cycle_num` decimal(20,6) DEFAULT NULL COMMENT '周期间隔',\n `remark` varchar(255) DEFAULT NULL COMMENT '备注',\n `create_org` bigint DEFAULT NULL COMMENT '创建组织',\n `use_org` bigint DEFAULT NULL COMMENT '使用组织',\n `create_time` datetime NOT NULL COMMENT '创建时间',\n `create_user` bigint DEFAULT NULL COMMENT '创建人员',\n `create_user_name` varchar(50) DEFAULT NULL,\n `create_dept` bigint DEFAULT NULL COMMENT '创建部门',\n `update_time` datetime DEFAULT NULL COMMENT '更新时间',\n `update_user` bigint DEFAULT NULL COMMENT '更新人员',\n `update_user_name` varchar(50) DEFAULT NULL,\n `status` int DEFAULT NULL,\n `is_deleted` int DEFAULT NULL COMMENT '是否已删除',\n PRIMARY KEY (`id`)\n) COMMENT='设备点检标准表' +t_iot_equipment_inspection_stand CREATE TABLE `t_iot_equipment_inspection_stand` (\n `id` bigint NOT NULL,\n `tenant_id` varchar(50) NOT NULL COMMENT '租户ID',\n `equipment_category_id` bigint NOT NULL COMMENT '设备分类ID',\n `equipment_model_id` bigint NOT NULL,\n `name` varchar(50) NOT NULL COMMENT '点检项名称',\n `category` varchar(50) DEFAULT NULL COMMENT '检验分类：定性、定量、智能点检',\n `inspection_content` varchar(50) DEFAULT NULL COMMENT '点检内容',\n `inspection_tool` varchar(50) DEFAULT NULL COMMENT '点检工具',\n `inspection_method` varchar(50) DEFAULT NULL COMMENT '点检方法',\n `judgment_criteria` varchar(50) DEFAULT NULL COMMENT '判断标准',\n `inspection_exceptions` text DEFAULT NULL COMMENT '异常描述[\\"表面有磨损\\",\\"表面有裂痕\\"]',\n `major` text DEFAULT NULL COMMENT '点检专业',\n `cycle_unit` varchar(50) DEFAULT NULL COMMENT '执行周期,一次、年、季度、月、周、日、班次、小时',\n `cycle_num` decimal(20,6) DEFAULT NULL COMMENT '周期间隔',\n `remark` varchar(255) DEFAULT NULL COMMENT '备注',\n `create_org` bigint DEFAULT NULL COMMENT '创建组织',\n `use_org` bigint DEFAULT NULL COMMENT '使用组织',\n `create_time` datetime NOT NULL COMMENT '创建时间',\n `create_user` bigint DEFAULT NULL COMMENT '创建人员',\n `create_user_name` varchar(50) DEFAULT NULL,\n `create_dept` bigint DEFAULT NULL COMMENT '创建部门',\n `update_time` datetime DEFAULT NULL COMMENT '更新时间',\n `update_user` bigint DEFAULT NULL COMMENT '更新人员',\n `update_user_name` varchar(50) DEFAULT NULL,\n `status` int DEFAULT NULL,\n `is_deleted` int DEFAULT NULL COMMENT '是否已删除',\n PRIMARY KEY (`id`)\n) COMMENT='设备点检标准表' drop database emis_issue; create database if not exists emis_issue; use emis_issue; @@ -230,5 +230,5 @@ PRIMARY KEY (`id`) USING BTREE ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='设备点检标准表'; show create table `t_iot_equipment_inspection_stand`; Table Create Table -t_iot_equipment_inspection_stand CREATE TABLE `t_iot_equipment_inspection_stand` (\n `id` bigint NOT NULL,\n `tenant_id` varchar(50) NOT NULL COMMENT '租户ID',\n `equipment_category_id` bigint NOT NULL COMMENT '设备分类ID',\n `equipment_model_id` bigint NOT NULL,\n `name` varchar(50) NOT NULL COMMENT '点检项名称',\n `category` varchar(50) DEFAULT NULL COMMENT '检验分类：定性、定量、智能点检',\n `inspection_content` varchar(50) DEFAULT NULL COMMENT '点检内容',\n `inspection_tool` varchar(50) DEFAULT NULL COMMENT '点检工具',\n `inspection_method` varchar(50) DEFAULT NULL COMMENT '点检方法',\n `judgment_criteria` varchar(50) DEFAULT NULL COMMENT '判断标准',\n `inspection_exceptions` text DEFAULT NULL COMMENT '异常描述["表面有磨损","表面有裂痕"]',\n `major` text DEFAULT NULL COMMENT '点检专业',\n `cycle_unit` varchar(50) DEFAULT NULL COMMENT '执行周期,一次、年、季度、月、周、日、班次、小时',\n `cycle_num` decimal(20,6) DEFAULT NULL COMMENT '周期间隔',\n `remark` varchar(255) DEFAULT NULL COMMENT '备注',\n `create_org` bigint DEFAULT NULL COMMENT '创建组织',\n `use_org` bigint DEFAULT NULL COMMENT '使用组织',\n `create_time` datetime NOT NULL COMMENT '创建时间',\n `create_user` bigint DEFAULT NULL COMMENT '创建人员',\n `create_user_name` varchar(50) DEFAULT NULL,\n `create_dept` bigint DEFAULT NULL COMMENT '创建部门',\n `update_time` datetime DEFAULT NULL COMMENT '更新时间',\n `update_user` bigint DEFAULT NULL COMMENT '更新人员',\n `update_user_name` varchar(50) DEFAULT NULL,\n `status` int DEFAULT NULL,\n `is_deleted` int DEFAULT NULL COMMENT '是否已删除',\n PRIMARY KEY (`id`)\n) COMMENT='设备点检标准表' +t_iot_equipment_inspection_stand CREATE TABLE `t_iot_equipment_inspection_stand` (\n `id` bigint NOT NULL,\n `tenant_id` varchar(50) NOT NULL COMMENT '租户ID',\n `equipment_category_id` bigint NOT NULL COMMENT '设备分类ID',\n `equipment_model_id` bigint NOT NULL,\n `name` varchar(50) NOT NULL COMMENT '点检项名称',\n `category` varchar(50) DEFAULT NULL COMMENT '检验分类：定性、定量、智能点检',\n `inspection_content` varchar(50) DEFAULT NULL COMMENT '点检内容',\n `inspection_tool` varchar(50) DEFAULT NULL COMMENT '点检工具',\n `inspection_method` varchar(50) DEFAULT NULL COMMENT '点检方法',\n `judgment_criteria` varchar(50) DEFAULT NULL COMMENT '判断标准',\n `inspection_exceptions` text DEFAULT NULL COMMENT '异常描述[\\"表面有磨损\\",\\"表面有裂痕\\"]',\n `major` text DEFAULT NULL COMMENT '点检专业',\n `cycle_unit` varchar(50) DEFAULT NULL COMMENT '执行周期,一次、年、季度、月、周、日、班次、小时',\n `cycle_num` decimal(20,6) DEFAULT NULL COMMENT '周期间隔',\n `remark` varchar(255) DEFAULT NULL COMMENT '备注',\n `create_org` bigint DEFAULT NULL COMMENT '创建组织',\n `use_org` bigint DEFAULT NULL COMMENT '使用组织',\n `create_time` datetime NOT NULL COMMENT '创建时间',\n `create_user` bigint DEFAULT NULL COMMENT '创建人员',\n `create_user_name` varchar(50) DEFAULT NULL,\n `create_dept` bigint DEFAULT NULL COMMENT '创建部门',\n `update_time` datetime DEFAULT NULL COMMENT '更新时间',\n `update_user` bigint DEFAULT NULL COMMENT '更新人员',\n `update_user_name` varchar(50) DEFAULT NULL,\n `status` int DEFAULT NULL,\n `is_deleted` int DEFAULT NULL COMMENT '是否已删除',\n PRIMARY KEY (`id`)\n) COMMENT='设备点检标准表' drop database emis_issue; diff --git a/test/distributed/cases/ddl/alter.result b/test/distributed/cases/ddl/alter.result index 169340f1dcc0a..73b401e71b2c6 100644 --- a/test/distributed/cases/ddl/alter.result +++ b/test/distributed/cases/ddl/alter.result @@ -603,7 +603,7 @@ Duplicate entry '1' for key 'b' create table v2 (a int primary key, b int, c text, fulltext f01(c)); insert into v2 values (1, 1, "42"), (2, 1, "43"); alter table v2 modify column b int unique key; -- dup, fuzzy dedup path -Duplicate entry '1' for key '__mo_index_idx_col' +Duplicate entry '1' for key 'b' create table v3 (a int primary key, b int, c text, unique index IdX2(b)); load data infile '$resources/load_data/dup_load.csv' into table v3 fields terminated by ','; insert into v3 values (1, 1, "boroborodesu"); -- dup diff --git a/test/distributed/cases/dtype/decimal.result b/test/distributed/cases/dtype/decimal.result index 14bfa8824ae93..1f7441d667555 100644 --- a/test/distributed/cases/dtype/decimal.result +++ b/test/distributed/cases/dtype/decimal.result @@ -9,7 +9,7 @@ cast(9223372.036854775808 as decimal(38)) + 1 9223373 select round(cast(2320310.66666612312 as decimal)); round(cast(2320310.66666612312 as decimal(38))) -2320311.0 +2320311 select floor(cast(2231231.501231 as decimal)); floor(cast(2231231.501231 as decimal(38))) 2231232 @@ -625,16 +625,16 @@ a - 0.27832 -0.278320 SELECT a * 0 FROM decimal01; a * 0 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 -0E-12 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 +0.000000 SELECT a / 6 FROM decimal01; a / 6 20.562140000000 @@ -689,11 +689,9 @@ DROP TABLE decimal05; no such table decimal.decimal05 DROP TABLE IF EXISTS decimal06; CREATE TABLE decimal06(a DECIMAL(39,10)); -SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. For decimal(M), M must between 0 and 38. at line 1 column 39 near "));"; CREATE TABLE decimal06(b DECIMAL(40,39)); -SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. For decimal(M), M must between 0 and 38. at line 1 column 39 near "));"; +SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. Display scale for decimal out of range (max = 30) at line 1 column 39 near "));"; DROP TABLE decimal06; -no such table decimal.decimal06 DROP TABLE IF EXISTS decimal07; CREATE TABLE decimal07(a int PRIMARY KEY, b DECIMAL(38)); INSERT INTO decimal07 VALUES(1, 3728193.3902); @@ -727,19 +725,19 @@ a a - b - b SELECT a, b DIV a FROM decimal07; Data truncation: data out of range: data type BIGINT, SELECT a, ABS(b) FROM decimal07; -a abs(b) +a ABS(b) 1 3728193 2 0 3 3728 4 12345678909876543212345678909876543243 SELECT a, CEIL(b) FROM decimal07; -a ceil(b) +a CEIL(b) 1 3728193 2 0 3 -3728 4 12345678909876543212345678909876543243 SELECT a, POWER(b,2) FROM decimal07; -a power(b, 2) +a POWER(b, 2) 1 1.3899423045249E13 2 0.0 3 1.3897984E7 @@ -753,23 +751,19 @@ b + pi() -3724.8584073464103 1.2345678909876543E37 SELECT LOG(10, b + 100000) FROM decimal07; -log(10, b + 100000) +LOG(10, b + 100000) 6.582993824800232 5.0 4.9834999941475795 37.0915149775167 SELECT LN(b + 20000) FROM decimal07; -ln(b + 20000) +LN(b + 20000) 15.136784415144875 9.903487552536127 9.69720111828834 85.40636946379534 SELECT EXP(b) FROM decimal07; -exp(b) -Infinity -1.0 -0.0 -Infinity +Data truncation: data out of range: data type float64, DOUBLE value is out of range in 'exp(3.728193e+06)' DROP TABLE decimal07; DROP TABLE IF EXISTS decimal08; CREATE TABLE decimal08(a DECIMAL(38,0)); @@ -863,25 +857,25 @@ a / d -0.011305247057632835 null SELECT ABS(a) * c FROM decimal10; -abs(a) * c +ABS(a) * c -5.963586E9 1.2614726E11 1226526.0 812.166 SELECT FLOOR(a) FROM decimal10; -floor(a) +FLOOR(a) 12323 3829 -3728833 0 SELECT CEIL(a) * CEIL(c) FROM decimal10; -ceil(a) * ceil(c) +CEIL(a) * CEIL(c) -5.963879376E9 1.2617262452E11 -3728832.0 3729.0 SELECT POWER(ABS(a), 10) FROM decimal10; -power(abs(a), 10) +POWER(ABS(a), 10) 8.077917745724969E40 6.778202311305383E35 5.196711812449448E65 @@ -893,37 +887,37 @@ pi() * a -1.171447246865273E7 0.6843422697660866 SELECT LOG(ABS(a)) FROM decimal10; -log(abs(a)) +LOG(ABS(a)) 9.419253785434625 8.250419017576137 15.131605712642699 -1.524026977969649 SELECT LN(ABS(a)) FROM decimal10; -ln(abs(a)) +LN(ABS(a)) 9.419253785434625 8.250419017576137 15.131605712642699 -1.524026977969649 SELECT EXP(a div c) FROM decimal10; -exp(a div c) +EXP(a div c) 1.0 1.0 0.0 1.0 SELECT SUM(a) FROM decimal10; -sum(a) +SUM(a) -3712679.56746709 SELECT AVG(a + b) FROM decimal10; -avg(a + b) +AVG(a + b) -1248495.261766666667 SELECT COUNT(a) FROM decimal10; -count(a) +COUNT(a) 4 SELECT MAX(a) FROM decimal10; -max(a) +MAX(a) 12323.38290000 SELECT MIN(a) + MAX(b) FROM decimal10; -min(a) + max(b) +MIN(a) + MAX(b) -3728832.39820000 SELECT * FROM decimal10 ORDER BY a DESC; a b c d @@ -981,7 +975,7 @@ cast(b as decimal(10)) 0 111 SELECT CAST(ABS(a) AS decimal) FROM decimal10; -cast(abs(a) as decimal(38)) +cast(ABS(a) as decimal(38)) 0 0 2 @@ -1046,9 +1040,9 @@ a b c -2.220000000 0 32783232 SELECT a * b FROM decimal10 WHERE a NOT BETWEEN 2 AND 9; a * b -0E-12 -30.414696000000 -0E-12 +0E-9 +30.414696000 +0E-9 SELECT any_value(a) FROM decimal10 WHERE ABS(a) >= 0 GROUP BY id; any_value(a) 0E-9 @@ -1138,7 +1132,7 @@ a b c -28.32320 387213.0 3.2132313E7 null 327.32892 -38922.2123 INSERT INTO decimal15 VALUES(271.212121,387213.0,3289); -Duplicate entry '271.21212' for key '(.*)' +Duplicate entry '271.21212' for key 'a' DROP TABLE decimal15; DROP TABLE IF EXISTS decimal16; CREATE TABLE decimal16(a decimal, b decimal(38,10), c varchar(20),UNIQUE INDEX(a),INDEX(b)); @@ -1166,6 +1160,9 @@ a b c d DROP TABLE decimal17; DROP TABLE IF EXISTS decimal18; CREATE TABLE decimal18 (col1 decimal(38,37),col2 decimal(38,37),col3 float, col4 double); +SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. Display scale for decimal out of range (max = 30) at line 1 column 43 near "),col2 decimal(38,37),col3 float, col4 double);"; +DROP TABLE IF EXISTS decimal18; +CREATE TABLE decimal18 (col1 decimal(38,30),col2 decimal(38,30),col3 float, col4 double); INSERT INTO decimal18 VALUES(0.1221212134567890987654321333546543213,0.9999999999999999999999999999999999999,1278945.21588,78153178.49845612); INSERT INTO decimal18 VALUES(0.9999999999999999999999999999999999999,0.1484484651187895121879845615156784548,1545.1548,879.89484); INSERT INTO decimal18 VALUES(0.8932839724832437289437927438274832748,0,453201,78465121); @@ -1173,11 +1170,11 @@ INSERT INTO decimal18 VALUES(0.372837842743762,9.9999999999999999999999999999999 INSERT INTO decimal18 VALUES(-0.3728329487324893628746328746873236438,-9.3820342423,-329837842932.4932,0); SELECT * FROM decimal18; col1 col2 col3 col4 -0.1221212134567890987654321333546543213 0.9999999999999999999999999999999999999 1278945.2 7.815317849845612E7 -0.9999999999999999999999999999999999999 0.1484484651187895121879845615156784548 1545.1548 879.89484 -0.8932839724832437289437927438274832748 0E-37 453201.0 7.8465121E7 -0.3728378427437620000000000000000000000 9.9999999999999999999999999999999999999 0.0 -454.49845 --0.3728329487324893628746328746873236438 -9.3820342423000000000000000000000000000 -3.2983784E11 0.0 +0.122121213456789098765432133355 1.000000000000000000000000000000 1278945.2 7.815317849845612E7 +1.000000000000000000000000000000 0.148448465118789512187984561516 1545.1548 879.89484 +0.893283972483243728943792743827 0E-30 453201.0 7.8465121E7 +0.372837842743762000000000000000 10.000000000000000000000000000000 0.0 -454.49845 +-0.372832948732489362874632874687 -9.382034242300000000000000000000 -3.2983784E11 0.0 SELECT CAST(col3 AS decimal(38)) FROM decimal18; cast(col3 as decimal(38)) 1278945 @@ -1194,18 +1191,18 @@ cast(col4 as decimal(20, 3)) 0.000 SELECT 0.32846287164921643232142372817438921749321 * col1 FROM decimal18; 0.32846287164921643232142372817438921749321 * col1 -0.0401122844613038803331760546727756160 -0.3284628716492164323214237281743892174 -0.2934106188000658682671043005117996486 +0.0401122844613038803331760546728891586 +0.3284628716492164323214237281743892175 +0.2934106188000658682671043005116409109 0.1224633884871150379612231853163806304 --0.1224617809861185439347457501020516214 +-0.1224617809861185439347457501019453165 SELECT -0.487794599999999999999999999999999945451154 * col2 FROM decimal18; -0.487794599999999999999999999999999945451154 * col2 --0.4877945999999999999999999999999999454 --0.0724123596632338825819330539907157574 +-0.4877945999999999999999999999999999455 +-0.0724123596632338825819330539908726055 0E-37 --4.8779459999999999999999999999999994549 -4.5765056404090315799999999999999994886 +-4.8779459999999999999999999999999994550 +4.5765056404090315799999999999999994887 SELECT col1 * col2 FROM decimal18; [unknown result because it is related to issue#8516] SELECT col3 * col2 FROM decimal18; @@ -1218,6 +1215,7 @@ SELECT 12345678965412365478965444565896532145 / col1 FROM decimal18; [unknown result because it is related to issue#8513] SELECT col2/522222222225456987.23212654569987523654 FROM decimal18; [unknown result because it is related to issue#8513] + DROP TABLE IF EXISTS decimal19; CREATE TABLE decimal19 (col1 decimal(38,0),col2 decimal(19,0)); INSERT INTO decimal19 VALUES(12345645678978945612312345678885229999, 1235467899687894561); @@ -1226,8 +1224,8 @@ INSERT INTO decimal19 VALUES(-99999999997899999999999999999999999999, 5681569874 SELECT col1 / col2 FROM decimal19; col1 / col2 9992688342690018894.297291 -32015808253987387864.171827 -17600769189777557874.214319 +32015808253987387864.171828 +17600769189777557874.214320 SELECT col1 * col2 FROM decimal19; invalid input: Decimal128 Mul overflow: 12345645678978945612312345678885229999(Scale:0)*1235467899687894561(Scale:0) SELECT col1 * 0.2871438217498217489217843728134214212143 FROM decimal19; @@ -1330,15 +1328,15 @@ col1 / (col1 * col2) 100000000000000000000.00000000000 SELECT col1%col2 from decimal22; col1 % col2 -0.0000000000000000000000000 +0E-25 DROP TABLE decimal22; DROP TABLE IF EXISTS decimal23; CREATE TABLE decimal23(col1 decimal(18,5),col2 decimal(18,15)); INSERT INTO decimal23 VALUES('0xffffffffff',0.0000000000001); SELECT col1%col2 from decimal23; -col1 % col2 -0.000000000000000 +col1 % col2 +0E-15 SELECT cast(col2 as double) from decimal23; cast(col2 as double) -0.0000000000001 -DROP TABLE decimal23; \ No newline at end of file +1.0E-13 +DROP TABLE decimal23; diff --git a/test/distributed/cases/dtype/decimal.test b/test/distributed/cases/dtype/decimal.test index aecbc7b9892e8..ea53d659d3676 100644 --- a/test/distributed/cases/dtype/decimal.test +++ b/test/distributed/cases/dtype/decimal.test @@ -620,7 +620,10 @@ DROP TABLE decimal17; -- Precision 256 DROP TABLE IF EXISTS decimal18; +-- scale > 30 is rejected for MySQL compatibility CREATE TABLE decimal18 (col1 decimal(38,37),col2 decimal(38,37),col3 float, col4 double); +DROP TABLE IF EXISTS decimal18; +CREATE TABLE decimal18 (col1 decimal(38,30),col2 decimal(38,30),col3 float, col4 double); INSERT INTO decimal18 VALUES(0.1221212134567890987654321333546543213,0.9999999999999999999999999999999999999,1278945.21588,78153178.49845612); INSERT INTO decimal18 VALUES(0.9999999999999999999999999999999999999,0.1484484651187895121879845615156784548,1545.1548,879.89484); INSERT INTO decimal18 VALUES(0.8932839724832437289437927438274832748,0,453201,78465121); diff --git a/test/distributed/cases/dtype/numeric.result b/test/distributed/cases/dtype/numeric.result index 2d24c8e8dda23..614a1905ce57a 100644 --- a/test/distributed/cases/dtype/numeric.result +++ b/test/distributed/cases/dtype/numeric.result @@ -16,6 +16,7 @@ floor(cast(2231231.501231 as numeric(38))) drop table if exists t1; create table t1 (a numeric(29,0) not null, primary key(a)); insert into t1 values (18446744073709551615), (0xFFFFFFFFFFFFFE), (18446744073709551613.0000000), (18446744073709551612.0000000001); + select * from t1 order by 1 asc; a 72057594037927934 @@ -26,6 +27,7 @@ select * from t1 where a=18446744073709551615 order by a desc; a 18446744073709551615 delete from t1 where a=18446744073709551615.000000000; + select * from t1; a 72057594037927934 @@ -46,8 +48,11 @@ select min(big),avg(big),max(big)-1 from t1 group by a order by 1+2; min(big) avg(big) max(big) - 1 -1.00000000000 34.526466426967 91.23372036855 drop table t1; + create table t1 ( a int not null default 1, big numeric(20,4) primary key); + insert into t1 (big) values (0),(18446744073), (0xFFFFFE), (184467.13), (184462); + select * from t1 order by 1,2 desc; a big 1 18446744073.0000 @@ -238,10 +243,15 @@ a 0.9 0.9 drop table t1; + create table t (id numeric(23,3) unsigned, b int); + insert into t values(889475494977969.3574,1); + insert into t values(889475494977969.3579,2); + insert into t values(889475494977969.357,3); + select count(*) from t where id>=88947549497796.3574 and id <=889475494977969.358; count(*) @@ -251,6 +261,7 @@ where id between 88947549497796.3574 and 889475494977969.358; count(*) 3 drop table t; + SELECT CAST(1.00 AS numeric) BETWEEN 1 AND -1; cast(1.00 as numeric(38)) between 1 and -1 0 @@ -271,12 +282,15 @@ drop table if exists t12; CREATE TABLE t1 (a numeric(3,2), b numeric(5,2) primary key); INSERT INTO t1 VALUES (1.00,1.0000),(1.00,2.0000); update t1 set a=2.00 where a=1 limit 1; + select * from t1; a b 1.00 2.00 2.00 1.00 INSERT INTO t1 VALUES (1,3); + update t1 set a=2 where a=1.00; + select * from t1; a b 2.00 1.00 @@ -401,6 +415,7 @@ j numeric(10,5) not null default 12345.67890, primary key (a)); insert into t1 (a) values (2.1111),(4),(00006.12311),(8.41231),(24.0000); delete from t1 where a=2+2.0000; + select a,b from t1 order by 1; a b 2.11110 12346 @@ -408,18 +423,21 @@ a b 8.41231 12346 24.00000 12346 delete from t1 where a=24.0000; + select a,b from t1 order by 1; a b 2.11110 12346 6.12311 12346 8.41231 12346 delete from t1 where 3 < 2; + select a,b from t1 order by 1; a b 2.11110 12346 6.12311 12346 8.41231 12346 delete from t1 where 1 < 2; + select a,b from t1 order by 1; a b drop table t1; @@ -721,11 +739,9 @@ DROP TABLE numeric05; no such table numeric.numeric05 DROP TABLE IF EXISTS numeric06; CREATE TABLE numeric06(a numeric(39,10)); -SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. For decimal(M), M must between 0 and 38. at line 1 column 39 near "));"; CREATE TABLE numeric06(b numeric(40,39)); -SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. For decimal(M), M must between 0 and 38. at line 1 column 39 near "));"; +SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. Display scale for decimal out of range (max = 30) at line 1 column 39 near "));"; DROP TABLE numeric06; -no such table numeric.numeric06 DROP TABLE IF EXISTS numeric07; CREATE TABLE numeric07(a int PRIMARY KEY, b numeric(38)); INSERT INTO numeric07 VALUES(1, 3728193.3902); @@ -797,11 +813,7 @@ LN(b + 20000) 9.69720111828834 85.40636946379534 SELECT EXP(b) FROM numeric07; -EXP(b) -Infinity -1.0 -0.0 -Infinity +Data truncation: data out of range: data type float64, DOUBLE value is out of range in 'exp(3.728193e+06)' DROP TABLE numeric07; DROP TABLE IF EXISTS numeric08; CREATE TABLE numeric08(a numeric(38,0)); @@ -902,10 +914,10 @@ ABS(a) * c 812.166 SELECT FLOOR(a) FROM numeric10; FLOOR(a) -12323.00000000 -3829.00000000 --3728833.00000000 -0E-8 +12323 +3829 +-3728833 +0 SELECT CEIL(a) * CEIL(c) FROM numeric10; CEIL(a) * CEIL(c) -5.963879376E9 @@ -1170,7 +1182,7 @@ a b c -28.32320 387213.0 3.2132313E7 null 327.32892 -38922.2123 INSERT INTO numeric15 VALUES(271.212121,387213.0,3289); -Duplicate entry '271.21212' for key '(.*)' +Duplicate entry '271.21212' for key 'a' DROP TABLE numeric15; DROP TABLE IF EXISTS numeric16; CREATE TABLE numeric16(a numeric, b numeric(38,10), c varchar(20),UNIQUE INDEX(a),INDEX(b)); @@ -1198,6 +1210,9 @@ a b c d DROP TABLE numeric17; DROP TABLE IF EXISTS numeric18; CREATE TABLE numeric18 (col1 numeric(38,37),col2 numeric(38,37),col3 float, col4 double); +SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. Display scale for decimal out of range (max = 30) at line 1 column 43 near "),col2 numeric(38,37),col3 float, col4 double);"; +DROP TABLE IF EXISTS numeric18; +CREATE TABLE numeric18 (col1 numeric(38,30),col2 numeric(38,30),col3 float, col4 double); INSERT INTO numeric18 VALUES(0.1221212134567890987654321333546543213,0.9999999999999999999999999999999999999,1278945.21588,78153178.49845612); INSERT INTO numeric18 VALUES(0.9999999999999999999999999999999999999,0.1484484651187895121879845615156784548,1545.1548,879.89484); INSERT INTO numeric18 VALUES(0.8932839724832437289437927438274832748,0,453201,78465121); @@ -1205,11 +1220,11 @@ INSERT INTO numeric18 VALUES(0.372837842743762,9.9999999999999999999999999999999 INSERT INTO numeric18 VALUES(-0.3728329487324893628746328746873236438,-9.3820342423,-329837842932.4932,0); SELECT * FROM numeric18; col1 col2 col3 col4 -0.1221212134567890987654321333546543213 0.9999999999999999999999999999999999999 1278945.2 7.815317849845612E7 -0.9999999999999999999999999999999999999 0.1484484651187895121879845615156784548 1545.1548 879.89484 -0.8932839724832437289437927438274832748 0E-37 453201.0 7.8465121E7 -0.3728378427437620000000000000000000000 9.9999999999999999999999999999999999999 0.0 -454.49845 --0.3728329487324893628746328746873236438 -9.3820342423000000000000000000000000000 -3.2983784E11 0.0 +0.122121213456789098765432133355 1.000000000000000000000000000000 1278945.2 7.815317849845612E7 +1.000000000000000000000000000000 0.148448465118789512187984561516 1545.1548 879.89484 +0.893283972483243728943792743827 0E-30 453201.0 7.8465121E7 +0.372837842743762000000000000000 10.000000000000000000000000000000 0.0 -454.49845 +-0.372832948732489362874632874687 -9.382034242300000000000000000000 -3.2983784E11 0.0 SELECT CAST(col3 AS numeric(38)) FROM numeric18; cast(col3 as numeric(38)) 1278945 @@ -1226,50 +1241,31 @@ cast(col4 as numeric(20, 3)) 0.000 SELECT 0.32846287164921643232142372817438921749321 * col1 FROM numeric18; 0.32846287164921643232142372817438921749321 * col1 -0.0401122844613038803331760546727756160 +0.0401122844613038803331760546728891586 0.3284628716492164323214237281743892175 -0.2934106188000658682671043005117996487 +0.2934106188000658682671043005116409109 0.1224633884871150379612231853163806304 --0.1224617809861185439347457501020516215 +-0.1224617809861185439347457501019453165 SELECT -0.487794599999999999999999999999999945451154 * col2 FROM numeric18; -0.487794599999999999999999999999999945451154 * col2 -0.4877945999999999999999999999999999455 --0.0724123596632338825819330539907157575 +-0.0724123596632338825819330539908726055 0E-37 -4.8779459999999999999999999999999994550 4.5765056404090315799999999999999994887 SELECT col1 * col2 FROM numeric18; -col1 * col2 -0.1221212134567890987654321333546543213 -0.1484484651187895121879845615156784548 -0E-37 -3.7283784274376200000000000000000000000 -3.4979314916658955850103159923577553319 +[unknown result because it is related to issue#8516] SELECT col3 * col2 FROM numeric18; -col3 * col2 -1278945.2 -229.37585 -0.0 -0.0 -3.09455E12 +[unknown result because it is related to issue#8516] SELECT col2 * col4 FROM numeric18; -col2 * col4 -7.815317849845612E7 -130.61903846394287 -0.0 --4544.9845 --0.0 +[unknown result because it is related to issue#8516] SELECT col1 / col2 FROM numeric18; -invalid input: Decimal128 Div overflow: 8932839724832437289437927438274832748(Scale:37)/0(Scale:37) +[unknown result because it is related to issue#8513] SELECT 12345678965412365478965444565896532145 / col1 FROM numeric18; -invalid input: Decimal128 Div overflow: 12345678965412365478965444565896532145(Scale:0)/1221212134567890987654321333546543213(Scale:37) +[unknown result because it is related to issue#8513] SELECT col2/522222222225456987.23212654569987523654 FROM numeric18; -col2 / 522222222225456987.23212654569987523654 -1.9148936170094153026E-18 -2.842630183108148709E-19 -0E-37 -1.91489361700941530259E-17 -1.79655974851440360904E-17 +[unknown result because it is related to issue#8513] + DROP TABLE IF EXISTS numeric19; CREATE TABLE numeric19 (col1 numeric(38,0),col2 numeric(19,0)); INSERT INTO numeric19 VALUES(12345645678978945612312345678885229999, 1235467899687894561); diff --git a/test/distributed/cases/dtype/numeric.sql b/test/distributed/cases/dtype/numeric.sql index d36966128986f..1253c3f3ffcd0 100644 --- a/test/distributed/cases/dtype/numeric.sql +++ b/test/distributed/cases/dtype/numeric.sql @@ -620,7 +620,10 @@ DROP TABLE numeric17; -- Precision 256 DROP TABLE IF EXISTS numeric18; +-- scale > 30 is rejected for MySQL compatibility CREATE TABLE numeric18 (col1 numeric(38,37),col2 numeric(38,37),col3 float, col4 double); +DROP TABLE IF EXISTS numeric18; +CREATE TABLE numeric18 (col1 numeric(38,30),col2 numeric(38,30),col3 float, col4 double); INSERT INTO numeric18 VALUES(0.1221212134567890987654321333546543213,0.9999999999999999999999999999999999999,1278945.21588,78153178.49845612); INSERT INTO numeric18 VALUES(0.9999999999999999999999999999999999999,0.1484484651187895121879845615156784548,1545.1548,879.89484); INSERT INTO numeric18 VALUES(0.8932839724832437289437927438274832748,0,453201,78465121); diff --git a/test/distributed/cases/foreign_key/fk_base.result b/test/distributed/cases/foreign_key/fk_base.result index 9796cb43d8325..08e3510d69dc5 100644 --- a/test/distributed/cases/foreign_key/fk_base.result +++ b/test/distributed/cases/foreign_key/fk_base.result @@ -309,7 +309,7 @@ create table c1( a int primary key, b int unique key, c int not null, d int,fore insert into f1 values (1,1), (2,2), (3,3); insert into c1 values(1,2,1,1); insert into c1 values(2,2,1,1); -Duplicate entry '2' for key '__mo_index_idx_col' +Duplicate entry '2' for key 'b' drop table c1; drop table f1; create table fk_01(a int,b varchar(20),c tinyint,primary key(a,b)); diff --git a/test/distributed/cases/function/func_datetime_unixtime.result b/test/distributed/cases/function/func_datetime_unixtime.result index 439d8ac42c0ed..8592845fbb6b0 100644 --- a/test/distributed/cases/function/func_datetime_unixtime.result +++ b/test/distributed/cases/function/func_datetime_unixtime.result @@ -182,7 +182,7 @@ SELECT FROM_UNIXTIME(9223372036854775808); FROM_UNIXTIME(9223372036854775808) null SELECT FROM_UNIXTIME(99999999999999999999999999999999999999999999999999999999999999999); -invalid input: 99999999999999999999999999999999999999999999999999999999999999999 beyond the range, can't be converted to Decimal128. +invalid argument function from_unixtime, bad value [DECIMAL256] select count(unix_timestamp()); count(unix_timestamp()) 1 diff --git a/test/distributed/cases/operator/is_operator.result b/test/distributed/cases/operator/is_operator.result index 5d38d8850a800..b3bf6a41d0bee 100755 --- a/test/distributed/cases/operator/is_operator.result +++ b/test/distributed/cases/operator/is_operator.result @@ -58,7 +58,6 @@ col1 drop table if exists tbl_datetime; drop table if exists tbl_decimal; CREATE TABLE tbl_decimal (col1 DECIMAL(65, 30)); -SQL parser error: You have an error in your SQL syntax; check the manual that corresponds to your MatrixOne server version for the right syntax to use. For decimal(M), M must between 0 and 38. at line 1 column 46 near "));"; drop table if exists tbl_decimal; drop table if exists t1; create table t1 (id int not null, str char(10)); @@ -407,4 +406,4 @@ a 0 0 0 -1 \ No newline at end of file +1 diff --git a/test/distributed/cases/optimistic/isolation_2.result b/test/distributed/cases/optimistic/isolation_2.result index 29ef7baf3d423..f799cc779249c 100644 --- a/test/distributed/cases/optimistic/isolation_2.result +++ b/test/distributed/cases/optimistic/isolation_2.result @@ -468,7 +468,7 @@ a b c commit; commit; update dis_table_04 set b=(select 'kkkk') where a=879; -Duplicate entry 'kkkk' for key '__mo_index_idx_col' +Duplicate entry 'kkkk' for key 'b' select * from dis_table_04; a b c 6666 kkkk 2010-11-25 00:00:00 diff --git a/test/distributed/cases/optimistic/unique_secondary_index.result b/test/distributed/cases/optimistic/unique_secondary_index.result index 11fbcf83ec3bf..74a80e96ddd3e 100644 --- a/test/distributed/cases/optimistic/unique_secondary_index.result +++ b/test/distributed/cases/optimistic/unique_secondary_index.result @@ -3,7 +3,7 @@ insert into index_01 values (1,'13456789872',20.23,'5678'),(2,'13873458290',100. insert into index_01 values (67834,'13456789872',20.23,'4090'),(56473,'13456789872',100.00,'5678'); Duplicate entry '13456789872' for key 'col2' insert into index_01 values (4,'13866666666',20.23,'5678'),(5,'13873458290',100.00,'23'),(6,'13777777777',100.00,'23'); -Duplicate entry '13873458290' for key '__mo_index_idx_col' +Duplicate entry '13873458290' for key 'col2' select col2,col4 from index_01; col2 col4 13456789872 5678 @@ -12,7 +12,7 @@ null 23 create table index_02 (col1 bigint primary key,col2 char(25) unique key,col3 float,col4 char(50),key num_id(col4)); insert into index_02 values (67834,'13456789872',20.23,'5678'),(56473,'',100.00,'5678'); insert into index_02 values (1,'',20.23,'5678'),(2,'13873458290',100.00,'23'); -Duplicate entry '' for key '__mo_index_idx_col' +Duplicate entry '' for key 'col2' insert into index_02 values (67834,'13456799878',20.23,'4090'),(56473,NULL,100.00,''); Duplicate entry '67834' for key 'col1' insert into index_02 values (3,'excel',0.1,'4090'),(4,'中文',0.2,''),(5,'MMEabc$%^123',0.2,''); @@ -167,7 +167,7 @@ create table index_table_01 (col1 bigint auto_increment primary key,col2 varchar insert into index_table_01 values (67834,'13456789872',20.23,4090),(56473,'',100.00,5678); insert into index_table_01 values (34,NULL,4090,1); insert into index_table_01 values (56478,'',103.00,5670); -Duplicate entry '' for key '__mo_index_idx_col' +Duplicate entry '' for key 'col2' select * from index_table_01; col1 col2 col3 col4 67834 13456789872 20.23 4090 @@ -259,7 +259,7 @@ create table index_table_04 (col1 bigint not null auto_increment,col2 varchar(25 insert into index_table_04(col2,col3,col4) select 'apple',1,'10'; insert into index_table_04(col2,col3,col4) select 'apple',2,'11'; insert into index_table_04(col2,col3,col4) select 'apple',2,'12'; -Duplicate entry '(apple,2)' for key '__mo_index_idx_col' +Duplicate entry '(apple,2)' for key 'm1' insert into index_table_04(col2,col3,col4) select NULL,NULL,'13'; select * from index_table_04; col1 col2 col3 col4 @@ -292,7 +292,7 @@ apple bread chart update index_table_05 set col2='bread' where col1=1; -Duplicate entry 'bread' for key '__mo_index_idx_col' +Duplicate entry 'bread' for key 'col2' select * from index_table_05; col1 col2 col3 col4 1 apple 1 10 @@ -523,7 +523,7 @@ create unique index m1_index on create_index_18(col2,col3); insert into create_index_18(col2,col3,col4) select 'apple',1,'10'; insert into create_index_18(col2,col3,col4) select 'apple',2,'11'; insert into create_index_18(col2,col3,col4) select 'apple',2,'12'; -Duplicate entry '(apple,2)' for key '__mo_index_idx_col' +Duplicate entry '(apple,2)' for key 'm1_index' insert into create_index_18(col2,col3,col4) select NULL,NULL,'13'; select * from create_index_18; col1 col2 col3 col4 @@ -538,7 +538,7 @@ insert into create_index_18(col2,col3,col4) select 'apple',2,'11'; insert into create_index_18(col2,col3,col4) select 'apple',2,'12'; insert into create_index_18(col2,col3,col4) select NULL,NULL,'13'; insert into create_index_18(col2,col3,col4) select 'apple',2,'12'; -Duplicate entry '(apple,2,12)' for key '__mo_index_idx_col' +Duplicate entry '(apple,2,12)' for key 'm2_index' select * from create_index_18; col1 col2 col3 col4 1 apple 1 10 @@ -590,7 +590,7 @@ apple bread chart update create_index_19 set col2='bread' where col1=1; -Duplicate entry 'bread' for key '__mo_index_idx_col' +Duplicate entry 'bread' for key 'col2' select * from create_index_19; col1 col2 col3 col4 1 apple 1 10