diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_select.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_select.go index e08a7a9d..967d957f 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_select.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_select.go @@ -133,7 +133,7 @@ func (btc *BigtableAdapter) convertResultRow(resultRow bigtable.ResultRow, query // use the result name because that applies the correct alias key = query.ResultColumnMetadata[i].Name // use the selected column because that has the CQLType - expectedType = query.SelectClause.Columns[i].ResultType + expectedType = query.SelectClause.Columns[i].GetType() } if _, ok := result[key]; ok { diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_test.go index 12b9e812..ccd4cf1f 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/bigtable_test.go @@ -143,7 +143,7 @@ func TestInsertRow(t *testing.T) { client, err := btc.clients.GetClient(tt.keyspace) require.NoError(t, err) table := client.Open(string(tt.table)) - row, err := table.ReadRow(t.Context(), string(tt.rowKey)) + row, err := table.ReadRow(t.Context(), string(tt.rowKey), bigtable.RowFilter(bigtable.LatestNFilter(1))) require.NoError(t, err) require.NotEmpty(t, row) require.Contains(t, row, "cf1") @@ -198,7 +198,7 @@ func TestApplyBulkMutation(t *testing.T) { require.NoError(t, err) // Verify mutations - row1, err := tbl.ReadRow(t.Context(), "bulk1") + row1, err := tbl.ReadRow(t.Context(), "bulk1", bigtable.RowFilter(bigtable.LatestNFilter(1))) assert.NoError(t, err) assert.NotEmpty(t, row1) assert.Equal(t, []byte(nil), row1["cf1"][0].Value) // empty row cell @@ -208,7 +208,7 @@ func TestApplyBulkMutation(t *testing.T) { assert.NoError(t, err) assert.Empty(t, row2) - row3, err := tbl.ReadRow(t.Context(), "bulk3") + row3, err := tbl.ReadRow(t.Context(), "bulk3", bigtable.RowFilter(bigtable.LatestNFilter(1))) assert.NoError(t, err) assert.NotEmpty(t, row3) assert.Equal(t, []byte(nil), row3["cf1"][0].Value) // empty row cell @@ -229,7 +229,7 @@ func TestMutateRowDeleteColumnFamily(t *testing.T) { // Verify both column families are populated tbl, err := btc.clients.GetTableClient(keyspace, tableName) require.NoError(t, err) - row, err := tbl.ReadRow(t.Context(), key) + row, err := tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.LatestNFilter(1))) require.NoError(t, err) assert.ElementsMatch(t, maps.Keys(row), []string{"cf1", "tags"}) @@ -240,7 +240,7 @@ func TestMutateRowDeleteColumnFamily(t *testing.T) { require.NoError(t, err) // Verify deletion by reading the row - row, err = tbl.ReadRow(t.Context(), key) + row, err = tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.LatestNFilter(1))) require.NoError(t, err) assert.ElementsMatch(t, maps.Keys(row), []string{"cf1"}, "cf1 should still exist and tags should be deleted") } @@ -265,7 +265,7 @@ func TestMutateRowDeleteQualifiers(t *testing.T) { // Verify deletion by reading the row tbl, err := btc.clients.GetTableClient(keyspace, tableName) require.NoError(t, err) - row, err := tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.FamilyFilter("cf1"))) + row, err := tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.ChainFilters(bigtable.FamilyFilter("cf1"), bigtable.LatestNFilter(1)))) require.NoError(t, err) var columns []string for _, item := range row["cf1"] { @@ -297,7 +297,7 @@ func TestMutateRowIfExists(t *testing.T) { tbl, err := btc.clients.GetTableClient(keyspace, tableName) require.NoError(t, err) - row, err := tbl.ReadRow(t.Context(), key1, bigtable.RowFilter(bigtable.FamilyFilter("cf1"))) + row, err := tbl.ReadRow(t.Context(), key1, bigtable.RowFilter(bigtable.ChainFilters(bigtable.FamilyFilter("cf1"), bigtable.LatestNFilter(1)))) require.NoError(t, err) assert.Equal(t, []byte(nil), row["cf1"][0].Value) // empty row cell assert.Equal(t, "v2", string(row["cf1"][1].Value), "value should be updated to v2") @@ -327,7 +327,7 @@ func TestMutateRowIfNotExists(t *testing.T) { // Verify the row is created tbl, err := btc.clients.GetTableClient(keyspace, tableName) require.NoError(t, err) - row, err := tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.FamilyFilter("cf1"))) + row, err := tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.ChainFilters(bigtable.FamilyFilter("cf1"), bigtable.LatestNFilter(1)))) require.NoError(t, err) assert.Equal(t, []byte(nil), row["cf1"][0].Value) // empty row cell assert.Equal(t, "v1", string(row["cf1"][1].Value), "row1 should be created with value v1") @@ -338,7 +338,7 @@ func TestMutateRowIfNotExists(t *testing.T) { assert.False(t, wasApplied(res)) // Verify the row is not updated - row, err = tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.FamilyFilter("cf1"))) + row, err = tbl.ReadRow(t.Context(), key, bigtable.RowFilter(bigtable.ChainFilters(bigtable.FamilyFilter("cf1"), bigtable.LatestNFilter(1)))) require.NoError(t, err) assert.Equal(t, []byte(nil), row["cf1"][0].Value) // empty row cell assert.Equal(t, "v1", string(row["cf1"][1].Value), "row1 should not be updated") diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/utils.go index dceba124..880e3a97 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/bigtable/utils.go @@ -23,6 +23,7 @@ import ( "github.com/datastax/go-cassandra-native-protocol/datatype" "github.com/datastax/go-cassandra-native-protocol/message" "github.com/datastax/go-cassandra-native-protocol/primitive" + "github.com/google/uuid" ) const ( @@ -117,15 +118,15 @@ func addBindValueIfNeeded(dynamicValue types.DynamicValue, values *types.QueryPa if dynamicValue == nil { return nil } - param, ok := dynamicValue.(*types.ParameterizedValue) - if !ok { + p := dynamicValue.GetParameter() + if p == "" { return nil } var value any if needsByteConversion { var err error - value, err = param.GetValue(values) + value, err = dynamicValue.GetValue(values) if err != nil { return err } @@ -136,7 +137,7 @@ func addBindValueIfNeeded(dynamicValue types.DynamicValue, values *types.QueryPa } } else { var err error - value, err = param.GetValue(values) + value, err = dynamicValue.GetValue(values) if err != nil { return err } @@ -148,7 +149,14 @@ func addBindValueIfNeeded(dynamicValue types.DynamicValue, values *types.QueryPa value = v[:] } } - result[string(param.Parameter)] = value + if u, ok := value.(uuid.UUID); ok { + b, err := u.MarshalBinary() + if err != nil { + return err + } + value = b + } + result[string(p)] = value return nil } @@ -190,12 +198,12 @@ func addParamIfNeeded(value types.DynamicValue, params *types.QueryParameters, n return nil } - param, ok := value.(*types.ParameterizedValue) - if !ok { + p := value.GetParameter() + if p == "" { return nil } - md, err := params.GetMetadata(param.Parameter) + md, err := params.GetMetadata(p) if err != nil { return err } @@ -204,6 +212,6 @@ func addParamIfNeeded(value types.DynamicValue, params *types.QueryParameters, n if needsByteConversion { bigtableType = bigtable.BytesSQLType{} } - result[string(param.Parameter)] = bigtableType + result[string(p)] = bigtableType return nil } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_avg.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_avg.go new file mode 100644 index 00000000..4ede9366 --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_avg.go @@ -0,0 +1,37 @@ +package types + +type FuncAvg struct { +} + +func (f *FuncAvg) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncAvg) GetName() string { + return "avg" +} + +func (f *FuncAvg) GetCode() CqlFuncCode { + return FuncCodeAvg +} + +func (f *FuncAvg) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter(AllNumericTypes, true, false), + } +} + +func (f *FuncAvg) Apply(_ []DynamicValue, value *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncAvg) GetReturnType(args []DynamicValue) CqlDataType { + if len(args) != 1 { + return TypeDouble + } + dt := args[0].GetType() + if dt.Code() == INT || dt.Code() == BIGINT { + return TypeFloat + } + return dt +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_count.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_count.go new file mode 100644 index 00000000..3790740f --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_count.go @@ -0,0 +1,30 @@ +package types + +type FuncCount struct { +} + +func (f *FuncCount) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncCount) GetName() string { + return "count" +} + +func (f *FuncCount) GetCode() CqlFuncCode { + return FuncCodeCount +} + +func (f *FuncCount) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter(AllScalarTypes, true, true), + } +} + +func (f *FuncCount) Apply(_ []DynamicValue, _ *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncCount) GetReturnType(_ []DynamicValue) CqlDataType { + return TypeBigInt +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max.go new file mode 100644 index 00000000..c730d004 --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max.go @@ -0,0 +1,33 @@ +package types + +type FuncMax struct { +} + +func (f *FuncMax) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncMax) GetName() string { + return "max" +} + +func (f *FuncMax) GetCode() CqlFuncCode { + return FuncCodeMax +} + +func (f *FuncMax) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter(AllNumericTypes, true, false), + } +} + +func (f *FuncMax) Apply(_ []DynamicValue, value *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncMax) GetReturnType(args []DynamicValue) CqlDataType { + if len(args) != 1 { + return TypeDouble + } + return args[0].GetType() +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max_timeuuid.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max_timeuuid.go new file mode 100644 index 00000000..b3b95556 --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_max_timeuuid.go @@ -0,0 +1,74 @@ +package types + +import ( + "github.com/google/uuid" + "time" +) + +type FuncMaxTimeuuid struct { +} + +func (f *FuncMaxTimeuuid) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseWhere, QueryClauseValues} +} + +func (f *FuncMaxTimeuuid) GetName() string { + return "maxTimeuuid" +} + +func (f *FuncMaxTimeuuid) GetCode() CqlFuncCode { + return FuncCodeMaxTimeuuid +} + +func (f *FuncMaxTimeuuid) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter( + []CqlDataType{ + TypeTimestamp, + }, + false, + false), + } +} + +func (f *FuncMaxTimeuuid) Apply(args []DynamicValue, values *QueryParameterValues) (GoValue, error) { + u, err := getTimeArg(0, args, values) + if err != nil { + return nil, err + } + return maxUUIDv1ForTime(u) +} + +func (f *FuncMaxTimeuuid) GetReturnType(args []DynamicValue) CqlDataType { + return TypeTimeuuid +} + +// maxUUIDv1ForTime creates the maximum possible UUIDv1 for a given time.Time. +// This is achieved by setting the timestamp fields based on the input time, +// and setting the Clock Sequence and Node ID fields to their maximum values. +func maxUUIDv1ForTime(t time.Time) (uuid.UUID, error) { + // For maxTimeuuid, Cassandra adds 9999 to the 100-nanosecond intervals timestamp. + // 9999 * 100 nanoseconds. + maxT := t.Add(9999 * 100 * time.Nanosecond) + u := setUuidV1Time(maxT, [16]byte{}) + + // --- Clock Sequence & Node ID Fields (Maxed Values) --- + // clock_seq_hi_and_variant (byte 8, 8 bits) + // The variant bits must be 10 (0x80 to 0xBF). We set the clock sequence to max. + // 0xBF is 0b10111111 (variant 10 and max 6 bits for the clock sequence high part) + u[8] = 0xBF + + // clock_seq_low (byte 9, 8 bits) + u[9] = 0xFF + + // Node ID (bytes 10-15, 48 bits) - set to all F's (max) + u[10] = 0xFF + u[11] = 0xFF + u[12] = 0xFF + u[13] = 0xFF + u[14] = 0xFF + u[15] = 0xFF + + // Create the UUID from the byte array + return u, nil +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min.go new file mode 100644 index 00000000..cc2a580b --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min.go @@ -0,0 +1,33 @@ +package types + +type FuncMin struct { +} + +func (f *FuncMin) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncMin) GetName() string { + return "min" +} + +func (f *FuncMin) GetCode() CqlFuncCode { + return FuncCodeMin +} + +func (f *FuncMin) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter(AllNumericTypes, true, false), + } +} + +func (f *FuncMin) Apply(_ []DynamicValue, value *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncMin) GetReturnType(args []DynamicValue) CqlDataType { + if len(args) != 1 { + return TypeDouble + } + return args[0].GetType() +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min_timeuuid.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min_timeuuid.go new file mode 100644 index 00000000..1d99f03e --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_min_timeuuid.go @@ -0,0 +1,69 @@ +package types + +import ( + "github.com/google/uuid" + "time" +) + +type FuncMinTimeuuid struct { +} + +func (f *FuncMinTimeuuid) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseWhere, QueryClauseValues} +} + +func (f *FuncMinTimeuuid) GetName() string { + return "minTimeuuid" +} + +func (f *FuncMinTimeuuid) GetCode() CqlFuncCode { + return FuncCodeMinTimeuuid +} + +func (f *FuncMinTimeuuid) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter( + []CqlDataType{ + TypeTimestamp, + }, + false, + false), + } +} + +func (f *FuncMinTimeuuid) Apply(args []DynamicValue, values *QueryParameterValues) (GoValue, error) { + u, err := getTimeArg(0, args, values) + if err != nil { + return nil, err + } + return minUUIDv1ForTime(u) +} + +func (f *FuncMinTimeuuid) GetReturnType(args []DynamicValue) CqlDataType { + return TypeTimeuuid +} + +func minUUIDv1ForTime(t time.Time) (uuid.UUID, error) { + u := setUuidV1Time(t, [16]byte{}) + + // --- Clock Sequence & Node ID Fields (Minned Values) --- + + // clock_seq_hi_and_variant (byte 8, 8 bits) + // The variant bits must be 10 (0x80 to 0xBF). We set the clock sequence to min (0). + // 0x80 is 0b10000000 (variant 10 and min 6 bits for the clock sequence high part) + u[8] = 0x80 + + // clock_seq_low (byte 9, 8 bits) + u[9] = 0x00 // Min 8 bits + + // Node ID (bytes 10-15, 48 bits) - set to all 0's (min) + u[10] = 0x00 + u[11] = 0x00 + u[12] = 0x00 + u[13] = 0x00 + u[14] = 0x00 + u[15] = 0x00 + + // Create the UUID from the byte array + return u, nil +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_now.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_now.go new file mode 100644 index 00000000..ef47d78b --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_now.go @@ -0,0 +1,42 @@ +package types + +import ( + "fmt" + "github.com/google/uuid" +) + +type FuncNow struct { +} + +func (f *FuncNow) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseWhere, QueryClauseValues} +} + +func (f *FuncNow) GetName() string { + return "now" +} + +func (f *FuncNow) GetCode() CqlFuncCode { + return FuncCodeNow +} + +func (f *FuncNow) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{} +} + +func (f *FuncNow) Apply(_ []DynamicValue, value *QueryParameterValues) (GoValue, error) { + id, err := uuid.NewUUID() + if err != nil { + return nil, err + } + if id.Version() != 1 { + return nil, fmt.Errorf("internal: timeuuid must be v1") + } + // sync with query "now" + setUuidV1Time(value.time, id) + return id, nil +} + +func (f *FuncNow) GetReturnType(_ []DynamicValue) CqlDataType { + return TypeTimeuuid +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_sum.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_sum.go new file mode 100644 index 00000000..0ce4003a --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_sum.go @@ -0,0 +1,33 @@ +package types + +type FuncSum struct { +} + +func (f *FuncSum) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncSum) GetName() string { + return "sum" +} + +func (f *FuncSum) GetCode() CqlFuncCode { + return FuncCodeSum +} + +func (f *FuncSum) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter(AllNumericTypes, true, false), + } +} + +func (f *FuncSum) Apply(_ []DynamicValue, value *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncSum) GetReturnType(args []DynamicValue) CqlDataType { + if len(args) != 1 { + return TypeDouble + } + return args[0].GetType() +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_to_timestamp.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_to_timestamp.go new file mode 100644 index 00000000..3ee7f280 --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_to_timestamp.go @@ -0,0 +1,50 @@ +package types + +import ( + "github.com/google/uuid" + "time" +) + +type FuncToTimestamp struct { +} + +func (f *FuncToTimestamp) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseWhere, QueryClauseValues} +} + +func (f *FuncToTimestamp) GetName() string { + return "toTimestamp" +} + +func (f *FuncToTimestamp) GetCode() CqlFuncCode { + return FuncCodeToTimestamp +} + +func (f *FuncToTimestamp) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + *NewCqlFuncParameter( + []CqlDataType{ + TypeTimeuuid, + }, + false, + false, + ), + } +} + +func (f *FuncToTimestamp) Apply(args []DynamicValue, values *QueryParameterValues) (GoValue, error) { + u, err := getUuidArg(0, args, values) + if err != nil { + return nil, err + } + return getTimeFromUUID(u) +} + +func (f *FuncToTimestamp) GetReturnType(_ []DynamicValue) CqlDataType { + return TypeTimestamp +} + +func getTimeFromUUID(id uuid.UUID) (time.Time, error) { + sec, nsec := id.Time().UnixTime() + return time.Unix(sec, nsec).UTC(), nil +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_writetime.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_writetime.go new file mode 100644 index 00000000..b6637b5a --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_func_writetime.go @@ -0,0 +1,31 @@ +package types + +type FuncWritetime struct { +} + +func (f *FuncWritetime) GetValidClauses() []QueryClause { + return []QueryClause{QueryClauseSelect} +} + +func (f *FuncWritetime) GetName() string { + return "writetime" +} + +func (f *FuncWritetime) GetCode() CqlFuncCode { + return FuncCodeWriteTime +} + +func (f *FuncWritetime) GetParameterTypes() []CqlFuncParameter { + return []CqlFuncParameter{ + // todo what about collections? + *NewCqlFuncParameter(AllScalarTypes, true, false), + } +} + +func (f *FuncWritetime) Apply(_ []DynamicValue, _ *QueryParameterValues) (GoValue, error) { + return nil, nil +} + +func (f *FuncWritetime) GetReturnType(_ []DynamicValue) CqlDataType { + return TypeBigInt +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_funcs.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_funcs.go new file mode 100644 index 00000000..a0ccbb45 --- /dev/null +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_funcs.go @@ -0,0 +1,177 @@ +package types + +import ( + "encoding/binary" + "fmt" + "github.com/google/uuid" + "time" +) + +type CqlFuncCode int + +const ( + FuncCodeUnknown CqlFuncCode = iota + FuncCodeWriteTime + FuncCodeCount + FuncCodeAvg + FuncCodeSum + FuncCodeMin + FuncCodeMax + FuncCodeNow + FuncCodeToTimestamp + FuncCodeMinTimeuuid + FuncCodeMaxTimeuuid + FuncCodeUUID +) + +type CqlFunc interface { + GetName() string + GetCode() CqlFuncCode + GetValidClauses() []QueryClause + GetParameterTypes() []CqlFuncParameter + Apply(args []DynamicValue, value *QueryParameterValues) (GoValue, error) + GetReturnType(args []DynamicValue) CqlDataType +} + +type CqlFuncParameter struct { + Types []CqlDataType + AllowColumn bool + AllowStar bool +} + +func NewCqlFuncParameter(Types []CqlDataType, allowColumn bool, allowStar bool) *CqlFuncParameter { + return &CqlFuncParameter{Types: Types, AllowColumn: allowColumn, AllowStar: allowStar} +} + +var ( + WriteTime CqlFunc = &FuncWritetime{} + Count CqlFunc = &FuncCount{} + Avg CqlFunc = &FuncAvg{} + Sum CqlFunc = &FuncSum{} + Min CqlFunc = &FuncMin{} + Max CqlFunc = &FuncMax{} + Now CqlFunc = &FuncNow{} + ToTimestamp CqlFunc = &FuncToTimestamp{} + MinTimeuuid CqlFunc = &FuncMinTimeuuid{} + MaxTimeuuid CqlFunc = &FuncMaxTimeuuid{} +) + +func GetFunc(c CqlFuncCode) (CqlFunc, error) { + switch c { + case FuncCodeWriteTime: + return WriteTime, nil + case FuncCodeCount: + return Count, nil + case FuncCodeAvg: + return Avg, nil + case FuncCodeSum: + return Sum, nil + case FuncCodeMin: + return Min, nil + case FuncCodeMax: + return Max, nil + case FuncCodeNow: + return Now, nil + case FuncCodeToTimestamp: + return ToTimestamp, nil + case FuncCodeMinTimeuuid: + return MinTimeuuid, nil + case FuncCodeMaxTimeuuid: + return MaxTimeuuid, nil + default: + return nil, fmt.Errorf("unknown func") + } +} + +func setUuidV1Time(t time.Time, id uuid.UUID) uuid.UUID { + const epochOffset = 122192928000000000 + + // Convert Unix time to 100-ns intervals + unixIntervals := t.Unix()*10000000 + int64(t.Nanosecond()/100) + + // Add the offset + uuidTime := uint64(unixIntervals + epochOffset) + + // 2. Breakdown the 60-bit timestamp into fields + // UUID v1 Layout: + // Time Low (32 bits) + // Time Mid (16 bits) + // Time High & Version (16 bits) + + timeLow := uint32(uuidTime & 0xFFFFFFFF) + timeMid := uint16((uuidTime >> 32) & 0xFFFF) + timeHi := uint16((uuidTime >> 48) & 0x0FFF) + + // 3. Write bytes into the UUID structure (Big Endian) + + // Bytes 0-3: Time Low + binary.BigEndian.PutUint32(id[0:4], timeLow) + + // Bytes 4-5: Time Mid + binary.BigEndian.PutUint16(id[4:6], timeMid) + + // Bytes 6-7: Time High + Version + // We combine the high time bits with the Version 1 identifier (0x1000) + binary.BigEndian.PutUint16(id[6:8], timeHi|0x1000) + return id +} + +func getUuidArg(index int, args []DynamicValue, values *QueryParameterValues) (uuid.UUID, error) { + value, err := args[index].GetValue(values) + if err != nil { + return [16]byte{}, err + } + + u, ok := value.(uuid.UUID) + if !ok { + return [16]byte{}, fmt.Errorf("invalid argment: %T expected uuid", value) + } + return u, nil +} + +func getTimeArg(index int, args []DynamicValue, values *QueryParameterValues) (time.Time, error) { + value, err := args[index].GetValue(values) + if err != nil { + return time.Time{}, err + } + + u, ok := value.(time.Time) + if !ok { + return time.Time{}, fmt.Errorf("invalid argment: %T expected time.Time", value) + } + return u, nil +} + +func ValidateFunctionArgs(f *FunctionValue) error { + if len(f.Func.GetParameterTypes()) != len(f.Args) { + return fmt.Errorf("function '%s' expects %d args but got %d", f.Func.GetName(), len(f.Func.GetParameterTypes()), len(f.Args)) + } + + for i, arg := range f.Args { + param := f.Func.GetParameterTypes()[i] + star := IsSelectStar(arg) + if !param.AllowStar && star { + return fmt.Errorf("function '%s' doesn't allow '*' args for parameter %d", f.Func.GetName(), i) + } + if !param.AllowColumn && IsColumn(arg) { + return fmt.Errorf("function '%s' doesn't allow column args for parameter %d", f.Func.GetName(), i) + } + + // star is allowed so it's ok + if star { + continue + } + + isValidType := false + for _, paramType := range param.Types { + if paramType == arg.GetType() { + isValidType = true + break + } + } + if !isValidType { + return fmt.Errorf("function '%s' parameter %d doesn't accept type %s", f.Func.GetName(), i, arg.GetType().String()) + } + } + return nil +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_functions.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_functions.go deleted file mode 100644 index b30ec443..00000000 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_functions.go +++ /dev/null @@ -1,140 +0,0 @@ -package types - -import ( - "encoding/binary" - "fmt" - "github.com/datastax/go-cassandra-native-protocol/primitive" - "github.com/gocql/gocql" - "github.com/google/uuid" - "time" -) - -type CqlFuncCode int - -const ( - FuncCodeUnknown CqlFuncCode = iota - FuncCodeWriteTime - FuncCodeCount - FuncCodeAvg - FuncCodeSum - FuncCodeMin - FuncCodeMax - FuncCodeNow - FuncCodeToTimestamp -) - -func (c CqlFuncCode) String() string { - switch c { - case FuncCodeWriteTime: - return "writetime" - case FuncCodeCount: - return "count" - case FuncCodeAvg: - return "avg" - case FuncCodeSum: - return "sum" - case FuncCodeMin: - return "min" - case FuncCodeMax: - return "max" - case FuncCodeNow: - return "now" - case FuncCodeToTimestamp: - return "totimestamp" - default: - return "unknown" - } -} - -type CqlFuncSpec struct { - Code CqlFuncCode - ParameterTypes []CqlDataType - ReturnType CqlDataType - Apply func(args []GoValue) (GoValue, error) -} - -func NewCqlFuncSpec(code CqlFuncCode, parameterTypes []CqlDataType, returnType CqlDataType, apply func(args []GoValue) (GoValue, error)) *CqlFuncSpec { - return &CqlFuncSpec{Code: code, ParameterTypes: parameterTypes, ReturnType: returnType, Apply: apply} -} - -var ( - FuncNow = NewCqlFuncSpec(FuncCodeNow, nil, TypeTimeuuid, now) - FuncToTimestamp = NewCqlFuncSpec(FuncCodeToTimestamp, []CqlDataType{TypeTimeuuid}, TypeTimestamp, toTimestamp) -) - -func GetCqlFunc(code CqlFuncCode) (*CqlFuncSpec, error) { - switch code { - //case FuncCodeUnknown: - // return FuncUnknown, nil - //case FuncCodeWriteTime: - // return FuncWriteTime, nil - //case FuncCodeCount: - // return FuncCount, nil - //case FuncCodeAvg: - // return FuncAvg, nil - //case FuncCodeSum: - // return FuncSum, nil - //case FuncCodeMin: - // return FuncMin, nil - //case FuncCodeMax: - // return FuncMax, nil - case FuncCodeNow: - return FuncNow, nil - case FuncCodeToTimestamp: - return FuncToTimestamp, nil - default: - return nil, fmt.Errorf("unknown function code %s (%d)", code.String(), code) - } -} - -func now(_ []GoValue) (GoValue, error) { - // Cassandra's now() function typically returns a timeuuid (UUIDv1 or UUIDv7). - // Using gocql.TimeUUID() generates a UUIDv1. - u := gocql.TimeUUID() - return primitive.UUID(u), nil -} -func toTimestamp(args []GoValue) (GoValue, error) { - if len(args) != 1 { - return nil, fmt.Errorf("invalid arguments") - } - - p, ok := args[0].(primitive.UUID) - if !ok { - return nil, fmt.Errorf("invalid argument: %T expected primitive.UUID", args[0]) - } - u := uuid.UUID(p) - if u.Version() == 1 { - sec, nsec := u.Time().UnixTime() - return time.Unix(sec, nsec).UTC(), nil - } - if u.Version() == 7 { - return GetTimeFromUUIDv7(p) - } - return nil, fmt.Errorf("unsupported uuid version: %d", u.Version()) -} - -func GetTimeFromUUIDv7(p primitive.UUID) (time.Time, error) { - id := uuid.UUID(p) - // 1. Check the UUID version. UUIDv7 has the '7' in the 4 most significant bits - // of the 7th byte (index 6). This is a good sanity check. - if id.Version() != 7 { - return time.Time{}, fmt.Errorf("uuid version is %d, expected 7", id.Version()) - } - - // UUIDv7 structure: - // Bits 0-47: 48-bit Unix Epoch time in milliseconds (6 bytes) - // Bits 48-51: 4-bit version (7) - // ... rest is reserved/random - timestamp64 := binary.BigEndian.Uint64(id[:8]) - - // 3. Shift right by 16 bits to discard the version/reserved bits and move - // the 48-bit millisecond timestamp to the least significant position. - milliseconds := int64(timestamp64 >> 16) - - // 4. Convert milliseconds to time. - // time.Unix takes seconds and nanoseconds, so we need to divide the milliseconds. - seconds := milliseconds / 1000 - nanos := (milliseconds % 1000) * int64(time.Millisecond) // Remaining millis * 1,000,000 nanosec/millis - - return time.Unix(seconds, nanos).UTC(), nil -} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_types.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_types.go index 422c4393..f5c7f230 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_types.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/cql_types.go @@ -146,6 +146,42 @@ var ( TypeVarint CqlDataType = newScalarType("varint", VARINT, datatype.Varint, reflect.TypeOf(1), bigtable.StringSQLType{}) ) +var ( + AllScalarTypes = []CqlDataType{ + TypeAscii, + TypeVarchar, + TypeBigInt, + TypeBlob, + TypeBoolean, + TypeCounter, + TypeDate, + TypeDecimal, + TypeDouble, + TypeFloat, + TypeInet, + TypeInt, + TypeSmallint, + TypeText, + TypeTime, + TypeTimestamp, + TypeTimeuuid, + TypeTinyint, + TypeUuid, + TypeVarint, + } + AllNumericTypes = []CqlDataType{ + TypeBigInt, + TypeCounter, + TypeDecimal, + TypeDouble, + TypeFloat, + TypeInt, + TypeSmallint, + TypeTinyint, + TypeVarint, + } +) + type MapType struct { keyType CqlDataType valueType CqlDataType diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/dynamic_value.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/dynamic_value.go index 572648f9..54db3afa 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/dynamic_value.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/dynamic_value.go @@ -1,17 +1,27 @@ package types import ( - "github.com/datastax/go-cassandra-native-protocol/primitive" - "github.com/gocql/gocql" + "fmt" ) type DynamicValue interface { GetValue(values *QueryParameterValues) (GoValue, error) IsIdempotent() bool + GetParameter() Parameter + GetType() CqlDataType } type ParameterizedValue struct { - Parameter Parameter + parameter Parameter + dataType CqlDataType +} + +func (p *ParameterizedValue) GetParameter() Parameter { + return p.parameter +} + +func (p *ParameterizedValue) GetType() CqlDataType { + return p.dataType } func (p *ParameterizedValue) IsIdempotent() bool { @@ -19,11 +29,11 @@ func (p *ParameterizedValue) IsIdempotent() bool { } func (p *ParameterizedValue) GetValue(values *QueryParameterValues) (GoValue, error) { - return values.GetValue(p.Parameter) + return values.GetValue(p.parameter) } -func NewParameterizedValue(parameter Parameter) DynamicValue { - return &ParameterizedValue{Parameter: parameter} +func NewParameterizedValue(parameter Parameter, dt CqlDataType) DynamicValue { + return &ParameterizedValue{parameter: parameter, dataType: dt} } type TimestampNowValue struct { @@ -37,40 +47,172 @@ func (f *TimestampNowValue) GetValue(values *QueryParameterValues) (GoValue, err return values.Time(), nil } -func NewTimestampNowValue() DynamicValue { - return &TimestampNowValue{} +type LiteralValue struct { + Value GoValue + dt CqlDataType +} + +func (l *LiteralValue) GetParameter() Parameter { + return "" +} + +func (l *LiteralValue) GetType() CqlDataType { + return l.dt +} + +func (l *LiteralValue) IsIdempotent() bool { + return true +} + +func (l *LiteralValue) GetValue(values *QueryParameterValues) (GoValue, error) { + return l.Value, nil } -type TimeuuidNowValue struct { +func NewLiteralValue(value GoValue, dt CqlDataType) DynamicValue { + return &LiteralValue{Value: value, dt: dt} } -func (f *TimeuuidNowValue) IsIdempotent() bool { +type FunctionValue struct { + Parameter Parameter + Func CqlFunc + Args []DynamicValue +} + +func (f FunctionValue) GetType() CqlDataType { + return f.Func.GetReturnType(f.Args) +} + +func (f FunctionValue) GetParameter() Parameter { + return f.Parameter +} + +func (f FunctionValue) GetValue(values *QueryParameterValues) (GoValue, error) { + apply, err := f.Func.Apply(f.Args, values) + if err != nil { + return nil, err + } + return apply, nil +} + +func (f FunctionValue) IsIdempotent() bool { return false } -func (f *TimeuuidNowValue) GetValue(values *QueryParameterValues) (GoValue, error) { - // Cassandra's now() function typically returns a timeuuid (UUIDv1 or UUIDv7). - // Using gocql.TimeUUID() generates a UUIDv1. - u := gocql.TimeUUID() - return primitive.UUID(u), nil +func NewFunctionValue(p Parameter, f CqlFunc, args ...DynamicValue) *FunctionValue { + return &FunctionValue{ + Parameter: p, + Func: f, + Args: args, + } } -func NewTimeuuidNowValue() DynamicValue { - return &TimeuuidNowValue{} +type ColumnValue struct { + Column *Column } -type LiteralValue struct { - Value GoValue +func (c ColumnValue) GetType() CqlDataType { + return c.Column.CQLType } -func (l *LiteralValue) IsIdempotent() bool { +func (c ColumnValue) GetValue(values *QueryParameterValues) (GoValue, error) { + return nil, fmt.Errorf("cannot get value on a column") +} + +func (c ColumnValue) IsIdempotent() bool { return true } -func (l *LiteralValue) GetValue(values *QueryParameterValues) (GoValue, error) { - return l.Value, nil +func (c ColumnValue) GetParameter() Parameter { + return "" +} + +func NewColumnValue(column *Column) DynamicValue { + return &ColumnValue{Column: column} +} + +type SelectStarValue struct { +} + +func (c SelectStarValue) GetType() CqlDataType { + return TypeText +} + +func (c SelectStarValue) GetValue(values *QueryParameterValues) (GoValue, error) { + return nil, fmt.Errorf("cannot get value on a select * value") +} + +func (c SelectStarValue) IsIdempotent() bool { + return true +} + +func (c SelectStarValue) GetParameter() Parameter { + return "" +} + +func NewSelectStarValue() DynamicValue { + return &SelectStarValue{} +} + +type MapAccessValue struct { + Column *Column + mapType *MapType + // placeholders are NOT allowed + MapKey ColumnQualifier +} + +func NewMapAccessValue(column *Column, mapType *MapType, mapKey ColumnQualifier) DynamicValue { + return &MapAccessValue{Column: column, mapType: mapType, MapKey: mapKey} +} + +func (m MapAccessValue) GetValue(values *QueryParameterValues) (GoValue, error) { + return nil, fmt.Errorf("GetValue not allowed") +} + +func (m MapAccessValue) IsIdempotent() bool { + return true +} + +func (m MapAccessValue) GetParameter() Parameter { + return "" +} + +func (m MapAccessValue) GetType() CqlDataType { + return m.mapType.valueType +} + +type ListElementValue struct { + Column *Column + listType *ListType + // placeholders are NOT allowed + ListIndex int64 +} + +func NewListElementValue(column *Column, listType *ListType, listIndex int64) DynamicValue { + return &ListElementValue{Column: column, listType: listType, ListIndex: listIndex} +} + +func (l ListElementValue) GetValue(values *QueryParameterValues) (GoValue, error) { + return nil, fmt.Errorf("GetValue not allowed") +} + +func (l ListElementValue) IsIdempotent() bool { + return true +} + +func (l ListElementValue) GetParameter() Parameter { + return "" +} + +func (l ListElementValue) GetType() CqlDataType { + return l.listType.elementType +} + +func IsSelectStar(v DynamicValue) bool { + _, ok := v.(SelectStarValue) + return ok } -func NewLiteralValue(value GoValue) DynamicValue { - return &LiteralValue{Value: value} +func IsColumn(v DynamicValue) bool { + _, ok := v.(ColumnValue) + return ok } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/queries.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/queries.go index 50b81589..3682501c 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/queries.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/queries.go @@ -80,6 +80,21 @@ const ( CONTAINS_KEY Operator = "CONTAINS KEY" ) +func FlipOperator(op Operator) Operator { + switch op { + case GT: + return LT + case LT: + return GT + case GTE: + return LTE + case LTE: + return LTE + default: + return op + } +} + type ArithmeticOperator string const ( diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters.go index 28b149a9..4ac7df02 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters.go @@ -2,6 +2,7 @@ package types import ( "fmt" + "reflect" "time" ) @@ -16,7 +17,8 @@ type ParameterMetadata struct { IsNamed bool Type CqlDataType // can be null if the placeholder is not related to a specific column - Column *Column + Column *Column + IsInternal bool } func newParameterMetadata( @@ -25,8 +27,9 @@ func newParameterMetadata( isNamed bool, tpe CqlDataType, column *Column, + isInternal bool, ) *ParameterMetadata { - return &ParameterMetadata{Key: key, Order: order, IsNamed: isNamed, Type: tpe, Column: column} + return &ParameterMetadata{Key: key, Order: order, IsNamed: isNamed, Type: tpe, Column: column, IsInternal: isInternal} } type QueryParameters struct { @@ -61,6 +64,17 @@ func (q *QueryParameters) Count() int { return len(q.ordered) } +func (q *QueryParameters) CountUserParameters() int { + result := 0 + for _, metadata := range q.params { + if metadata.IsInternal { + continue + } + result++ + } + return result +} + func (q *QueryParameters) Ordered() []*ParameterMetadata { result := make([]*ParameterMetadata, len(q.ordered)) for _, metadata := range q.params { @@ -69,6 +83,19 @@ func (q *QueryParameters) Ordered() []*ParameterMetadata { return result } +func (q *QueryParameters) OrderedUserParams() []*ParameterMetadata { + ordered := q.Ordered() + result := make([]*ParameterMetadata, 0, len(ordered)) + for _, p := range ordered { + // don't return internal params because we don't want the user to bind to them + if p.IsInternal { + continue + } + result = append(result, p) + } + return result +} + type QueryParameterValues struct { params *QueryParameters time time.Time @@ -105,3 +132,90 @@ func (q *QueryParameterValues) AllValuesSet() bool { func (q *QueryParameterValues) AsMap() map[Parameter]GoValue { return q.values } +func (q *QueryParameterValues) GetValueInt32(dv DynamicValue) (int32, error) { + value, err := dv.GetValue(q) + if err != nil { + return 0, err + } + intVal, ok := value.(int32) + if !ok { + return 0, fmt.Errorf("query value is a %T, not an int32", value) + } + return intVal, nil +} + +func (q *QueryParameterValues) GetValueInt64(dv DynamicValue) (int64, error) { + v, err := dv.GetValue(q) + if err != nil { + return 0, err + } + intVal, ok := v.(int64) + if !ok { + return 0, fmt.Errorf("query value is a %T, not an int64", v) + } + return intVal, nil +} + +func (q *QueryParameterValues) GetValueTime(dv DynamicValue) (time.Time, error) { + v, err := dv.GetValue(q) + if err != nil { + return time.Time{}, err + } + t, ok := v.(time.Time) + if !ok { + return time.Time{}, fmt.Errorf("query value is a %T, not a time", v) + } + return t, nil +} + +func (q *QueryParameterValues) GetValueSlice(dv DynamicValue) ([]GoValue, error) { + v, err := dv.GetValue(q) + if err != nil { + return nil, err + } + + val := reflect.ValueOf(v) + + if val.Kind() != reflect.Slice { + return nil, fmt.Errorf("query value is a %T, not a slice", v) + } + + length := val.Len() + result := make([]GoValue, length) + + for i := 0; i < length; i++ { + result[i] = val.Index(i).Interface() + } + + return result, nil +} + +func (q *QueryParameterValues) GetValueMap(dv DynamicValue) (map[GoValue]GoValue, error) { + v, err := dv.GetValue(q) + if err != nil { + return nil, err + } + val := reflect.ValueOf(v) + + if val.Kind() != reflect.Map { + return nil, fmt.Errorf("value is a %T, not a map", v) + } + + result := make(map[GoValue]GoValue, val.Len()) + + // 3. Iterate over the keys of the original map + iter := val.MapRange() + for iter.Next() { + // Get the reflection Placeholder for the key and the value + keyVal := iter.Key() + valueVal := iter.Value() + + // 4. Use .Interface() to convert the concrete key/value to an any (interface{}) + keyAny := keyVal.Interface() + valueAny := valueVal.Interface() + + // 5. Add to the new map[any]any + result[keyAny] = valueAny + } + return result, nil +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters_builder.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters_builder.go index 2d4fd11a..828c7b79 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters_builder.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/query_parameters_builder.go @@ -29,7 +29,18 @@ func (q *QueryParameterBuilder) AddPositionalParam(dt CqlDataType, c *Column) (P // could happen if named parameters are also used (which is not allowed in cql) return "", errors.New("unexpected positional param key already exists") } - q.metadata[p] = newParameterMetadata(p, q.getNextIndex(), false, dt, c) + q.metadata[p] = newParameterMetadata(p, q.getNextIndex(), false, dt, c, false) + return p, nil +} + +func (q *QueryParameterBuilder) AddInternalParam(dt CqlDataType) (Parameter, error) { + p := q.getNextParameter() + _, exists := q.metadata[p] + if exists { + // could happen if named parameters are also used (which is not allowed in cql) + return "", errors.New("unexpected positional param key already exists") + } + q.metadata[p] = newParameterMetadata(p, q.getNextIndex(), false, dt, nil, true) return p, nil } @@ -41,7 +52,7 @@ func (q *QueryParameterBuilder) AddNamedParam(p Parameter, dt CqlDataType) error // we already have this param so we can return now return nil } - q.metadata[p] = newParameterMetadata(p, q.getNextIndex(), true, dt, nil) + q.metadata[p] = newParameterMetadata(p, q.getNextIndex(), true, dt, nil, false) return nil } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/select_query.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/select_query.go index 5e208e4a..e3cca16d 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/select_query.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/select_query.go @@ -9,32 +9,17 @@ import ( // SelectedColumn describes a column that was selected as part of a query. It's // an output of query translating, and is also used for response construction. type SelectedColumn struct { - // Sql is the original value of the selected column, including functions, not including alias. e.g. "region" or "count(*)" - Sql string - Func CqlFuncCode - // placeholders are NOT allowed - MapKey ColumnQualifier - // placeholders are NOT allowed - ListIndex int64 - // ColumnName is the name of the underlying column in a function, or map key - // access. e.g. the column name of "max(price)" is "price" - ColumnName ColumnName - Alias string - ResultType CqlDataType + Cql string + Value DynamicValue + Alias string } -func NewSelectedColumn(sql string, columnName ColumnName, alias string, resultType CqlDataType) *SelectedColumn { - return &SelectedColumn{Sql: sql, ColumnName: columnName, Alias: alias, ResultType: resultType, ListIndex: -1} +func (s SelectedColumn) GetType() CqlDataType { + return s.Value.GetType() } -func NewSelectedColumnListElement(sql string, columnName ColumnName, alias string, resultType CqlDataType, listIndex int64) *SelectedColumn { - return &SelectedColumn{Sql: sql, Alias: alias, ColumnName: columnName, ResultType: resultType, ListIndex: listIndex} -} -func NewSelectedColumnMapElement(sql string, columnName ColumnName, alias string, resultType CqlDataType, key ColumnQualifier) *SelectedColumn { - return &SelectedColumn{Sql: sql, Alias: alias, ColumnName: columnName, ResultType: resultType, MapKey: key, ListIndex: -1} -} -func NewSelectedColumnFunction(sql string, columnName ColumnName, alias string, resultType CqlDataType, funcCode CqlFuncCode) *SelectedColumn { - return &SelectedColumn{Sql: sql, Alias: alias, ColumnName: columnName, ResultType: resultType, Func: funcCode, ListIndex: -1} +func NewSelectedColumn(cql string, value DynamicValue, alias string) SelectedColumn { + return SelectedColumn{Cql: cql, Value: value, Alias: alias} } // PreparedSelectQuery represents the mapping of a select query along with its translation details. diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/types.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/types.go index 333a4320..b6f25fc8 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/types.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types/types.go @@ -271,3 +271,24 @@ func (r *RawQuery) Header() *frame.Header { type ICassandraClient interface { SetSessionKeyspace(k Keyspace) } + +type QueryClause int + +const ( + QueryClauseSelect QueryClause = iota + QueryClauseWhere + QueryClauseValues +) + +func (c QueryClause) String() string { + switch c { + case QueryClauseSelect: + return "select" + case QueryClauseWhere: + return "where" + case QueryClauseValues: + return "values" + default: + return "unknown" + } +} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/mem_table/in_mem_select.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/mem_table/in_mem_select.go index b8295b9a..3991d440 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/mem_table/in_mem_select.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/mem_table/in_mem_select.go @@ -3,7 +3,6 @@ package mem_table import ( "fmt" "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types" - "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities" "strings" ) @@ -27,7 +26,7 @@ func (e *InMemEngine) Execute(query *types.ExecutableSelectQuery) ([]types.GoRow // apply limit if query.Limit != nil { - limit, err := utilities.GetValueInt32(query.Limit, query.Values) + limit, err := query.Values.GetValueInt32(query.Limit) if err != nil { return nil, err } @@ -36,16 +35,19 @@ func (e *InMemEngine) Execute(query *types.ExecutableSelectQuery) ([]types.GoRow } } + // todo move transformation logic to CqlFunc type // handle aggregates if present for _, col := range query.SelectClause.Columns { - if col.Func == types.FuncCodeCount { - key := col.Sql - if col.Alias != "" { - key = col.Alias + if f, ok := col.Value.(*types.FunctionValue); ok { + if f.Func.GetCode() == types.FuncCodeCount { + key := col.Cql + if col.Alias != "" { + key = col.Alias + } + return []types.GoRow{ + {key: int64(len(filtered))}, + }, nil } - return []types.GoRow{ - {key: int64(len(filtered))}, - }, nil } } @@ -56,7 +58,11 @@ func (e *InMemEngine) Execute(query *types.ExecutableSelectQuery) ([]types.GoRow projectedRows := make([]types.GoRow, len(filtered)) for i, row := range filtered { - projectedRows[i] = projectRow(row, query.SelectClause.Columns) + selectedRow, err := projectRow(row, query.SelectClause.Columns) + if err != nil { + return nil, err + } + projectedRows[i] = selectedRow } return projectedRows, nil @@ -131,18 +137,22 @@ func compareAny(v1, v2 any) (int, error) { return 0, fmt.Errorf("unhandled comparison types: %T and %T", v1, v2) } -func projectRow(source types.GoRow, columns []types.SelectedColumn) types.GoRow { +func projectRow(source types.GoRow, columns []types.SelectedColumn) (types.GoRow, error) { newRow := make(types.GoRow) for _, col := range columns { - val, exists := source[string(col.ColumnName)] + selectedCol, ok := col.Value.(*types.ColumnValue) + if !ok { + return nil, fmt.Errorf("unhandled select column operation: %T", col.Value) + } + val, exists := source[string(selectedCol.Column.Name)] if exists { // Use Alias if present, otherwise use original Family Name targetKey := col.Alias if targetKey == "" { - targetKey = string(col.ColumnName) + targetKey = string(selectedCol.Column.Name) } newRow[targetKey] = val } } - return newRow + return newRow, nil } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/responsehandler/responsehandler_utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/responsehandler/responsehandler_utils.go index 3fe9a17b..dbd604a2 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/responsehandler/responsehandler_utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/responsehandler/responsehandler_utils.go @@ -76,7 +76,7 @@ func BuildPreparedResultResponse(id [16]byte, query types.IPreparedQuery) (*mess func buildPreparedResult(query types.IPreparedQuery) ([]*message.ColumnMetadata, []uint16) { var variableMetadata []*message.ColumnMetadata var pkIndices []uint16 - for i, md := range query.Parameters().Ordered() { + for i, md := range query.Parameters().OrderedUserParams() { var col = message.ColumnMetadata{ Keyspace: string(query.Keyspace()), Table: string(query.Table()), diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/testing/compliance/compliance_uuid_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/testing/compliance/compliance_uuid_test.go index a659f4b1..ad67748b 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/testing/compliance/compliance_uuid_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/testing/compliance/compliance_uuid_test.go @@ -144,12 +144,35 @@ func TestInsertTimeUuidNull(t *testing.T) { assert.Equal(t, (*gocql.UUID)(nil), got.parentEvent) } +func TestValidateMaxAndMin(t *testing.T) { + inputTime := time.Date(2025, 12, 12, 13, 20, 42, 456000000, time.UTC) + + minUuid, err := gocql.ParseUUID("5c09c580-d75d-11f0-0000-000000000000") + require.NoError(t, err) + maxUuid, err := gocql.ParseUUID("5c09ec8f-d75d-11f0-ffff-ffffffffffff") + require.NoError(t, err) + + require.NoError(t, session.Query(`INSERT INTO timeuuid_key (pk, id, val, parentEvent) VALUES ('timeuuid-validate', ?, '3', now())`, minUuid).Exec()) + require.NoError(t, session.Query(`INSERT INTO timeuuid_key (pk, id, val, parentEvent) VALUES ('timeuuid-validate', ?, '3', now())`, maxUuid).Exec()) + + var gotMin gocql.UUID + require.NoError(t, session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-validate' AND id = minTimeuuid(?)`, inputTime).Scan(&gotMin)) + assert.Equal(t, minUuid, gotMin) + var gotMax gocql.UUID + require.NoError(t, session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-validate' AND id = maxTimeuuid(?)`, inputTime).Scan(&gotMax)) + assert.Equal(t, maxUuid, gotMax) +} + func TestMaxAndMinTimestamp(t *testing.T) { t.Parallel() t1, _ := gocql.ParseUUID("7b287b9e-d769-11f0-b949-8e0ad7a51247") t2, _ := gocql.ParseUUID("7e2fcec8-d769-11f0-b94a-8e0ad7a51247") + // 2025-12-12 14:47:38.769 +0000 + // server: 2025-12-12 14:47:38.769 +0000 OK + // max: 8133f810-d769-11f0-ffff-ffffffffffff WHAT t3, _ := gocql.ParseUUID("8133fa68-d769-11f0-b94b-8e0ad7a51247") + t4, _ := gocql.ParseUUID("843a7228-d769-11f0-b94c-8e0ad7a51247") t5, _ := gocql.ParseUUID("87575e30-d769-11f0-b94d-8e0ad7a51247") @@ -187,6 +210,39 @@ func TestMaxAndMinTimestamp(t *testing.T) { assert.Equal(t, []gocql.UUID{t1, t2, t3}, got) }) + t.Run("< minTimeuuid", func(t *testing.T) { + t.Parallel() + got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id < minTimeuuid(?)`, t3.Time()).Iter().Scanner()) + require.NoError(t, err) + assert.NotContains(t, got, t3) + assert.Equal(t, []gocql.UUID{t1, t2}, got) + }) + + t.Run("> minTimeuuid", func(t *testing.T) { + t.Parallel() + got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id > minTimeuuid(?)`, t3.Time()).Iter().Scanner()) + require.NoError(t, err) + assert.Equal(t, []gocql.UUID{t3, t4, t5}, got) + }) + + t.Run("> maxTimeuuid", func(t *testing.T) { + t.Parallel() + got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id > maxTimeuuid(?)`, t3.Time()).Iter().Scanner()) + require.NoError(t, err) + assert.NotContains(t, got, t3) + assert.Equal(t, []gocql.UUID{t4, t5}, got) + }) + + t.Run("< maxTimeuuid", func(t *testing.T) { + t.Parallel() + got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id < maxTimeuuid(?)`, t3.Time()).Iter().Scanner()) + require.NoError(t, err) + assert.Contains(t, got, t1) + assert.Contains(t, got, t2) + assert.Contains(t, got, t3) + assert.Equal(t, []gocql.UUID{t1, t2, t3}, got) + }) + t.Run("between t1 t3", func(t *testing.T) { t.Parallel() got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id BETWEEN ? AND ?`, t1, t3).Iter().Scanner()) @@ -194,6 +250,13 @@ func TestMaxAndMinTimestamp(t *testing.T) { // between is inclusive assert.Equal(t, []gocql.UUID{t1, t2, t3}, got) }) + + t.Run("between min max", func(t *testing.T) { + t.Parallel() + got, err := scanAllTimeuuids(session.Query(`SELECT id FROM timeuuid_key WHERE pk='timeuuid-minmax' AND id BETWEEN minTimeuuid(?) AND maxTimeuuid(?)`, t3.Time(), t3.Time()).Iter().Scanner()) + require.NoError(t, err) + assert.Equal(t, []gocql.UUID{t3}, got) + }) } func scanAllTimeuuids(scanner gocql.Scanner) ([]gocql.UUID, error) { @@ -223,15 +286,15 @@ func TestInsertTimeUuidPrepared(t *testing.T) { got := TimeUuidEvent{} require.NoError(t, session.Query(`SELECT pk, id, val, parentEvent FROM bigtabledevinstance.timeuuid_key WHERE pk = 'timeuuid-prepared'`).Scan(&got.pk, &got.id, &got.val, &got.parentEvent)) assert.Equal(t, "timeuuid-prepared", got.pk) - assert.Equal(t, t1, *got.id) + assert.Equal(t, &t1, got.id) assert.Equal(t, "3", got.val) - assert.Equal(t, t2, *got.parentEvent) + assert.Equal(t, &t2, got.parentEvent) require.NoError(t, session.Query(`SELECT pk, id, val, parentEvent FROM bigtabledevinstance.timeuuid_key WHERE id=? AND parentEvent=?`, t1, t2).Scan(&got.pk, &got.id, &got.val, &got.parentEvent)) assert.Equal(t, "timeuuid-prepared", got.pk) - assert.Equal(t, t1, *got.id) + assert.Equal(t, &t1, got.id) assert.Equal(t, "3", got.val) - assert.Equal(t, t2, *got.parentEvent) + assert.Equal(t, &t2, got.parentEvent) } type TimeUuidEvent struct { diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.g4 b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.g4 index 95efcd37..a3415f7f 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.g4 +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.g4 @@ -789,6 +789,8 @@ relationElement | relationBetween | relationFunctionCompareConstant | relationFunctionCompareFunction + | relationColumnCompareFunction + | relationFunctionCompareColumn | relationContainsKey | relationContains | relationIn @@ -810,8 +812,16 @@ relationFunctionCompareFunction : functionCall compareOperator functionCall ; +relationColumnCompareFunction + : column compareOperator functionCall + ; + +relationFunctionCompareColumn + : functionCall compareOperator column + ; + relationBetween - : column kwBetween constant kwAnd constant + : column kwBetween valueAny kwAnd valueAny ; relationCompare @@ -843,14 +853,23 @@ relationContainsKey ; functionCall - : OBJECT_NAME '(' STAR ')' - | OBJECT_NAME '(' functionArgs? ')' - | K_UUID '(' ')' - | K_WRITETIME '(' functionArgs? ')' + : functionName '(' functionArgs? ')' ; +functionName + : OBJECT_NAME + | K_UUID + | K_WRITETIME + ; + functionArgs - : (constant | OBJECT_NAME | functionCall) (syntaxComma (constant | OBJECT_NAME | functionCall))* + : (functionArg) (syntaxComma functionArg)* + ; + +functionArg + : valueAny + | column + | STAR ; valueAny diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.interp b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.interp index 96365b8a..cab9e62f 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.interp +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/CqlParser.interp @@ -533,6 +533,8 @@ relationElement compareOperator relationFunctionCompareConstant relationFunctionCompareFunction +relationColumnCompareFunction +relationFunctionCompareColumn relationBetween relationCompare relationLike @@ -542,7 +544,9 @@ relationIn relationContains relationContainsKey functionCall +functionName functionArgs +functionArg valueAny constant decimalLiteral @@ -683,4 +687,4 @@ groupSpecElement atn: -[4, 1, 181, 2458, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 1, 0, 4, 0, 628, 8, 0, 11, 0, 12, 0, 629, 1, 0, 3, 0, 633, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 639, 8, 1, 1, 1, 1, 1, 1, 1, 5, 1, 644, 8, 1, 10, 1, 12, 1, 647, 9, 1, 1, 1, 1, 1, 3, 1, 651, 8, 1, 1, 1, 3, 1, 654, 8, 1, 1, 1, 3, 1, 657, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 701, 8, 4, 1, 5, 1, 5, 3, 5, 705, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 713, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 3, 9, 720, 8, 9, 1, 9, 1, 9, 1, 10, 3, 10, 725, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 741, 8, 12, 1, 12, 3, 12, 744, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 751, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 756, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 767, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 777, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 792, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 803, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 812, 8, 16, 1, 17, 1, 17, 1, 17, 3, 17, 817, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 825, 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 830, 8, 18, 1, 18, 1, 18, 3, 18, 834, 8, 18, 1, 19, 1, 19, 1, 19, 3, 19, 839, 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 844, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 857, 8, 20, 10, 20, 12, 20, 860, 9, 20, 1, 21, 1, 21, 1, 21, 3, 21, 865, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 870, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 880, 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 885, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 902, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 909, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 915, 8, 24, 10, 24, 12, 24, 918, 9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 931, 8, 26, 1, 27, 1, 27, 1, 27, 3, 27, 936, 8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 948, 8, 27, 1, 28, 1, 28, 3, 28, 952, 8, 28, 1, 28, 1, 28, 3, 28, 956, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 961, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 966, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 983, 8, 30, 10, 30, 12, 30, 986, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 992, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 1000, 8, 32, 1, 32, 1, 32, 3, 32, 1004, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1009, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1028, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 1035, 8, 34, 10, 34, 12, 34, 1038, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1052, 8, 36, 10, 36, 12, 36, 1055, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1064, 8, 37, 10, 37, 12, 37, 1067, 9, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1080, 8, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, 1087, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1094, 8, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 1102, 8, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1111, 8, 45, 10, 45, 12, 45, 1114, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 5, 47, 1127, 8, 47, 10, 47, 12, 47, 1130, 9, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1148, 8, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1169, 8, 55, 10, 55, 12, 55, 1172, 9, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1181, 8, 57, 10, 57, 12, 57, 1184, 9, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1197, 8, 60, 10, 60, 12, 60, 1200, 9, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1209, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1216, 8, 63, 10, 63, 12, 63, 1219, 9, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1237, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1245, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1251, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1256, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1263, 8, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1268, 8, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1276, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1281, 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1288, 8, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1293, 8, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 3, 70, 1300, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1305, 8, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 3, 71, 1312, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1321, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 1328, 8, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 3, 74, 1335, 8, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 3, 75, 1342, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1347, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1354, 8, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1361, 8, 76, 1, 77, 1, 77, 3, 77, 1365, 8, 77, 1, 77, 3, 77, 1368, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1376, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1384, 8, 79, 10, 79, 12, 79, 1387, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1397, 8, 80, 1, 81, 1, 81, 1, 82, 1, 82, 3, 82, 1403, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 1410, 8, 83, 10, 83, 12, 83, 1413, 9, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 1425, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 5, 87, 1431, 8, 87, 10, 87, 12, 87, 1434, 9, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1439, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1444, 8, 88, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 1458, 8, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 1476, 8, 95, 10, 95, 12, 95, 1479, 9, 95, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 1485, 8, 96, 10, 96, 12, 96, 1488, 9, 96, 1, 97, 1, 97, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 1499, 8, 100, 1, 100, 1, 100, 3, 100, 1503, 8, 100, 1, 101, 1, 101, 3, 101, 1507, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1521, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1527, 8, 103, 10, 103, 12, 103, 1530, 9, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1538, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 3, 107, 1549, 8, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 1556, 8, 108, 1, 108, 3, 108, 1559, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 3, 109, 1569, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1575, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 3, 114, 1593, 8, 114, 1, 114, 1, 114, 3, 114, 1597, 8, 114, 1, 114, 1, 114, 3, 114, 1601, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1606, 8, 114, 1, 114, 3, 114, 1609, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1615, 8, 115, 10, 115, 12, 115, 1618, 9, 115, 1, 116, 1, 116, 3, 116, 1622, 8, 116, 1, 116, 1, 116, 3, 116, 1626, 8, 116, 3, 116, 1628, 8, 116, 1, 117, 3, 117, 1631, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1636, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1643, 8, 117, 1, 117, 3, 117, 1646, 8, 117, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 1655, 8, 119, 10, 119, 12, 119, 1658, 9, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 1668, 8, 121, 10, 121, 12, 121, 1671, 9, 121, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1677, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 1709, 8, 128, 10, 128, 12, 128, 1712, 9, 128, 3, 128, 1714, 8, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1728, 8, 129, 10, 129, 12, 129, 1731, 9, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 1740, 8, 130, 10, 130, 12, 130, 1743, 9, 130, 3, 130, 1745, 8, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1756, 8, 132, 10, 132, 12, 132, 1759, 9, 132, 1, 132, 1, 132, 1, 133, 3, 133, 1764, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1770, 8, 133, 1, 133, 1, 133, 3, 133, 1774, 8, 133, 1, 133, 3, 133, 1777, 8, 133, 1, 133, 3, 133, 1780, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1798, 8, 134, 1, 135, 1, 135, 1, 135, 3, 135, 1803, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1826, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 1836, 8, 142, 10, 142, 12, 142, 1839, 9, 142, 1, 143, 1, 143, 1, 143, 1, 143, 5, 143, 1845, 8, 143, 10, 143, 12, 143, 1848, 9, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1856, 8, 144, 1, 145, 1, 145, 3, 145, 1860, 8, 145, 1, 145, 3, 145, 1863, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1868, 8, 145, 1, 145, 3, 145, 1871, 8, 145, 1, 145, 3, 145, 1874, 8, 145, 1, 145, 3, 145, 1877, 8, 145, 1, 145, 3, 145, 1880, 8, 145, 1, 145, 3, 145, 1883, 8, 145, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 3, 147, 1891, 8, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1898, 8, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 1911, 8, 151, 10, 151, 12, 151, 1914, 9, 151, 1, 152, 1, 152, 1, 152, 3, 152, 1919, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 3, 155, 1928, 8, 155, 1, 155, 1, 155, 1, 155, 5, 155, 1933, 8, 155, 10, 155, 12, 155, 1936, 9, 155, 1, 156, 1, 156, 3, 156, 1940, 8, 156, 1, 156, 1, 156, 3, 156, 1944, 8, 156, 1, 156, 1, 156, 3, 156, 1948, 8, 156, 3, 156, 1950, 8, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 1968, 8, 161, 10, 161, 12, 161, 1971, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2000, 8, 162, 10, 162, 12, 162, 2003, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2012, 8, 162, 10, 162, 12, 162, 2015, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2024, 8, 162, 10, 162, 12, 162, 2027, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2035, 8, 162, 10, 162, 12, 162, 2038, 9, 162, 3, 162, 2040, 8, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2073, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2096, 8, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2105, 8, 174, 1, 174, 3, 174, 2108, 8, 174, 1, 175, 1, 175, 1, 175, 3, 175, 2113, 8, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2119, 8, 175, 5, 175, 2121, 8, 175, 10, 175, 12, 175, 2124, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2133, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 2144, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 1, 180, 1, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 2160, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2169, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 3, 185, 2177, 8, 185, 1, 186, 1, 186, 3, 186, 2181, 8, 186, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 5, 188, 2190, 8, 188, 10, 188, 12, 188, 2193, 9, 188, 1, 188, 1, 188, 1, 189, 1, 189, 3, 189, 2199, 8, 189, 1, 190, 1, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 193, 1, 193, 1, 194, 1, 194, 1, 195, 1, 195, 1, 196, 1, 196, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 211, 1, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 214, 1, 214, 1, 215, 1, 215, 1, 216, 1, 216, 1, 217, 1, 217, 1, 218, 1, 218, 1, 219, 1, 219, 1, 220, 1, 220, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, 1, 224, 1, 224, 1, 225, 1, 225, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, 1, 229, 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, 1, 238, 1, 239, 1, 239, 1, 240, 1, 240, 1, 241, 1, 241, 1, 242, 1, 242, 1, 243, 1, 243, 1, 244, 1, 244, 1, 245, 1, 245, 1, 246, 1, 246, 1, 247, 1, 247, 1, 248, 1, 248, 1, 249, 1, 249, 1, 250, 1, 250, 1, 251, 1, 251, 1, 252, 1, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 262, 1, 262, 1, 263, 1, 263, 1, 264, 1, 264, 1, 265, 1, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 268, 1, 268, 1, 269, 1, 269, 1, 270, 1, 270, 1, 271, 1, 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, 274, 1, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 277, 1, 277, 1, 278, 1, 278, 1, 279, 1, 279, 1, 280, 1, 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 283, 1, 283, 1, 284, 1, 284, 1, 285, 1, 285, 1, 286, 1, 286, 1, 287, 1, 287, 1, 288, 1, 288, 1, 289, 1, 289, 1, 290, 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 293, 1, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 296, 1, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 300, 1, 300, 1, 301, 1, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 306, 1, 306, 1, 307, 1, 307, 1, 308, 1, 308, 1, 309, 1, 309, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, 2451, 8, 311, 10, 311, 12, 311, 2454, 9, 311, 1, 312, 1, 312, 1, 312, 0, 0, 313, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 0, 8, 1, 0, 168, 169, 2, 0, 14, 14, 16, 16, 1, 0, 19, 23, 1, 0, 176, 177, 1, 0, 170, 171, 2, 0, 57, 57, 131, 131, 6, 0, 84, 84, 118, 118, 127, 127, 141, 141, 147, 167, 174, 174, 2, 0, 71, 71, 174, 174, 2435, 0, 627, 1, 0, 0, 0, 2, 645, 1, 0, 0, 0, 4, 658, 1, 0, 0, 0, 6, 660, 1, 0, 0, 0, 8, 700, 1, 0, 0, 0, 10, 704, 1, 0, 0, 0, 12, 712, 1, 0, 0, 0, 14, 714, 1, 0, 0, 0, 16, 716, 1, 0, 0, 0, 18, 719, 1, 0, 0, 0, 20, 724, 1, 0, 0, 0, 22, 728, 1, 0, 0, 0, 24, 735, 1, 0, 0, 0, 26, 745, 1, 0, 0, 0, 28, 757, 1, 0, 0, 0, 30, 776, 1, 0, 0, 0, 32, 811, 1, 0, 0, 0, 34, 813, 1, 0, 0, 0, 36, 826, 1, 0, 0, 0, 38, 835, 1, 0, 0, 0, 40, 850, 1, 0, 0, 0, 42, 861, 1, 0, 0, 0, 44, 875, 1, 0, 0, 0, 46, 903, 1, 0, 0, 0, 48, 910, 1, 0, 0, 0, 50, 919, 1, 0, 0, 0, 52, 930, 1, 0, 0, 0, 54, 932, 1, 0, 0, 0, 56, 949, 1, 0, 0, 0, 58, 976, 1, 0, 0, 0, 60, 978, 1, 0, 0, 0, 62, 991, 1, 0, 0, 0, 64, 997, 1, 0, 0, 0, 66, 1027, 1, 0, 0, 0, 68, 1029, 1, 0, 0, 0, 70, 1041, 1, 0, 0, 0, 72, 1045, 1, 0, 0, 0, 74, 1058, 1, 0, 0, 0, 76, 1070, 1, 0, 0, 0, 78, 1073, 1, 0, 0, 0, 80, 1081, 1, 0, 0, 0, 82, 1086, 1, 0, 0, 0, 84, 1088, 1, 0, 0, 0, 86, 1101, 1, 0, 0, 0, 88, 1103, 1, 0, 0, 0, 90, 1106, 1, 0, 0, 0, 92, 1115, 1, 0, 0, 0, 94, 1119, 1, 0, 0, 0, 96, 1131, 1, 0, 0, 0, 98, 1136, 1, 0, 0, 0, 100, 1147, 1, 0, 0, 0, 102, 1149, 1, 0, 0, 0, 104, 1152, 1, 0, 0, 0, 106, 1157, 1, 0, 0, 0, 108, 1161, 1, 0, 0, 0, 110, 1164, 1, 0, 0, 0, 112, 1173, 1, 0, 0, 0, 114, 1176, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1189, 1, 0, 0, 0, 120, 1192, 1, 0, 0, 0, 122, 1201, 1, 0, 0, 0, 124, 1204, 1, 0, 0, 0, 126, 1210, 1, 0, 0, 0, 128, 1236, 1, 0, 0, 0, 130, 1238, 1, 0, 0, 0, 132, 1252, 1, 0, 0, 0, 134, 1259, 1, 0, 0, 0, 136, 1271, 1, 0, 0, 0, 138, 1284, 1, 0, 0, 0, 140, 1296, 1, 0, 0, 0, 142, 1308, 1, 0, 0, 0, 144, 1317, 1, 0, 0, 0, 146, 1324, 1, 0, 0, 0, 148, 1331, 1, 0, 0, 0, 150, 1338, 1, 0, 0, 0, 152, 1350, 1, 0, 0, 0, 154, 1362, 1, 0, 0, 0, 156, 1369, 1, 0, 0, 0, 158, 1379, 1, 0, 0, 0, 160, 1396, 1, 0, 0, 0, 162, 1398, 1, 0, 0, 0, 164, 1402, 1, 0, 0, 0, 166, 1404, 1, 0, 0, 0, 168, 1416, 1, 0, 0, 0, 170, 1420, 1, 0, 0, 0, 172, 1424, 1, 0, 0, 0, 174, 1426, 1, 0, 0, 0, 176, 1440, 1, 0, 0, 0, 178, 1445, 1, 0, 0, 0, 180, 1448, 1, 0, 0, 0, 182, 1457, 1, 0, 0, 0, 184, 1459, 1, 0, 0, 0, 186, 1461, 1, 0, 0, 0, 188, 1465, 1, 0, 0, 0, 190, 1471, 1, 0, 0, 0, 192, 1480, 1, 0, 0, 0, 194, 1489, 1, 0, 0, 0, 196, 1491, 1, 0, 0, 0, 198, 1493, 1, 0, 0, 0, 200, 1496, 1, 0, 0, 0, 202, 1506, 1, 0, 0, 0, 204, 1508, 1, 0, 0, 0, 206, 1522, 1, 0, 0, 0, 208, 1537, 1, 0, 0, 0, 210, 1539, 1, 0, 0, 0, 212, 1543, 1, 0, 0, 0, 214, 1546, 1, 0, 0, 0, 216, 1552, 1, 0, 0, 0, 218, 1568, 1, 0, 0, 0, 220, 1574, 1, 0, 0, 0, 222, 1576, 1, 0, 0, 0, 224, 1581, 1, 0, 0, 0, 226, 1586, 1, 0, 0, 0, 228, 1592, 1, 0, 0, 0, 230, 1610, 1, 0, 0, 0, 232, 1627, 1, 0, 0, 0, 234, 1630, 1, 0, 0, 0, 236, 1647, 1, 0, 0, 0, 238, 1650, 1, 0, 0, 0, 240, 1659, 1, 0, 0, 0, 242, 1663, 1, 0, 0, 0, 244, 1676, 1, 0, 0, 0, 246, 1678, 1, 0, 0, 0, 248, 1682, 1, 0, 0, 0, 250, 1688, 1, 0, 0, 0, 252, 1694, 1, 0, 0, 0, 254, 1698, 1, 0, 0, 0, 256, 1703, 1, 0, 0, 0, 258, 1717, 1, 0, 0, 0, 260, 1734, 1, 0, 0, 0, 262, 1748, 1, 0, 0, 0, 264, 1750, 1, 0, 0, 0, 266, 1763, 1, 0, 0, 0, 268, 1797, 1, 0, 0, 0, 270, 1799, 1, 0, 0, 0, 272, 1804, 1, 0, 0, 0, 274, 1807, 1, 0, 0, 0, 276, 1810, 1, 0, 0, 0, 278, 1814, 1, 0, 0, 0, 280, 1825, 1, 0, 0, 0, 282, 1827, 1, 0, 0, 0, 284, 1831, 1, 0, 0, 0, 286, 1840, 1, 0, 0, 0, 288, 1855, 1, 0, 0, 0, 290, 1857, 1, 0, 0, 0, 292, 1884, 1, 0, 0, 0, 294, 1887, 1, 0, 0, 0, 296, 1892, 1, 0, 0, 0, 298, 1897, 1, 0, 0, 0, 300, 1901, 1, 0, 0, 0, 302, 1904, 1, 0, 0, 0, 304, 1915, 1, 0, 0, 0, 306, 1920, 1, 0, 0, 0, 308, 1923, 1, 0, 0, 0, 310, 1927, 1, 0, 0, 0, 312, 1949, 1, 0, 0, 0, 314, 1951, 1, 0, 0, 0, 316, 1953, 1, 0, 0, 0, 318, 1955, 1, 0, 0, 0, 320, 1960, 1, 0, 0, 0, 322, 1963, 1, 0, 0, 0, 324, 2039, 1, 0, 0, 0, 326, 2041, 1, 0, 0, 0, 328, 2043, 1, 0, 0, 0, 330, 2047, 1, 0, 0, 0, 332, 2051, 1, 0, 0, 0, 334, 2057, 1, 0, 0, 0, 336, 2061, 1, 0, 0, 0, 338, 2065, 1, 0, 0, 0, 340, 2072, 1, 0, 0, 0, 342, 2074, 1, 0, 0, 0, 344, 2078, 1, 0, 0, 0, 346, 2082, 1, 0, 0, 0, 348, 2107, 1, 0, 0, 0, 350, 2112, 1, 0, 0, 0, 352, 2132, 1, 0, 0, 0, 354, 2143, 1, 0, 0, 0, 356, 2145, 1, 0, 0, 0, 358, 2147, 1, 0, 0, 0, 360, 2149, 1, 0, 0, 0, 362, 2151, 1, 0, 0, 0, 364, 2153, 1, 0, 0, 0, 366, 2159, 1, 0, 0, 0, 368, 2168, 1, 0, 0, 0, 370, 2176, 1, 0, 0, 0, 372, 2178, 1, 0, 0, 0, 374, 2182, 1, 0, 0, 0, 376, 2184, 1, 0, 0, 0, 378, 2198, 1, 0, 0, 0, 380, 2200, 1, 0, 0, 0, 382, 2202, 1, 0, 0, 0, 384, 2204, 1, 0, 0, 0, 386, 2206, 1, 0, 0, 0, 388, 2208, 1, 0, 0, 0, 390, 2210, 1, 0, 0, 0, 392, 2212, 1, 0, 0, 0, 394, 2214, 1, 0, 0, 0, 396, 2216, 1, 0, 0, 0, 398, 2218, 1, 0, 0, 0, 400, 2220, 1, 0, 0, 0, 402, 2222, 1, 0, 0, 0, 404, 2225, 1, 0, 0, 0, 406, 2227, 1, 0, 0, 0, 408, 2229, 1, 0, 0, 0, 410, 2231, 1, 0, 0, 0, 412, 2233, 1, 0, 0, 0, 414, 2236, 1, 0, 0, 0, 416, 2238, 1, 0, 0, 0, 418, 2240, 1, 0, 0, 0, 420, 2242, 1, 0, 0, 0, 422, 2244, 1, 0, 0, 0, 424, 2246, 1, 0, 0, 0, 426, 2248, 1, 0, 0, 0, 428, 2250, 1, 0, 0, 0, 430, 2252, 1, 0, 0, 0, 432, 2254, 1, 0, 0, 0, 434, 2256, 1, 0, 0, 0, 436, 2258, 1, 0, 0, 0, 438, 2260, 1, 0, 0, 0, 440, 2262, 1, 0, 0, 0, 442, 2264, 1, 0, 0, 0, 444, 2266, 1, 0, 0, 0, 446, 2268, 1, 0, 0, 0, 448, 2270, 1, 0, 0, 0, 450, 2272, 1, 0, 0, 0, 452, 2274, 1, 0, 0, 0, 454, 2276, 1, 0, 0, 0, 456, 2278, 1, 0, 0, 0, 458, 2280, 1, 0, 0, 0, 460, 2282, 1, 0, 0, 0, 462, 2284, 1, 0, 0, 0, 464, 2286, 1, 0, 0, 0, 466, 2288, 1, 0, 0, 0, 468, 2290, 1, 0, 0, 0, 470, 2292, 1, 0, 0, 0, 472, 2294, 1, 0, 0, 0, 474, 2296, 1, 0, 0, 0, 476, 2298, 1, 0, 0, 0, 478, 2300, 1, 0, 0, 0, 480, 2302, 1, 0, 0, 0, 482, 2304, 1, 0, 0, 0, 484, 2306, 1, 0, 0, 0, 486, 2308, 1, 0, 0, 0, 488, 2310, 1, 0, 0, 0, 490, 2312, 1, 0, 0, 0, 492, 2314, 1, 0, 0, 0, 494, 2316, 1, 0, 0, 0, 496, 2318, 1, 0, 0, 0, 498, 2320, 1, 0, 0, 0, 500, 2322, 1, 0, 0, 0, 502, 2324, 1, 0, 0, 0, 504, 2326, 1, 0, 0, 0, 506, 2328, 1, 0, 0, 0, 508, 2330, 1, 0, 0, 0, 510, 2332, 1, 0, 0, 0, 512, 2334, 1, 0, 0, 0, 514, 2336, 1, 0, 0, 0, 516, 2338, 1, 0, 0, 0, 518, 2340, 1, 0, 0, 0, 520, 2342, 1, 0, 0, 0, 522, 2344, 1, 0, 0, 0, 524, 2346, 1, 0, 0, 0, 526, 2348, 1, 0, 0, 0, 528, 2350, 1, 0, 0, 0, 530, 2352, 1, 0, 0, 0, 532, 2354, 1, 0, 0, 0, 534, 2356, 1, 0, 0, 0, 536, 2358, 1, 0, 0, 0, 538, 2360, 1, 0, 0, 0, 540, 2362, 1, 0, 0, 0, 542, 2364, 1, 0, 0, 0, 544, 2366, 1, 0, 0, 0, 546, 2368, 1, 0, 0, 0, 548, 2370, 1, 0, 0, 0, 550, 2372, 1, 0, 0, 0, 552, 2374, 1, 0, 0, 0, 554, 2376, 1, 0, 0, 0, 556, 2378, 1, 0, 0, 0, 558, 2380, 1, 0, 0, 0, 560, 2382, 1, 0, 0, 0, 562, 2384, 1, 0, 0, 0, 564, 2386, 1, 0, 0, 0, 566, 2388, 1, 0, 0, 0, 568, 2390, 1, 0, 0, 0, 570, 2392, 1, 0, 0, 0, 572, 2394, 1, 0, 0, 0, 574, 2396, 1, 0, 0, 0, 576, 2398, 1, 0, 0, 0, 578, 2400, 1, 0, 0, 0, 580, 2402, 1, 0, 0, 0, 582, 2404, 1, 0, 0, 0, 584, 2406, 1, 0, 0, 0, 586, 2408, 1, 0, 0, 0, 588, 2410, 1, 0, 0, 0, 590, 2412, 1, 0, 0, 0, 592, 2414, 1, 0, 0, 0, 594, 2416, 1, 0, 0, 0, 596, 2418, 1, 0, 0, 0, 598, 2420, 1, 0, 0, 0, 600, 2422, 1, 0, 0, 0, 602, 2424, 1, 0, 0, 0, 604, 2426, 1, 0, 0, 0, 606, 2428, 1, 0, 0, 0, 608, 2430, 1, 0, 0, 0, 610, 2432, 1, 0, 0, 0, 612, 2434, 1, 0, 0, 0, 614, 2436, 1, 0, 0, 0, 616, 2438, 1, 0, 0, 0, 618, 2440, 1, 0, 0, 0, 620, 2442, 1, 0, 0, 0, 622, 2444, 1, 0, 0, 0, 624, 2455, 1, 0, 0, 0, 626, 628, 3, 2, 1, 0, 627, 626, 1, 0, 0, 0, 628, 629, 1, 0, 0, 0, 629, 627, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 632, 1, 0, 0, 0, 631, 633, 5, 15, 0, 0, 632, 631, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 635, 5, 0, 0, 1, 635, 1, 1, 0, 0, 0, 636, 638, 3, 8, 4, 0, 637, 639, 5, 15, 0, 0, 638, 637, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 641, 3, 4, 2, 0, 641, 644, 1, 0, 0, 0, 642, 644, 3, 6, 3, 0, 643, 636, 1, 0, 0, 0, 643, 642, 1, 0, 0, 0, 644, 647, 1, 0, 0, 0, 645, 643, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 656, 1, 0, 0, 0, 647, 645, 1, 0, 0, 0, 648, 653, 3, 8, 4, 0, 649, 651, 5, 15, 0, 0, 650, 649, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 652, 1, 0, 0, 0, 652, 654, 3, 4, 2, 0, 653, 650, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 6, 3, 0, 656, 648, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 3, 1, 0, 0, 0, 658, 659, 5, 8, 0, 0, 659, 5, 1, 0, 0, 0, 660, 661, 3, 4, 2, 0, 661, 7, 1, 0, 0, 0, 662, 701, 3, 204, 102, 0, 663, 701, 3, 130, 65, 0, 664, 701, 3, 124, 62, 0, 665, 701, 3, 98, 49, 0, 666, 701, 3, 84, 42, 0, 667, 701, 3, 78, 39, 0, 668, 701, 3, 198, 99, 0, 669, 701, 3, 64, 32, 0, 670, 701, 3, 56, 28, 0, 671, 701, 3, 216, 108, 0, 672, 701, 3, 54, 27, 0, 673, 701, 3, 44, 22, 0, 674, 701, 3, 36, 18, 0, 675, 701, 3, 152, 76, 0, 676, 701, 3, 42, 21, 0, 677, 701, 3, 38, 19, 0, 678, 701, 3, 34, 17, 0, 679, 701, 3, 228, 114, 0, 680, 701, 3, 138, 69, 0, 681, 701, 3, 140, 70, 0, 682, 701, 3, 150, 75, 0, 683, 701, 3, 148, 74, 0, 684, 701, 3, 136, 68, 0, 685, 701, 3, 144, 72, 0, 686, 701, 3, 146, 73, 0, 687, 701, 3, 142, 71, 0, 688, 701, 3, 134, 67, 0, 689, 701, 3, 132, 66, 0, 690, 701, 3, 28, 14, 0, 691, 701, 3, 266, 133, 0, 692, 701, 3, 26, 13, 0, 693, 701, 3, 24, 12, 0, 694, 701, 3, 22, 11, 0, 695, 701, 3, 290, 145, 0, 696, 701, 3, 214, 107, 0, 697, 701, 3, 234, 117, 0, 698, 701, 3, 212, 106, 0, 699, 701, 3, 10, 5, 0, 700, 662, 1, 0, 0, 0, 700, 663, 1, 0, 0, 0, 700, 664, 1, 0, 0, 0, 700, 665, 1, 0, 0, 0, 700, 666, 1, 0, 0, 0, 700, 667, 1, 0, 0, 0, 700, 668, 1, 0, 0, 0, 700, 669, 1, 0, 0, 0, 700, 670, 1, 0, 0, 0, 700, 671, 1, 0, 0, 0, 700, 672, 1, 0, 0, 0, 700, 673, 1, 0, 0, 0, 700, 674, 1, 0, 0, 0, 700, 675, 1, 0, 0, 0, 700, 676, 1, 0, 0, 0, 700, 677, 1, 0, 0, 0, 700, 678, 1, 0, 0, 0, 700, 679, 1, 0, 0, 0, 700, 680, 1, 0, 0, 0, 700, 681, 1, 0, 0, 0, 700, 682, 1, 0, 0, 0, 700, 683, 1, 0, 0, 0, 700, 684, 1, 0, 0, 0, 700, 685, 1, 0, 0, 0, 700, 686, 1, 0, 0, 0, 700, 687, 1, 0, 0, 0, 700, 688, 1, 0, 0, 0, 700, 689, 1, 0, 0, 0, 700, 690, 1, 0, 0, 0, 700, 691, 1, 0, 0, 0, 700, 692, 1, 0, 0, 0, 700, 693, 1, 0, 0, 0, 700, 694, 1, 0, 0, 0, 700, 695, 1, 0, 0, 0, 700, 696, 1, 0, 0, 0, 700, 697, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 700, 699, 1, 0, 0, 0, 701, 9, 1, 0, 0, 0, 702, 705, 3, 448, 224, 0, 703, 705, 3, 450, 225, 0, 704, 702, 1, 0, 0, 0, 704, 703, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 707, 3, 12, 6, 0, 707, 11, 1, 0, 0, 0, 708, 713, 3, 14, 7, 0, 709, 713, 3, 16, 8, 0, 710, 713, 3, 18, 9, 0, 711, 713, 3, 20, 10, 0, 712, 708, 1, 0, 0, 0, 712, 709, 1, 0, 0, 0, 712, 710, 1, 0, 0, 0, 712, 711, 1, 0, 0, 0, 713, 13, 1, 0, 0, 0, 714, 715, 3, 502, 251, 0, 715, 15, 1, 0, 0, 0, 716, 717, 3, 566, 283, 0, 717, 17, 1, 0, 0, 0, 718, 720, 3, 564, 282, 0, 719, 718, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 722, 3, 298, 149, 0, 722, 19, 1, 0, 0, 0, 723, 725, 3, 500, 250, 0, 724, 723, 1, 0, 0, 0, 724, 725, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 727, 3, 366, 183, 0, 727, 21, 1, 0, 0, 0, 728, 729, 3, 598, 299, 0, 729, 730, 3, 30, 15, 0, 730, 731, 3, 528, 264, 0, 731, 732, 3, 32, 16, 0, 732, 733, 3, 468, 234, 0, 733, 734, 3, 380, 190, 0, 734, 23, 1, 0, 0, 0, 735, 736, 3, 508, 254, 0, 736, 740, 3, 550, 275, 0, 737, 738, 3, 526, 263, 0, 738, 739, 3, 380, 190, 0, 739, 741, 1, 0, 0, 0, 740, 737, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 743, 1, 0, 0, 0, 742, 744, 3, 520, 260, 0, 743, 742, 1, 0, 0, 0, 743, 744, 1, 0, 0, 0, 744, 25, 1, 0, 0, 0, 745, 746, 3, 508, 254, 0, 746, 750, 3, 30, 15, 0, 747, 748, 3, 528, 264, 0, 748, 749, 3, 32, 16, 0, 749, 751, 1, 0, 0, 0, 750, 747, 1, 0, 0, 0, 750, 751, 1, 0, 0, 0, 751, 755, 1, 0, 0, 0, 752, 753, 3, 526, 263, 0, 753, 754, 3, 380, 190, 0, 754, 756, 1, 0, 0, 0, 755, 752, 1, 0, 0, 0, 755, 756, 1, 0, 0, 0, 756, 27, 1, 0, 0, 0, 757, 758, 3, 476, 238, 0, 758, 759, 3, 30, 15, 0, 759, 760, 3, 528, 264, 0, 760, 761, 3, 32, 16, 0, 761, 762, 3, 570, 285, 0, 762, 763, 3, 380, 190, 0, 763, 29, 1, 0, 0, 0, 764, 767, 3, 410, 205, 0, 765, 767, 3, 412, 206, 0, 766, 764, 1, 0, 0, 0, 766, 765, 1, 0, 0, 0, 767, 777, 1, 0, 0, 0, 768, 777, 3, 416, 208, 0, 769, 777, 3, 426, 213, 0, 770, 777, 3, 450, 225, 0, 771, 777, 3, 460, 230, 0, 772, 777, 3, 444, 222, 0, 773, 777, 3, 454, 227, 0, 774, 777, 3, 516, 258, 0, 775, 777, 3, 552, 276, 0, 776, 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 776, 772, 1, 0, 0, 0, 776, 773, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 776, 775, 1, 0, 0, 0, 777, 31, 1, 0, 0, 0, 778, 779, 3, 410, 205, 0, 779, 780, 3, 474, 237, 0, 780, 812, 1, 0, 0, 0, 781, 782, 3, 410, 205, 0, 782, 783, 3, 474, 237, 0, 783, 784, 3, 480, 240, 0, 784, 785, 3, 500, 250, 0, 785, 786, 3, 366, 183, 0, 786, 812, 1, 0, 0, 0, 787, 791, 3, 472, 236, 0, 788, 789, 3, 366, 183, 0, 789, 790, 5, 10, 0, 0, 790, 792, 1, 0, 0, 0, 791, 788, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 794, 3, 392, 196, 0, 794, 812, 1, 0, 0, 0, 795, 796, 3, 410, 205, 0, 796, 797, 3, 502, 251, 0, 797, 812, 1, 0, 0, 0, 798, 799, 3, 500, 250, 0, 799, 800, 3, 366, 183, 0, 800, 812, 1, 0, 0, 0, 801, 803, 3, 564, 282, 0, 802, 801, 1, 0, 0, 0, 802, 803, 1, 0, 0, 0, 803, 804, 1, 0, 0, 0, 804, 812, 3, 298, 149, 0, 805, 806, 3, 410, 205, 0, 806, 807, 3, 550, 275, 0, 807, 812, 1, 0, 0, 0, 808, 809, 3, 548, 274, 0, 809, 810, 3, 380, 190, 0, 810, 812, 1, 0, 0, 0, 811, 778, 1, 0, 0, 0, 811, 781, 1, 0, 0, 0, 811, 787, 1, 0, 0, 0, 811, 795, 1, 0, 0, 0, 811, 798, 1, 0, 0, 0, 811, 802, 1, 0, 0, 0, 811, 805, 1, 0, 0, 0, 811, 808, 1, 0, 0, 0, 812, 33, 1, 0, 0, 0, 813, 814, 3, 444, 222, 0, 814, 816, 3, 586, 293, 0, 815, 817, 3, 276, 138, 0, 816, 815, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817, 818, 1, 0, 0, 0, 818, 819, 3, 396, 198, 0, 819, 820, 3, 596, 298, 0, 820, 821, 3, 536, 268, 0, 821, 824, 3, 360, 180, 0, 822, 825, 3, 562, 281, 0, 823, 825, 3, 518, 259, 0, 824, 822, 1, 0, 0, 0, 824, 823, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 35, 1, 0, 0, 0, 826, 827, 3, 444, 222, 0, 827, 829, 3, 548, 274, 0, 828, 830, 3, 276, 138, 0, 829, 828, 1, 0, 0, 0, 829, 830, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 833, 3, 380, 190, 0, 832, 834, 3, 126, 63, 0, 833, 832, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 37, 1, 0, 0, 0, 835, 836, 3, 444, 222, 0, 836, 838, 3, 578, 289, 0, 837, 839, 3, 276, 138, 0, 838, 837, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 843, 1, 0, 0, 0, 840, 841, 3, 366, 183, 0, 841, 842, 5, 10, 0, 0, 842, 844, 1, 0, 0, 0, 843, 840, 1, 0, 0, 0, 843, 844, 1, 0, 0, 0, 844, 845, 1, 0, 0, 0, 845, 846, 3, 388, 194, 0, 846, 847, 3, 602, 301, 0, 847, 848, 3, 40, 20, 0, 848, 849, 3, 604, 302, 0, 849, 39, 1, 0, 0, 0, 850, 851, 3, 370, 185, 0, 851, 858, 3, 372, 186, 0, 852, 853, 3, 618, 309, 0, 853, 854, 3, 370, 185, 0, 854, 855, 3, 372, 186, 0, 855, 857, 1, 0, 0, 0, 856, 852, 1, 0, 0, 0, 857, 860, 1, 0, 0, 0, 858, 856, 1, 0, 0, 0, 858, 859, 1, 0, 0, 0, 859, 41, 1, 0, 0, 0, 860, 858, 1, 0, 0, 0, 861, 862, 3, 444, 222, 0, 862, 864, 3, 572, 286, 0, 863, 865, 3, 276, 138, 0, 864, 863, 1, 0, 0, 0, 864, 865, 1, 0, 0, 0, 865, 869, 1, 0, 0, 0, 866, 867, 3, 366, 183, 0, 867, 868, 5, 10, 0, 0, 868, 870, 1, 0, 0, 0, 869, 866, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 871, 1, 0, 0, 0, 871, 872, 3, 382, 191, 0, 872, 873, 3, 588, 294, 0, 873, 874, 3, 384, 192, 0, 874, 43, 1, 0, 0, 0, 875, 876, 3, 444, 222, 0, 876, 877, 3, 514, 257, 0, 877, 879, 3, 592, 296, 0, 878, 880, 3, 276, 138, 0, 879, 878, 1, 0, 0, 0, 879, 880, 1, 0, 0, 0, 880, 884, 1, 0, 0, 0, 881, 882, 3, 366, 183, 0, 882, 883, 5, 10, 0, 0, 883, 885, 1, 0, 0, 0, 884, 881, 1, 0, 0, 0, 884, 885, 1, 0, 0, 0, 885, 886, 1, 0, 0, 0, 886, 887, 3, 386, 193, 0, 887, 888, 3, 422, 211, 0, 888, 889, 3, 552, 276, 0, 889, 890, 3, 284, 142, 0, 890, 891, 3, 468, 234, 0, 891, 892, 3, 298, 149, 0, 892, 893, 3, 46, 23, 0, 893, 894, 3, 538, 269, 0, 894, 895, 3, 496, 248, 0, 895, 896, 3, 602, 301, 0, 896, 897, 3, 284, 142, 0, 897, 901, 3, 604, 302, 0, 898, 899, 3, 596, 298, 0, 899, 900, 3, 52, 26, 0, 900, 902, 1, 0, 0, 0, 901, 898, 1, 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 45, 1, 0, 0, 0, 903, 904, 3, 594, 297, 0, 904, 908, 3, 48, 24, 0, 905, 906, 3, 418, 209, 0, 906, 907, 3, 322, 161, 0, 907, 909, 1, 0, 0, 0, 908, 905, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 47, 1, 0, 0, 0, 910, 916, 3, 50, 25, 0, 911, 912, 3, 418, 209, 0, 912, 913, 3, 50, 25, 0, 913, 915, 1, 0, 0, 0, 914, 911, 1, 0, 0, 0, 915, 918, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 916, 917, 1, 0, 0, 0, 917, 49, 1, 0, 0, 0, 918, 916, 1, 0, 0, 0, 919, 920, 3, 370, 185, 0, 920, 921, 3, 492, 246, 0, 921, 922, 3, 522, 261, 0, 922, 923, 3, 524, 262, 0, 923, 51, 1, 0, 0, 0, 924, 931, 3, 158, 79, 0, 925, 926, 3, 158, 79, 0, 926, 927, 3, 418, 209, 0, 927, 928, 3, 156, 78, 0, 928, 931, 1, 0, 0, 0, 929, 931, 3, 156, 78, 0, 930, 924, 1, 0, 0, 0, 930, 925, 1, 0, 0, 0, 930, 929, 1, 0, 0, 0, 931, 53, 1, 0, 0, 0, 932, 933, 3, 444, 222, 0, 933, 935, 3, 500, 250, 0, 934, 936, 3, 276, 138, 0, 935, 934, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 937, 1, 0, 0, 0, 937, 938, 3, 366, 183, 0, 938, 939, 3, 596, 298, 0, 939, 940, 3, 544, 272, 0, 940, 941, 5, 19, 0, 0, 941, 942, 3, 606, 303, 0, 942, 943, 3, 206, 103, 0, 943, 947, 3, 608, 304, 0, 944, 945, 3, 418, 209, 0, 945, 946, 3, 210, 105, 0, 946, 948, 1, 0, 0, 0, 947, 944, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 55, 1, 0, 0, 0, 949, 951, 3, 444, 222, 0, 950, 952, 3, 76, 38, 0, 951, 950, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 955, 3, 472, 236, 0, 954, 956, 3, 276, 138, 0, 955, 954, 1, 0, 0, 0, 955, 956, 1, 0, 0, 0, 956, 960, 1, 0, 0, 0, 957, 958, 3, 366, 183, 0, 958, 959, 5, 10, 0, 0, 959, 961, 1, 0, 0, 0, 960, 957, 1, 0, 0, 0, 960, 961, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 3, 392, 196, 0, 963, 965, 3, 602, 301, 0, 964, 966, 3, 60, 30, 0, 965, 964, 1, 0, 0, 0, 965, 966, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 968, 3, 604, 302, 0, 968, 969, 3, 62, 31, 0, 969, 970, 3, 546, 273, 0, 970, 971, 3, 372, 186, 0, 971, 972, 3, 504, 252, 0, 972, 973, 3, 394, 197, 0, 973, 974, 3, 422, 211, 0, 974, 975, 3, 58, 29, 0, 975, 57, 1, 0, 0, 0, 976, 977, 7, 0, 0, 0, 977, 59, 1, 0, 0, 0, 978, 984, 3, 402, 201, 0, 979, 980, 3, 618, 309, 0, 980, 981, 3, 402, 201, 0, 981, 983, 1, 0, 0, 0, 982, 979, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 61, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 992, 3, 436, 218, 0, 988, 989, 3, 546, 273, 0, 989, 990, 3, 524, 262, 0, 990, 992, 1, 0, 0, 0, 991, 987, 1, 0, 0, 0, 991, 988, 1, 0, 0, 0, 992, 993, 1, 0, 0, 0, 993, 994, 3, 528, 264, 0, 994, 995, 3, 524, 262, 0, 995, 996, 3, 486, 243, 0, 996, 63, 1, 0, 0, 0, 997, 999, 3, 444, 222, 0, 998, 1000, 3, 76, 38, 0, 999, 998, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1003, 3, 408, 204, 0, 1002, 1004, 3, 276, 138, 0, 1003, 1002, 1, 0, 0, 0, 1003, 1004, 1, 0, 0, 0, 1004, 1008, 1, 0, 0, 0, 1005, 1006, 3, 366, 183, 0, 1006, 1007, 5, 10, 0, 0, 1007, 1009, 1, 0, 0, 0, 1008, 1005, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 3, 390, 195, 0, 1011, 1012, 3, 602, 301, 0, 1012, 1013, 3, 372, 186, 0, 1013, 1014, 3, 604, 302, 0, 1014, 1015, 3, 556, 278, 0, 1015, 1016, 3, 392, 196, 0, 1016, 1017, 3, 560, 280, 0, 1017, 1018, 3, 372, 186, 0, 1018, 1019, 3, 466, 233, 0, 1019, 1020, 3, 392, 196, 0, 1020, 1021, 3, 484, 242, 0, 1021, 1022, 3, 66, 33, 0, 1022, 65, 1, 0, 0, 0, 1023, 1028, 3, 354, 177, 0, 1024, 1028, 3, 74, 37, 0, 1025, 1028, 3, 72, 36, 0, 1026, 1028, 3, 68, 34, 0, 1027, 1023, 1, 0, 0, 0, 1027, 1024, 1, 0, 0, 0, 1027, 1025, 1, 0, 0, 0, 1027, 1026, 1, 0, 0, 0, 1028, 67, 1, 0, 0, 0, 1029, 1030, 3, 606, 303, 0, 1030, 1036, 3, 70, 35, 0, 1031, 1032, 3, 618, 309, 0, 1032, 1033, 3, 70, 35, 0, 1033, 1035, 1, 0, 0, 0, 1034, 1031, 1, 0, 0, 0, 1035, 1038, 1, 0, 0, 0, 1036, 1034, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1040, 3, 608, 304, 0, 1040, 69, 1, 0, 0, 0, 1041, 1042, 3, 400, 200, 0, 1042, 1043, 5, 9, 0, 0, 1043, 1044, 3, 66, 33, 0, 1044, 71, 1, 0, 0, 0, 1045, 1046, 3, 602, 301, 0, 1046, 1053, 3, 74, 37, 0, 1047, 1048, 3, 618, 309, 0, 1048, 1049, 3, 354, 177, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1052, 3, 74, 37, 0, 1051, 1047, 1, 0, 0, 0, 1051, 1050, 1, 0, 0, 0, 1052, 1055, 1, 0, 0, 0, 1053, 1051, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1056, 1, 0, 0, 0, 1055, 1053, 1, 0, 0, 0, 1056, 1057, 3, 604, 302, 0, 1057, 73, 1, 0, 0, 0, 1058, 1059, 3, 602, 301, 0, 1059, 1065, 3, 354, 177, 0, 1060, 1061, 3, 618, 309, 0, 1061, 1062, 3, 354, 177, 0, 1062, 1064, 1, 0, 0, 0, 1063, 1060, 1, 0, 0, 0, 1064, 1067, 1, 0, 0, 0, 1065, 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1068, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1068, 1069, 3, 604, 302, 0, 1069, 75, 1, 0, 0, 0, 1070, 1071, 3, 532, 266, 0, 1071, 1072, 3, 542, 271, 0, 1072, 77, 1, 0, 0, 0, 1073, 1074, 3, 416, 208, 0, 1074, 1075, 3, 586, 293, 0, 1075, 1076, 3, 396, 198, 0, 1076, 1077, 3, 596, 298, 0, 1077, 1079, 3, 80, 40, 0, 1078, 1080, 3, 82, 41, 0, 1079, 1078, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 79, 1, 0, 0, 0, 1081, 1082, 3, 536, 268, 0, 1082, 1083, 3, 360, 180, 0, 1083, 81, 1, 0, 0, 0, 1084, 1087, 3, 562, 281, 0, 1085, 1087, 3, 518, 259, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1085, 1, 0, 0, 0, 1087, 83, 1, 0, 0, 0, 1088, 1089, 3, 416, 208, 0, 1089, 1093, 3, 578, 289, 0, 1090, 1091, 3, 366, 183, 0, 1091, 1092, 5, 10, 0, 0, 1092, 1094, 1, 0, 0, 0, 1093, 1090, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 1096, 3, 388, 194, 0, 1096, 1097, 3, 86, 43, 0, 1097, 85, 1, 0, 0, 0, 1098, 1102, 3, 96, 48, 0, 1099, 1102, 3, 94, 47, 0, 1100, 1102, 3, 88, 44, 0, 1101, 1098, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1101, 1100, 1, 0, 0, 0, 1102, 87, 1, 0, 0, 0, 1103, 1104, 3, 540, 270, 0, 1104, 1105, 3, 90, 45, 0, 1105, 89, 1, 0, 0, 0, 1106, 1112, 3, 92, 46, 0, 1107, 1108, 3, 418, 209, 0, 1108, 1109, 3, 92, 46, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1107, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 91, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 3, 370, 185, 0, 1116, 1117, 3, 570, 285, 0, 1117, 1118, 3, 370, 185, 0, 1118, 93, 1, 0, 0, 0, 1119, 1120, 3, 406, 203, 0, 1120, 1121, 3, 370, 185, 0, 1121, 1128, 3, 372, 186, 0, 1122, 1123, 3, 618, 309, 0, 1123, 1124, 3, 370, 185, 0, 1124, 1125, 3, 372, 186, 0, 1125, 1127, 1, 0, 0, 0, 1126, 1122, 1, 0, 0, 0, 1127, 1130, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 95, 1, 0, 0, 0, 1130, 1128, 1, 0, 0, 0, 1131, 1132, 3, 416, 208, 0, 1132, 1133, 3, 370, 185, 0, 1133, 1134, 3, 578, 289, 0, 1134, 1135, 3, 372, 186, 0, 1135, 97, 1, 0, 0, 0, 1136, 1137, 3, 416, 208, 0, 1137, 1138, 3, 564, 282, 0, 1138, 1139, 3, 298, 149, 0, 1139, 1140, 3, 100, 50, 0, 1140, 99, 1, 0, 0, 0, 1141, 1148, 3, 118, 59, 0, 1142, 1148, 3, 108, 54, 0, 1143, 1148, 3, 106, 53, 0, 1144, 1148, 3, 112, 56, 0, 1145, 1148, 3, 104, 52, 0, 1146, 1148, 3, 102, 51, 0, 1147, 1141, 1, 0, 0, 0, 1147, 1142, 1, 0, 0, 0, 1147, 1143, 1, 0, 0, 0, 1147, 1144, 1, 0, 0, 0, 1147, 1145, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 101, 1, 0, 0, 0, 1149, 1150, 3, 596, 298, 0, 1150, 1151, 3, 158, 79, 0, 1151, 103, 1, 0, 0, 0, 1152, 1153, 3, 540, 270, 0, 1153, 1154, 3, 370, 185, 0, 1154, 1155, 3, 570, 285, 0, 1155, 1156, 3, 370, 185, 0, 1156, 105, 1, 0, 0, 0, 1157, 1158, 3, 454, 227, 0, 1158, 1159, 3, 440, 220, 0, 1159, 1160, 3, 558, 279, 0, 1160, 107, 1, 0, 0, 0, 1161, 1162, 3, 454, 227, 0, 1162, 1163, 3, 110, 55, 0, 1163, 109, 1, 0, 0, 0, 1164, 1170, 3, 370, 185, 0, 1165, 1166, 3, 618, 309, 0, 1166, 1167, 3, 370, 185, 0, 1167, 1169, 1, 0, 0, 0, 1168, 1165, 1, 0, 0, 0, 1169, 1172, 1, 0, 0, 0, 1170, 1168, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 111, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1173, 1174, 3, 416, 208, 0, 1174, 1175, 3, 114, 57, 0, 1175, 113, 1, 0, 0, 0, 1176, 1182, 3, 116, 58, 0, 1177, 1178, 3, 618, 309, 0, 1178, 1179, 3, 116, 58, 0, 1179, 1181, 1, 0, 0, 0, 1180, 1177, 1, 0, 0, 0, 1181, 1184, 1, 0, 0, 0, 1182, 1180, 1, 0, 0, 0, 1182, 1183, 1, 0, 0, 0, 1183, 115, 1, 0, 0, 0, 1184, 1182, 1, 0, 0, 0, 1185, 1186, 3, 370, 185, 0, 1186, 1187, 3, 578, 289, 0, 1187, 1188, 3, 372, 186, 0, 1188, 117, 1, 0, 0, 0, 1189, 1190, 3, 406, 203, 0, 1190, 1191, 3, 120, 60, 0, 1191, 119, 1, 0, 0, 0, 1192, 1198, 3, 122, 61, 0, 1193, 1194, 3, 618, 309, 0, 1194, 1195, 3, 122, 61, 0, 1195, 1197, 1, 0, 0, 0, 1196, 1193, 1, 0, 0, 0, 1197, 1200, 1, 0, 0, 0, 1198, 1196, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 121, 1, 0, 0, 0, 1200, 1198, 1, 0, 0, 0, 1201, 1202, 3, 370, 185, 0, 1202, 1203, 3, 372, 186, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 416, 208, 0, 1205, 1206, 3, 548, 274, 0, 1206, 1208, 3, 380, 190, 0, 1207, 1209, 3, 126, 63, 0, 1208, 1207, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 125, 1, 0, 0, 0, 1210, 1211, 3, 596, 298, 0, 1211, 1217, 3, 128, 64, 0, 1212, 1213, 3, 418, 209, 0, 1213, 1214, 3, 128, 64, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1212, 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 127, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1221, 3, 536, 268, 0, 1221, 1222, 5, 19, 0, 0, 1222, 1223, 3, 360, 180, 0, 1223, 1237, 1, 0, 0, 0, 1224, 1225, 3, 512, 256, 0, 1225, 1226, 5, 19, 0, 0, 1226, 1227, 3, 362, 181, 0, 1227, 1237, 1, 0, 0, 0, 1228, 1229, 3, 562, 281, 0, 1229, 1230, 5, 19, 0, 0, 1230, 1231, 3, 362, 181, 0, 1231, 1237, 1, 0, 0, 0, 1232, 1233, 3, 530, 265, 0, 1233, 1234, 5, 19, 0, 0, 1234, 1235, 3, 166, 83, 0, 1235, 1237, 1, 0, 0, 0, 1236, 1220, 1, 0, 0, 0, 1236, 1224, 1, 0, 0, 0, 1236, 1228, 1, 0, 0, 0, 1236, 1232, 1, 0, 0, 0, 1237, 129, 1, 0, 0, 0, 1238, 1239, 3, 416, 208, 0, 1239, 1240, 3, 514, 257, 0, 1240, 1244, 3, 592, 296, 0, 1241, 1242, 3, 366, 183, 0, 1242, 1243, 5, 10, 0, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1241, 1, 0, 0, 0, 1244, 1245, 1, 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1250, 3, 386, 193, 0, 1247, 1248, 3, 596, 298, 0, 1248, 1249, 3, 158, 79, 0, 1249, 1251, 1, 0, 0, 0, 1250, 1247, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 131, 1, 0, 0, 0, 1252, 1253, 3, 454, 227, 0, 1253, 1255, 3, 586, 293, 0, 1254, 1256, 3, 278, 139, 0, 1255, 1254, 1, 0, 0, 0, 1255, 1256, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 1258, 3, 396, 198, 0, 1258, 133, 1, 0, 0, 0, 1259, 1260, 3, 454, 227, 0, 1260, 1262, 3, 578, 289, 0, 1261, 1263, 3, 278, 139, 0, 1262, 1261, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1267, 1, 0, 0, 0, 1264, 1265, 3, 366, 183, 0, 1265, 1266, 5, 10, 0, 0, 1266, 1268, 1, 0, 0, 0, 1267, 1264, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1270, 3, 388, 194, 0, 1270, 135, 1, 0, 0, 0, 1271, 1272, 3, 454, 227, 0, 1272, 1273, 3, 514, 257, 0, 1273, 1275, 3, 592, 296, 0, 1274, 1276, 3, 278, 139, 0, 1275, 1274, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1280, 1, 0, 0, 0, 1277, 1278, 3, 366, 183, 0, 1278, 1279, 5, 10, 0, 0, 1279, 1281, 1, 0, 0, 0, 1280, 1277, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 3, 386, 193, 0, 1283, 137, 1, 0, 0, 0, 1284, 1285, 3, 454, 227, 0, 1285, 1287, 3, 408, 204, 0, 1286, 1288, 3, 278, 139, 0, 1287, 1286, 1, 0, 0, 0, 1287, 1288, 1, 0, 0, 0, 1288, 1292, 1, 0, 0, 0, 1289, 1290, 3, 366, 183, 0, 1290, 1291, 5, 10, 0, 0, 1291, 1293, 1, 0, 0, 0, 1292, 1289, 1, 0, 0, 0, 1292, 1293, 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1295, 3, 390, 195, 0, 1295, 139, 1, 0, 0, 0, 1296, 1297, 3, 454, 227, 0, 1297, 1299, 3, 472, 236, 0, 1298, 1300, 3, 278, 139, 0, 1299, 1298, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1304, 1, 0, 0, 0, 1301, 1302, 3, 366, 183, 0, 1302, 1303, 5, 10, 0, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1301, 1, 0, 0, 0, 1304, 1305, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1307, 3, 392, 196, 0, 1307, 141, 1, 0, 0, 0, 1308, 1309, 3, 454, 227, 0, 1309, 1311, 3, 572, 286, 0, 1310, 1312, 3, 278, 139, 0, 1311, 1310, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 3, 382, 191, 0, 1314, 1315, 3, 528, 264, 0, 1315, 1316, 3, 298, 149, 0, 1316, 143, 1, 0, 0, 0, 1317, 1318, 3, 454, 227, 0, 1318, 1320, 3, 548, 274, 0, 1319, 1321, 3, 278, 139, 0, 1320, 1319, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, 3, 380, 190, 0, 1323, 145, 1, 0, 0, 0, 1324, 1325, 3, 454, 227, 0, 1325, 1327, 3, 564, 282, 0, 1326, 1328, 3, 278, 139, 0, 1327, 1326, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1330, 3, 298, 149, 0, 1330, 147, 1, 0, 0, 0, 1331, 1332, 3, 454, 227, 0, 1332, 1334, 3, 500, 250, 0, 1333, 1335, 3, 278, 139, 0, 1334, 1333, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 1337, 3, 366, 183, 0, 1337, 149, 1, 0, 0, 0, 1338, 1339, 3, 454, 227, 0, 1339, 1341, 3, 482, 241, 0, 1340, 1342, 3, 278, 139, 0, 1341, 1340, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1346, 1, 0, 0, 0, 1343, 1344, 3, 366, 183, 0, 1344, 1345, 5, 10, 0, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1343, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1348, 1, 0, 0, 0, 1348, 1349, 3, 218, 109, 0, 1349, 151, 1, 0, 0, 0, 1350, 1351, 3, 444, 222, 0, 1351, 1353, 3, 564, 282, 0, 1352, 1354, 3, 276, 138, 0, 1353, 1352, 1, 0, 0, 0, 1353, 1354, 1, 0, 0, 0, 1354, 1355, 1, 0, 0, 0, 1355, 1356, 3, 298, 149, 0, 1356, 1357, 3, 602, 301, 0, 1357, 1358, 3, 174, 87, 0, 1358, 1360, 3, 604, 302, 0, 1359, 1361, 3, 154, 77, 0, 1360, 1359, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 153, 1, 0, 0, 0, 1362, 1364, 3, 596, 298, 0, 1363, 1365, 3, 158, 79, 0, 1364, 1363, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1367, 1, 0, 0, 0, 1366, 1368, 3, 156, 78, 0, 1367, 1366, 1, 0, 0, 0, 1367, 1368, 1, 0, 0, 0, 1368, 155, 1, 0, 0, 0, 1369, 1370, 3, 438, 219, 0, 1370, 1371, 3, 534, 267, 0, 1371, 1372, 3, 434, 217, 0, 1372, 1373, 3, 602, 301, 0, 1373, 1375, 3, 370, 185, 0, 1374, 1376, 3, 378, 189, 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1377, 1, 0, 0, 0, 1377, 1378, 3, 604, 302, 0, 1378, 157, 1, 0, 0, 0, 1379, 1385, 3, 160, 80, 0, 1380, 1381, 3, 418, 209, 0, 1381, 1382, 3, 160, 80, 0, 1382, 1384, 1, 0, 0, 0, 1383, 1380, 1, 0, 0, 0, 1384, 1387, 1, 0, 0, 0, 1385, 1383, 1, 0, 0, 0, 1385, 1386, 1, 0, 0, 0, 1386, 159, 1, 0, 0, 0, 1387, 1385, 1, 0, 0, 0, 1388, 1389, 3, 162, 81, 0, 1389, 1390, 5, 19, 0, 0, 1390, 1391, 3, 164, 82, 0, 1391, 1397, 1, 0, 0, 0, 1392, 1393, 3, 162, 81, 0, 1393, 1394, 5, 19, 0, 0, 1394, 1395, 3, 166, 83, 0, 1395, 1397, 1, 0, 0, 0, 1396, 1388, 1, 0, 0, 0, 1396, 1392, 1, 0, 0, 0, 1397, 161, 1, 0, 0, 0, 1398, 1399, 5, 174, 0, 0, 1399, 163, 1, 0, 0, 0, 1400, 1403, 3, 360, 180, 0, 1401, 1403, 3, 358, 179, 0, 1402, 1400, 1, 0, 0, 0, 1402, 1401, 1, 0, 0, 0, 1403, 165, 1, 0, 0, 0, 1404, 1405, 3, 606, 303, 0, 1405, 1411, 3, 168, 84, 0, 1406, 1407, 3, 618, 309, 0, 1407, 1408, 3, 168, 84, 0, 1408, 1410, 1, 0, 0, 0, 1409, 1406, 1, 0, 0, 0, 1410, 1413, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1411, 1, 0, 0, 0, 1414, 1415, 3, 608, 304, 0, 1415, 167, 1, 0, 0, 0, 1416, 1417, 3, 170, 85, 0, 1417, 1418, 5, 9, 0, 0, 1418, 1419, 3, 172, 86, 0, 1419, 169, 1, 0, 0, 0, 1420, 1421, 3, 360, 180, 0, 1421, 171, 1, 0, 0, 0, 1422, 1425, 3, 360, 180, 0, 1423, 1425, 3, 358, 179, 0, 1424, 1422, 1, 0, 0, 0, 1424, 1423, 1, 0, 0, 0, 1425, 173, 1, 0, 0, 0, 1426, 1432, 3, 176, 88, 0, 1427, 1428, 3, 618, 309, 0, 1428, 1429, 3, 176, 88, 0, 1429, 1431, 1, 0, 0, 0, 1430, 1427, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1438, 1, 0, 0, 0, 1434, 1432, 1, 0, 0, 0, 1435, 1436, 3, 618, 309, 0, 1436, 1437, 3, 180, 90, 0, 1437, 1439, 1, 0, 0, 0, 1438, 1435, 1, 0, 0, 0, 1438, 1439, 1, 0, 0, 0, 1439, 175, 1, 0, 0, 0, 1440, 1441, 3, 370, 185, 0, 1441, 1443, 3, 372, 186, 0, 1442, 1444, 3, 178, 89, 0, 1443, 1442, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 177, 1, 0, 0, 0, 1445, 1446, 3, 538, 269, 0, 1446, 1447, 3, 496, 248, 0, 1447, 179, 1, 0, 0, 0, 1448, 1449, 3, 538, 269, 0, 1449, 1450, 3, 496, 248, 0, 1450, 1451, 3, 602, 301, 0, 1451, 1452, 3, 182, 91, 0, 1452, 1453, 3, 604, 302, 0, 1453, 181, 1, 0, 0, 0, 1454, 1458, 3, 184, 92, 0, 1455, 1458, 3, 186, 93, 0, 1456, 1458, 3, 188, 94, 0, 1457, 1454, 1, 0, 0, 0, 1457, 1455, 1, 0, 0, 0, 1457, 1456, 1, 0, 0, 0, 1458, 183, 1, 0, 0, 0, 1459, 1460, 3, 370, 185, 0, 1460, 185, 1, 0, 0, 0, 1461, 1462, 3, 194, 97, 0, 1462, 1463, 3, 618, 309, 0, 1463, 1464, 3, 192, 96, 0, 1464, 187, 1, 0, 0, 0, 1465, 1466, 3, 602, 301, 0, 1466, 1467, 3, 190, 95, 0, 1467, 1468, 3, 604, 302, 0, 1468, 1469, 3, 618, 309, 0, 1469, 1470, 3, 192, 96, 0, 1470, 189, 1, 0, 0, 0, 1471, 1477, 3, 194, 97, 0, 1472, 1473, 3, 618, 309, 0, 1473, 1474, 3, 194, 97, 0, 1474, 1476, 1, 0, 0, 0, 1475, 1472, 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 191, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1486, 3, 196, 98, 0, 1481, 1482, 3, 618, 309, 0, 1482, 1483, 3, 196, 98, 0, 1483, 1485, 1, 0, 0, 0, 1484, 1481, 1, 0, 0, 0, 1485, 1488, 1, 0, 0, 0, 1486, 1484, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 193, 1, 0, 0, 0, 1488, 1486, 1, 0, 0, 0, 1489, 1490, 3, 370, 185, 0, 1490, 195, 1, 0, 0, 0, 1491, 1492, 3, 370, 185, 0, 1492, 197, 1, 0, 0, 0, 1493, 1494, 3, 420, 210, 0, 1494, 1495, 3, 428, 214, 0, 1495, 199, 1, 0, 0, 0, 1496, 1498, 3, 432, 216, 0, 1497, 1499, 3, 202, 101, 0, 1498, 1497, 1, 0, 0, 0, 1498, 1499, 1, 0, 0, 0, 1499, 1500, 1, 0, 0, 0, 1500, 1502, 3, 428, 214, 0, 1501, 1503, 3, 274, 137, 0, 1502, 1501, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 201, 1, 0, 0, 0, 1504, 1507, 3, 510, 255, 0, 1505, 1507, 3, 580, 290, 0, 1506, 1504, 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 203, 1, 0, 0, 0, 1508, 1509, 3, 416, 208, 0, 1509, 1510, 3, 500, 250, 0, 1510, 1511, 3, 366, 183, 0, 1511, 1512, 3, 596, 298, 0, 1512, 1513, 3, 544, 272, 0, 1513, 1514, 5, 19, 0, 0, 1514, 1515, 3, 606, 303, 0, 1515, 1516, 3, 206, 103, 0, 1516, 1520, 3, 608, 304, 0, 1517, 1518, 3, 418, 209, 0, 1518, 1519, 3, 210, 105, 0, 1519, 1521, 1, 0, 0, 0, 1520, 1517, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, 0, 1521, 205, 1, 0, 0, 0, 1522, 1528, 3, 208, 104, 0, 1523, 1524, 3, 618, 309, 0, 1524, 1525, 3, 208, 104, 0, 1525, 1527, 1, 0, 0, 0, 1526, 1523, 1, 0, 0, 0, 1527, 1530, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1528, 1529, 1, 0, 0, 0, 1529, 207, 1, 0, 0, 0, 1530, 1528, 1, 0, 0, 0, 1531, 1532, 5, 169, 0, 0, 1532, 1533, 5, 9, 0, 0, 1533, 1538, 5, 169, 0, 0, 1534, 1535, 5, 169, 0, 0, 1535, 1536, 5, 9, 0, 0, 1536, 1538, 5, 170, 0, 0, 1537, 1531, 1, 0, 0, 0, 1537, 1534, 1, 0, 0, 0, 1538, 209, 1, 0, 0, 0, 1539, 1540, 3, 456, 228, 0, 1540, 1541, 5, 19, 0, 0, 1541, 1542, 3, 362, 181, 0, 1542, 211, 1, 0, 0, 0, 1543, 1544, 3, 584, 292, 0, 1544, 1545, 3, 366, 183, 0, 1545, 213, 1, 0, 0, 0, 1546, 1548, 3, 574, 287, 0, 1547, 1549, 3, 564, 282, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 3, 298, 149, 0, 1551, 215, 1, 0, 0, 0, 1552, 1553, 3, 444, 222, 0, 1553, 1555, 3, 482, 241, 0, 1554, 1556, 3, 276, 138, 0, 1555, 1554, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1558, 1, 0, 0, 0, 1557, 1559, 3, 218, 109, 0, 1558, 1557, 1, 0, 0, 0, 1558, 1559, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1561, 3, 528, 264, 0, 1561, 1562, 3, 298, 149, 0, 1562, 1563, 3, 602, 301, 0, 1563, 1564, 3, 220, 110, 0, 1564, 1565, 3, 604, 302, 0, 1565, 217, 1, 0, 0, 0, 1566, 1569, 5, 174, 0, 0, 1567, 1569, 3, 360, 180, 0, 1568, 1566, 1, 0, 0, 0, 1568, 1567, 1, 0, 0, 0, 1569, 219, 1, 0, 0, 0, 1570, 1575, 3, 370, 185, 0, 1571, 1575, 3, 222, 111, 0, 1572, 1575, 3, 224, 112, 0, 1573, 1575, 3, 226, 113, 0, 1574, 1570, 1, 0, 0, 0, 1574, 1571, 1, 0, 0, 0, 1574, 1572, 1, 0, 0, 0, 1574, 1573, 1, 0, 0, 0, 1575, 221, 1, 0, 0, 0, 1576, 1577, 3, 498, 249, 0, 1577, 1578, 3, 602, 301, 0, 1578, 1579, 5, 174, 0, 0, 1579, 1580, 3, 604, 302, 0, 1580, 223, 1, 0, 0, 0, 1581, 1582, 3, 458, 229, 0, 1582, 1583, 3, 602, 301, 0, 1583, 1584, 5, 174, 0, 0, 1584, 1585, 3, 604, 302, 0, 1585, 225, 1, 0, 0, 0, 1586, 1587, 3, 470, 235, 0, 1587, 1588, 3, 602, 301, 0, 1588, 1589, 5, 174, 0, 0, 1589, 1590, 3, 604, 302, 0, 1590, 227, 1, 0, 0, 0, 1591, 1593, 3, 200, 100, 0, 1592, 1591, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, 1596, 3, 446, 223, 0, 1595, 1597, 3, 230, 115, 0, 1596, 1595, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1600, 3, 300, 150, 0, 1599, 1601, 3, 274, 137, 0, 1600, 1599, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1605, 3, 306, 153, 0, 1603, 1606, 3, 278, 139, 0, 1604, 1606, 3, 236, 118, 0, 1605, 1603, 1, 0, 0, 0, 1605, 1604, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1608, 1, 0, 0, 0, 1607, 1609, 3, 4, 2, 0, 1608, 1607, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 229, 1, 0, 0, 0, 1610, 1616, 3, 232, 116, 0, 1611, 1612, 3, 618, 309, 0, 1612, 1613, 3, 232, 116, 0, 1613, 1615, 1, 0, 0, 0, 1614, 1611, 1, 0, 0, 0, 1615, 1618, 1, 0, 0, 0, 1616, 1614, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 231, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1619, 1621, 3, 314, 157, 0, 1620, 1622, 3, 320, 160, 0, 1621, 1620, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1628, 1, 0, 0, 0, 1623, 1625, 3, 318, 159, 0, 1624, 1626, 3, 320, 160, 0, 1625, 1624, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1619, 1, 0, 0, 0, 1627, 1623, 1, 0, 0, 0, 1628, 233, 1, 0, 0, 0, 1629, 1631, 3, 200, 100, 0, 1630, 1629, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, 0, 1632, 1633, 3, 582, 291, 0, 1633, 1635, 3, 298, 149, 0, 1634, 1636, 3, 268, 134, 0, 1635, 1634, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1638, 3, 554, 277, 0, 1638, 1639, 3, 242, 121, 0, 1639, 1642, 3, 306, 153, 0, 1640, 1643, 3, 278, 139, 0, 1641, 1643, 3, 236, 118, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1641, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1645, 1, 0, 0, 0, 1644, 1646, 3, 4, 2, 0, 1645, 1644, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 235, 1, 0, 0, 0, 1647, 1648, 3, 478, 239, 0, 1648, 1649, 3, 238, 119, 0, 1649, 237, 1, 0, 0, 0, 1650, 1656, 3, 240, 120, 0, 1651, 1652, 3, 418, 209, 0, 1652, 1653, 3, 240, 120, 0, 1653, 1655, 1, 0, 0, 0, 1654, 1651, 1, 0, 0, 0, 1655, 1658, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, 1657, 239, 1, 0, 0, 0, 1658, 1656, 1, 0, 0, 0, 1659, 1660, 5, 174, 0, 0, 1660, 1661, 5, 19, 0, 0, 1661, 1662, 3, 354, 177, 0, 1662, 241, 1, 0, 0, 0, 1663, 1669, 3, 244, 122, 0, 1664, 1665, 3, 618, 309, 0, 1665, 1666, 3, 244, 122, 0, 1666, 1668, 1, 0, 0, 0, 1667, 1664, 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 243, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1677, 3, 250, 125, 0, 1673, 1677, 3, 248, 124, 0, 1674, 1677, 3, 246, 123, 0, 1675, 1677, 3, 254, 127, 0, 1676, 1672, 1, 0, 0, 0, 1676, 1673, 1, 0, 0, 0, 1676, 1674, 1, 0, 0, 0, 1676, 1675, 1, 0, 0, 0, 1677, 245, 1, 0, 0, 0, 1678, 1679, 3, 370, 185, 0, 1679, 1680, 5, 19, 0, 0, 1680, 1681, 3, 352, 176, 0, 1681, 247, 1, 0, 0, 0, 1682, 1683, 3, 370, 185, 0, 1683, 1684, 5, 19, 0, 0, 1684, 1685, 3, 352, 176, 0, 1685, 1686, 3, 262, 131, 0, 1686, 1687, 5, 174, 0, 0, 1687, 249, 1, 0, 0, 0, 1688, 1689, 3, 370, 185, 0, 1689, 1690, 5, 19, 0, 0, 1690, 1691, 5, 174, 0, 0, 1691, 1692, 3, 262, 131, 0, 1692, 1693, 3, 352, 176, 0, 1693, 251, 1, 0, 0, 0, 1694, 1695, 3, 614, 307, 0, 1695, 1696, 3, 354, 177, 0, 1696, 1697, 3, 616, 308, 0, 1697, 253, 1, 0, 0, 0, 1698, 1699, 3, 370, 185, 0, 1699, 1700, 3, 252, 126, 0, 1700, 1701, 5, 19, 0, 0, 1701, 1702, 3, 354, 177, 0, 1702, 255, 1, 0, 0, 0, 1703, 1713, 3, 606, 303, 0, 1704, 1710, 3, 354, 177, 0, 1705, 1706, 3, 618, 309, 0, 1706, 1707, 3, 354, 177, 0, 1707, 1709, 1, 0, 0, 0, 1708, 1705, 1, 0, 0, 0, 1709, 1712, 1, 0, 0, 0, 1710, 1708, 1, 0, 0, 0, 1710, 1711, 1, 0, 0, 0, 1711, 1714, 1, 0, 0, 0, 1712, 1710, 1, 0, 0, 0, 1713, 1704, 1, 0, 0, 0, 1713, 1714, 1, 0, 0, 0, 1714, 1715, 1, 0, 0, 0, 1715, 1716, 3, 608, 304, 0, 1716, 257, 1, 0, 0, 0, 1717, 1718, 3, 606, 303, 0, 1718, 1719, 3, 354, 177, 0, 1719, 1720, 3, 620, 310, 0, 1720, 1721, 3, 354, 177, 0, 1721, 1729, 1, 0, 0, 0, 1722, 1723, 3, 618, 309, 0, 1723, 1724, 3, 354, 177, 0, 1724, 1725, 3, 620, 310, 0, 1725, 1726, 3, 354, 177, 0, 1726, 1728, 1, 0, 0, 0, 1727, 1722, 1, 0, 0, 0, 1728, 1731, 1, 0, 0, 0, 1729, 1727, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, 0, 1731, 1729, 1, 0, 0, 0, 1732, 1733, 3, 608, 304, 0, 1733, 259, 1, 0, 0, 0, 1734, 1744, 3, 614, 307, 0, 1735, 1741, 3, 354, 177, 0, 1736, 1737, 3, 618, 309, 0, 1737, 1738, 3, 354, 177, 0, 1738, 1740, 1, 0, 0, 0, 1739, 1736, 1, 0, 0, 0, 1740, 1743, 1, 0, 0, 0, 1741, 1739, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1744, 1735, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 3, 616, 308, 0, 1747, 261, 1, 0, 0, 0, 1748, 1749, 7, 1, 0, 0, 1749, 263, 1, 0, 0, 0, 1750, 1751, 3, 602, 301, 0, 1751, 1757, 3, 288, 144, 0, 1752, 1753, 3, 618, 309, 0, 1753, 1754, 3, 288, 144, 0, 1754, 1756, 1, 0, 0, 0, 1755, 1752, 1, 0, 0, 0, 1756, 1759, 1, 0, 0, 0, 1757, 1755, 1, 0, 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 1760, 1, 0, 0, 0, 1759, 1757, 1, 0, 0, 0, 1760, 1761, 3, 604, 302, 0, 1761, 265, 1, 0, 0, 0, 1762, 1764, 3, 200, 100, 0, 1763, 1762, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1766, 3, 488, 244, 0, 1766, 1767, 3, 490, 245, 0, 1767, 1769, 3, 298, 149, 0, 1768, 1770, 3, 282, 141, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 1773, 3, 280, 140, 0, 1772, 1774, 3, 276, 138, 0, 1773, 1772, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1776, 1, 0, 0, 0, 1775, 1777, 3, 268, 134, 0, 1776, 1775, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1779, 1, 0, 0, 0, 1778, 1780, 3, 4, 2, 0, 1779, 1778, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 267, 1, 0, 0, 0, 1781, 1782, 3, 588, 294, 0, 1782, 1783, 3, 272, 136, 0, 1783, 1798, 1, 0, 0, 0, 1784, 1785, 3, 588, 294, 0, 1785, 1786, 3, 272, 136, 0, 1786, 1787, 3, 418, 209, 0, 1787, 1788, 3, 270, 135, 0, 1788, 1798, 1, 0, 0, 0, 1789, 1790, 3, 588, 294, 0, 1790, 1791, 3, 270, 135, 0, 1791, 1798, 1, 0, 0, 0, 1792, 1793, 3, 588, 294, 0, 1793, 1794, 3, 270, 135, 0, 1794, 1795, 3, 418, 209, 0, 1795, 1796, 3, 272, 136, 0, 1796, 1798, 1, 0, 0, 0, 1797, 1781, 1, 0, 0, 0, 1797, 1784, 1, 0, 0, 0, 1797, 1789, 1, 0, 0, 0, 1797, 1792, 1, 0, 0, 0, 1798, 269, 1, 0, 0, 0, 1799, 1802, 3, 568, 284, 0, 1800, 1803, 3, 338, 169, 0, 1801, 1803, 3, 356, 178, 0, 1802, 1800, 1, 0, 0, 0, 1802, 1801, 1, 0, 0, 0, 1803, 271, 1, 0, 0, 0, 1804, 1805, 3, 576, 288, 0, 1805, 1806, 3, 356, 178, 0, 1806, 273, 1, 0, 0, 0, 1807, 1808, 3, 588, 294, 0, 1808, 1809, 3, 270, 135, 0, 1809, 275, 1, 0, 0, 0, 1810, 1811, 3, 478, 239, 0, 1811, 1812, 3, 522, 261, 0, 1812, 1813, 3, 462, 231, 0, 1813, 277, 1, 0, 0, 0, 1814, 1815, 3, 478, 239, 0, 1815, 1816, 3, 462, 231, 0, 1816, 279, 1, 0, 0, 0, 1817, 1818, 3, 590, 295, 0, 1818, 1819, 5, 1, 0, 0, 1819, 1820, 3, 286, 143, 0, 1820, 1821, 5, 2, 0, 0, 1821, 1826, 1, 0, 0, 0, 1822, 1823, 3, 494, 247, 0, 1823, 1824, 3, 354, 177, 0, 1824, 1826, 1, 0, 0, 0, 1825, 1817, 1, 0, 0, 0, 1825, 1822, 1, 0, 0, 0, 1826, 281, 1, 0, 0, 0, 1827, 1828, 5, 1, 0, 0, 1828, 1829, 3, 284, 142, 0, 1829, 1830, 5, 2, 0, 0, 1830, 283, 1, 0, 0, 0, 1831, 1837, 3, 370, 185, 0, 1832, 1833, 3, 618, 309, 0, 1833, 1834, 3, 370, 185, 0, 1834, 1836, 1, 0, 0, 0, 1835, 1832, 1, 0, 0, 0, 1836, 1839, 1, 0, 0, 0, 1837, 1835, 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838, 285, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1846, 3, 352, 176, 0, 1841, 1842, 3, 618, 309, 0, 1842, 1843, 3, 352, 176, 0, 1843, 1845, 1, 0, 0, 0, 1844, 1841, 1, 0, 0, 0, 1845, 1848, 1, 0, 0, 0, 1846, 1844, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 287, 1, 0, 0, 0, 1848, 1846, 1, 0, 0, 0, 1849, 1856, 3, 354, 177, 0, 1850, 1856, 3, 348, 174, 0, 1851, 1856, 3, 258, 129, 0, 1852, 1856, 3, 256, 128, 0, 1853, 1856, 3, 260, 130, 0, 1854, 1856, 3, 264, 132, 0, 1855, 1849, 1, 0, 0, 0, 1855, 1850, 1, 0, 0, 0, 1855, 1851, 1, 0, 0, 0, 1855, 1852, 1, 0, 0, 0, 1855, 1853, 1, 0, 0, 0, 1855, 1854, 1, 0, 0, 0, 1856, 289, 1, 0, 0, 0, 1857, 1859, 3, 552, 276, 0, 1858, 1860, 3, 308, 154, 0, 1859, 1858, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1862, 1, 0, 0, 0, 1861, 1863, 3, 494, 247, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 3, 310, 155, 0, 1865, 1867, 3, 300, 150, 0, 1866, 1868, 3, 306, 153, 0, 1867, 1866, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1871, 3, 622, 311, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1873, 1, 0, 0, 0, 1872, 1874, 3, 302, 151, 0, 1873, 1872, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1876, 1, 0, 0, 0, 1875, 1877, 3, 294, 147, 0, 1876, 1875, 1, 0, 0, 0, 1876, 1877, 1, 0, 0, 0, 1877, 1879, 1, 0, 0, 0, 1878, 1880, 3, 292, 146, 0, 1879, 1878, 1, 0, 0, 0, 1879, 1880, 1, 0, 0, 0, 1880, 1882, 1, 0, 0, 0, 1881, 1883, 3, 4, 2, 0, 1882, 1881, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 291, 1, 0, 0, 0, 1884, 1885, 3, 414, 207, 0, 1885, 1886, 3, 464, 232, 0, 1886, 293, 1, 0, 0, 0, 1887, 1890, 3, 506, 253, 0, 1888, 1891, 3, 338, 169, 0, 1889, 1891, 3, 356, 178, 0, 1890, 1888, 1, 0, 0, 0, 1890, 1889, 1, 0, 0, 0, 1891, 295, 1, 0, 0, 0, 1892, 1893, 5, 83, 0, 0, 1893, 297, 1, 0, 0, 0, 1894, 1895, 3, 366, 183, 0, 1895, 1896, 5, 10, 0, 0, 1896, 1898, 1, 0, 0, 0, 1897, 1894, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1900, 3, 368, 184, 0, 1900, 299, 1, 0, 0, 0, 1901, 1902, 3, 468, 234, 0, 1902, 1903, 3, 298, 149, 0, 1903, 301, 1, 0, 0, 0, 1904, 1905, 3, 534, 267, 0, 1905, 1906, 3, 434, 217, 0, 1906, 1912, 3, 304, 152, 0, 1907, 1908, 3, 618, 309, 0, 1908, 1909, 3, 304, 152, 0, 1909, 1911, 1, 0, 0, 0, 1910, 1907, 1, 0, 0, 0, 1911, 1914, 1, 0, 0, 0, 1912, 1910, 1, 0, 0, 0, 1912, 1913, 1, 0, 0, 0, 1913, 303, 1, 0, 0, 0, 1914, 1912, 1, 0, 0, 0, 1915, 1918, 5, 174, 0, 0, 1916, 1919, 3, 424, 212, 0, 1917, 1919, 3, 448, 224, 0, 1918, 1916, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1918, 1919, 1, 0, 0, 0, 1919, 305, 1, 0, 0, 0, 1920, 1921, 3, 594, 297, 0, 1921, 1922, 3, 322, 161, 0, 1922, 307, 1, 0, 0, 0, 1923, 1924, 3, 452, 226, 0, 1924, 309, 1, 0, 0, 0, 1925, 1928, 5, 11, 0, 0, 1926, 1928, 3, 312, 156, 0, 1927, 1925, 1, 0, 0, 0, 1927, 1926, 1, 0, 0, 0, 1928, 1934, 1, 0, 0, 0, 1929, 1930, 3, 618, 309, 0, 1930, 1931, 3, 312, 156, 0, 1931, 1933, 1, 0, 0, 0, 1932, 1929, 1, 0, 0, 0, 1933, 1936, 1, 0, 0, 0, 1934, 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 311, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1937, 1939, 3, 314, 157, 0, 1938, 1940, 3, 320, 160, 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1950, 1, 0, 0, 0, 1941, 1943, 3, 316, 158, 0, 1942, 1944, 3, 320, 160, 0, 1943, 1942, 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 1950, 1, 0, 0, 0, 1945, 1947, 3, 318, 159, 0, 1946, 1948, 3, 320, 160, 0, 1947, 1946, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1950, 1, 0, 0, 0, 1949, 1937, 1, 0, 0, 0, 1949, 1941, 1, 0, 0, 0, 1949, 1945, 1, 0, 0, 0, 1950, 313, 1, 0, 0, 0, 1951, 1952, 3, 370, 185, 0, 1952, 315, 1, 0, 0, 0, 1953, 1954, 3, 348, 174, 0, 1954, 317, 1, 0, 0, 0, 1955, 1956, 3, 370, 185, 0, 1956, 1957, 3, 614, 307, 0, 1957, 1958, 3, 354, 177, 0, 1958, 1959, 3, 616, 308, 0, 1959, 319, 1, 0, 0, 0, 1960, 1961, 3, 422, 211, 0, 1961, 1962, 5, 174, 0, 0, 1962, 321, 1, 0, 0, 0, 1963, 1969, 3, 324, 162, 0, 1964, 1965, 3, 418, 209, 0, 1965, 1966, 3, 324, 162, 0, 1966, 1968, 1, 0, 0, 0, 1967, 1964, 1, 0, 0, 0, 1968, 1971, 1, 0, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 323, 1, 0, 0, 0, 1971, 1969, 1, 0, 0, 0, 1972, 2040, 3, 334, 167, 0, 1973, 2040, 3, 336, 168, 0, 1974, 2040, 3, 332, 166, 0, 1975, 2040, 3, 328, 164, 0, 1976, 2040, 3, 330, 165, 0, 1977, 2040, 3, 346, 173, 0, 1978, 2040, 3, 344, 172, 0, 1979, 2040, 3, 342, 171, 0, 1980, 1981, 5, 174, 0, 0, 1981, 1982, 5, 10, 0, 0, 1982, 1983, 5, 174, 0, 0, 1983, 1984, 3, 296, 148, 0, 1984, 1985, 3, 354, 177, 0, 1985, 2040, 1, 0, 0, 0, 1986, 1987, 5, 174, 0, 0, 1987, 1988, 5, 10, 0, 0, 1988, 1989, 5, 174, 0, 0, 1989, 1990, 3, 430, 215, 0, 1990, 1991, 3, 354, 177, 0, 1991, 1992, 3, 418, 209, 0, 1992, 1993, 3, 354, 177, 0, 1993, 2040, 1, 0, 0, 0, 1994, 1995, 5, 1, 0, 0, 1995, 2001, 5, 174, 0, 0, 1996, 1997, 3, 618, 309, 0, 1997, 1998, 5, 174, 0, 0, 1998, 2000, 1, 0, 0, 0, 1999, 1996, 1, 0, 0, 0, 2000, 2003, 1, 0, 0, 0, 2001, 1999, 1, 0, 0, 0, 2001, 2002, 1, 0, 0, 0, 2002, 2004, 1, 0, 0, 0, 2003, 2001, 1, 0, 0, 0, 2004, 2005, 5, 2, 0, 0, 2005, 2006, 3, 480, 240, 0, 2006, 2007, 5, 1, 0, 0, 2007, 2013, 3, 264, 132, 0, 2008, 2009, 3, 618, 309, 0, 2009, 2010, 3, 264, 132, 0, 2010, 2012, 1, 0, 0, 0, 2011, 2008, 1, 0, 0, 0, 2012, 2015, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2013, 2014, 1, 0, 0, 0, 2014, 2016, 1, 0, 0, 0, 2015, 2013, 1, 0, 0, 0, 2016, 2017, 5, 2, 0, 0, 2017, 2040, 1, 0, 0, 0, 2018, 2019, 5, 1, 0, 0, 2019, 2025, 5, 174, 0, 0, 2020, 2021, 3, 618, 309, 0, 2021, 2022, 5, 174, 0, 0, 2022, 2024, 1, 0, 0, 0, 2023, 2020, 1, 0, 0, 0, 2024, 2027, 1, 0, 0, 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2028, 1, 0, 0, 0, 2027, 2025, 1, 0, 0, 0, 2028, 2029, 5, 2, 0, 0, 2029, 2030, 3, 326, 163, 0, 2030, 2036, 3, 264, 132, 0, 2031, 2032, 3, 618, 309, 0, 2032, 2033, 3, 264, 132, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2031, 1, 0, 0, 0, 2035, 2038, 1, 0, 0, 0, 2036, 2034, 1, 0, 0, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2040, 1, 0, 0, 0, 2038, 2036, 1, 0, 0, 0, 2039, 1972, 1, 0, 0, 0, 2039, 1973, 1, 0, 0, 0, 2039, 1974, 1, 0, 0, 0, 2039, 1975, 1, 0, 0, 0, 2039, 1976, 1, 0, 0, 0, 2039, 1977, 1, 0, 0, 0, 2039, 1978, 1, 0, 0, 0, 2039, 1979, 1, 0, 0, 0, 2039, 1980, 1, 0, 0, 0, 2039, 1986, 1, 0, 0, 0, 2039, 1994, 1, 0, 0, 0, 2039, 2018, 1, 0, 0, 0, 2040, 325, 1, 0, 0, 0, 2041, 2042, 7, 2, 0, 0, 2042, 327, 1, 0, 0, 0, 2043, 2044, 3, 348, 174, 0, 2044, 2045, 3, 326, 163, 0, 2045, 2046, 3, 354, 177, 0, 2046, 329, 1, 0, 0, 0, 2047, 2048, 3, 348, 174, 0, 2048, 2049, 3, 326, 163, 0, 2049, 2050, 3, 348, 174, 0, 2050, 331, 1, 0, 0, 0, 2051, 2052, 3, 370, 185, 0, 2052, 2053, 3, 430, 215, 0, 2053, 2054, 3, 354, 177, 0, 2054, 2055, 3, 418, 209, 0, 2055, 2056, 3, 354, 177, 0, 2056, 333, 1, 0, 0, 0, 2057, 2058, 3, 370, 185, 0, 2058, 2059, 3, 326, 163, 0, 2059, 2060, 3, 354, 177, 0, 2060, 335, 1, 0, 0, 0, 2061, 2062, 3, 370, 185, 0, 2062, 2063, 3, 296, 148, 0, 2063, 2064, 3, 354, 177, 0, 2064, 337, 1, 0, 0, 0, 2065, 2066, 7, 3, 0, 0, 2066, 339, 1, 0, 0, 0, 2067, 2073, 3, 338, 169, 0, 2068, 2069, 5, 1, 0, 0, 2069, 2070, 3, 350, 175, 0, 2070, 2071, 5, 2, 0, 0, 2071, 2073, 1, 0, 0, 0, 2072, 2067, 1, 0, 0, 0, 2072, 2068, 1, 0, 0, 0, 2073, 341, 1, 0, 0, 0, 2074, 2075, 3, 370, 185, 0, 2075, 2076, 3, 480, 240, 0, 2076, 2077, 3, 340, 170, 0, 2077, 343, 1, 0, 0, 0, 2078, 2079, 3, 370, 185, 0, 2079, 2080, 3, 442, 221, 0, 2080, 2081, 3, 354, 177, 0, 2081, 345, 1, 0, 0, 0, 2082, 2083, 3, 370, 185, 0, 2083, 2084, 3, 442, 221, 0, 2084, 2085, 3, 496, 248, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2087, 3, 354, 177, 0, 2087, 347, 1, 0, 0, 0, 2088, 2089, 5, 174, 0, 0, 2089, 2090, 5, 1, 0, 0, 2090, 2091, 5, 11, 0, 0, 2091, 2108, 5, 2, 0, 0, 2092, 2093, 5, 174, 0, 0, 2093, 2095, 5, 1, 0, 0, 2094, 2096, 3, 350, 175, 0, 2095, 2094, 1, 0, 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2108, 5, 2, 0, 0, 2098, 2099, 5, 141, 0, 0, 2099, 2100, 5, 1, 0, 0, 2100, 2108, 5, 2, 0, 0, 2101, 2102, 5, 146, 0, 0, 2102, 2104, 5, 1, 0, 0, 2103, 2105, 3, 350, 175, 0, 2104, 2103, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2108, 5, 2, 0, 0, 2107, 2088, 1, 0, 0, 0, 2107, 2092, 1, 0, 0, 0, 2107, 2098, 1, 0, 0, 0, 2107, 2101, 1, 0, 0, 0, 2108, 349, 1, 0, 0, 0, 2109, 2113, 3, 354, 177, 0, 2110, 2113, 5, 174, 0, 0, 2111, 2113, 3, 348, 174, 0, 2112, 2109, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2112, 2111, 1, 0, 0, 0, 2113, 2122, 1, 0, 0, 0, 2114, 2118, 3, 618, 309, 0, 2115, 2119, 3, 354, 177, 0, 2116, 2119, 5, 174, 0, 0, 2117, 2119, 3, 348, 174, 0, 2118, 2115, 1, 0, 0, 0, 2118, 2116, 1, 0, 0, 0, 2118, 2117, 1, 0, 0, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2114, 1, 0, 0, 0, 2121, 2124, 1, 0, 0, 0, 2122, 2120, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 351, 1, 0, 0, 0, 2124, 2122, 1, 0, 0, 0, 2125, 2133, 3, 338, 169, 0, 2126, 2133, 3, 354, 177, 0, 2127, 2133, 3, 348, 174, 0, 2128, 2133, 3, 258, 129, 0, 2129, 2133, 3, 256, 128, 0, 2130, 2133, 3, 260, 130, 0, 2131, 2133, 3, 264, 132, 0, 2132, 2125, 1, 0, 0, 0, 2132, 2126, 1, 0, 0, 0, 2132, 2127, 1, 0, 0, 0, 2132, 2128, 1, 0, 0, 0, 2132, 2129, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2131, 1, 0, 0, 0, 2133, 353, 1, 0, 0, 0, 2134, 2144, 3, 338, 169, 0, 2135, 2144, 3, 524, 262, 0, 2136, 2144, 5, 175, 0, 0, 2137, 2144, 3, 360, 180, 0, 2138, 2144, 3, 356, 178, 0, 2139, 2144, 3, 358, 179, 0, 2140, 2144, 3, 364, 182, 0, 2141, 2144, 3, 362, 181, 0, 2142, 2144, 3, 58, 29, 0, 2143, 2134, 1, 0, 0, 0, 2143, 2135, 1, 0, 0, 0, 2143, 2136, 1, 0, 0, 0, 2143, 2137, 1, 0, 0, 0, 2143, 2138, 1, 0, 0, 0, 2143, 2139, 1, 0, 0, 0, 2143, 2140, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2143, 2142, 1, 0, 0, 0, 2144, 355, 1, 0, 0, 0, 2145, 2146, 5, 170, 0, 0, 2146, 357, 1, 0, 0, 0, 2147, 2148, 7, 4, 0, 0, 2148, 359, 1, 0, 0, 0, 2149, 2150, 5, 169, 0, 0, 2150, 361, 1, 0, 0, 0, 2151, 2152, 7, 5, 0, 0, 2152, 363, 1, 0, 0, 0, 2153, 2154, 5, 172, 0, 0, 2154, 365, 1, 0, 0, 0, 2155, 2160, 5, 174, 0, 0, 2156, 2157, 5, 17, 0, 0, 2157, 2158, 5, 174, 0, 0, 2158, 2160, 5, 17, 0, 0, 2159, 2155, 1, 0, 0, 0, 2159, 2156, 1, 0, 0, 0, 2160, 367, 1, 0, 0, 0, 2161, 2169, 5, 174, 0, 0, 2162, 2169, 5, 79, 0, 0, 2163, 2169, 5, 125, 0, 0, 2164, 2169, 5, 63, 0, 0, 2165, 2166, 5, 17, 0, 0, 2166, 2167, 5, 174, 0, 0, 2167, 2169, 5, 17, 0, 0, 2168, 2161, 1, 0, 0, 0, 2168, 2162, 1, 0, 0, 0, 2168, 2163, 1, 0, 0, 0, 2168, 2164, 1, 0, 0, 0, 2168, 2165, 1, 0, 0, 0, 2169, 369, 1, 0, 0, 0, 2170, 2177, 5, 174, 0, 0, 2171, 2177, 3, 578, 289, 0, 2172, 2177, 5, 76, 0, 0, 2173, 2174, 5, 17, 0, 0, 2174, 2175, 5, 174, 0, 0, 2175, 2177, 5, 17, 0, 0, 2176, 2170, 1, 0, 0, 0, 2176, 2171, 1, 0, 0, 0, 2176, 2172, 1, 0, 0, 0, 2176, 2173, 1, 0, 0, 0, 2177, 371, 1, 0, 0, 0, 2178, 2180, 3, 374, 187, 0, 2179, 2181, 3, 376, 188, 0, 2180, 2179, 1, 0, 0, 0, 2180, 2181, 1, 0, 0, 0, 2181, 373, 1, 0, 0, 0, 2182, 2183, 7, 6, 0, 0, 2183, 375, 1, 0, 0, 0, 2184, 2185, 3, 610, 305, 0, 2185, 2191, 3, 372, 186, 0, 2186, 2187, 3, 618, 309, 0, 2187, 2188, 3, 372, 186, 0, 2188, 2190, 1, 0, 0, 0, 2189, 2186, 1, 0, 0, 0, 2190, 2193, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2191, 2192, 1, 0, 0, 0, 2192, 2194, 1, 0, 0, 0, 2193, 2191, 1, 0, 0, 0, 2194, 2195, 3, 612, 306, 0, 2195, 377, 1, 0, 0, 0, 2196, 2199, 3, 424, 212, 0, 2197, 2199, 3, 448, 224, 0, 2198, 2196, 1, 0, 0, 0, 2198, 2197, 1, 0, 0, 0, 2199, 379, 1, 0, 0, 0, 2200, 2201, 5, 174, 0, 0, 2201, 381, 1, 0, 0, 0, 2202, 2203, 5, 174, 0, 0, 2203, 383, 1, 0, 0, 0, 2204, 2205, 3, 360, 180, 0, 2205, 385, 1, 0, 0, 0, 2206, 2207, 5, 174, 0, 0, 2207, 387, 1, 0, 0, 0, 2208, 2209, 5, 174, 0, 0, 2209, 389, 1, 0, 0, 0, 2210, 2211, 5, 174, 0, 0, 2211, 391, 1, 0, 0, 0, 2212, 2213, 5, 174, 0, 0, 2213, 393, 1, 0, 0, 0, 2214, 2215, 5, 174, 0, 0, 2215, 395, 1, 0, 0, 0, 2216, 2217, 5, 174, 0, 0, 2217, 397, 1, 0, 0, 0, 2218, 2219, 3, 360, 180, 0, 2219, 399, 1, 0, 0, 0, 2220, 2221, 5, 174, 0, 0, 2221, 401, 1, 0, 0, 0, 2222, 2223, 3, 404, 202, 0, 2223, 2224, 3, 372, 186, 0, 2224, 403, 1, 0, 0, 0, 2225, 2226, 7, 7, 0, 0, 2226, 405, 1, 0, 0, 0, 2227, 2228, 5, 24, 0, 0, 2228, 407, 1, 0, 0, 0, 2229, 2230, 5, 25, 0, 0, 2230, 409, 1, 0, 0, 0, 2231, 2232, 5, 26, 0, 0, 2232, 411, 1, 0, 0, 0, 2233, 2234, 5, 26, 0, 0, 2234, 2235, 5, 106, 0, 0, 2235, 413, 1, 0, 0, 0, 2236, 2237, 5, 27, 0, 0, 2237, 415, 1, 0, 0, 0, 2238, 2239, 5, 28, 0, 0, 2239, 417, 1, 0, 0, 0, 2240, 2241, 5, 29, 0, 0, 2241, 419, 1, 0, 0, 0, 2242, 2243, 5, 31, 0, 0, 2243, 421, 1, 0, 0, 0, 2244, 2245, 5, 32, 0, 0, 2245, 423, 1, 0, 0, 0, 2246, 2247, 5, 33, 0, 0, 2247, 425, 1, 0, 0, 0, 2248, 2249, 5, 34, 0, 0, 2249, 427, 1, 0, 0, 0, 2250, 2251, 5, 35, 0, 0, 2251, 429, 1, 0, 0, 0, 2252, 2253, 5, 37, 0, 0, 2253, 431, 1, 0, 0, 0, 2254, 2255, 5, 36, 0, 0, 2255, 433, 1, 0, 0, 0, 2256, 2257, 5, 38, 0, 0, 2257, 435, 1, 0, 0, 0, 2258, 2259, 5, 39, 0, 0, 2259, 437, 1, 0, 0, 0, 2260, 2261, 5, 40, 0, 0, 2261, 439, 1, 0, 0, 0, 2262, 2263, 5, 42, 0, 0, 2263, 441, 1, 0, 0, 0, 2264, 2265, 5, 44, 0, 0, 2265, 443, 1, 0, 0, 0, 2266, 2267, 5, 45, 0, 0, 2267, 445, 1, 0, 0, 0, 2268, 2269, 5, 47, 0, 0, 2269, 447, 1, 0, 0, 0, 2270, 2271, 5, 48, 0, 0, 2271, 449, 1, 0, 0, 0, 2272, 2273, 5, 49, 0, 0, 2273, 451, 1, 0, 0, 0, 2274, 2275, 5, 50, 0, 0, 2275, 453, 1, 0, 0, 0, 2276, 2277, 5, 51, 0, 0, 2277, 455, 1, 0, 0, 0, 2278, 2279, 5, 52, 0, 0, 2279, 457, 1, 0, 0, 0, 2280, 2281, 5, 54, 0, 0, 2281, 459, 1, 0, 0, 0, 2282, 2283, 5, 55, 0, 0, 2283, 461, 1, 0, 0, 0, 2284, 2285, 5, 56, 0, 0, 2285, 463, 1, 0, 0, 0, 2286, 2287, 5, 58, 0, 0, 2287, 465, 1, 0, 0, 0, 2288, 2289, 5, 59, 0, 0, 2289, 467, 1, 0, 0, 0, 2290, 2291, 5, 60, 0, 0, 2291, 469, 1, 0, 0, 0, 2292, 2293, 5, 61, 0, 0, 2293, 471, 1, 0, 0, 0, 2294, 2295, 5, 62, 0, 0, 2295, 473, 1, 0, 0, 0, 2296, 2297, 5, 63, 0, 0, 2297, 475, 1, 0, 0, 0, 2298, 2299, 5, 64, 0, 0, 2299, 477, 1, 0, 0, 0, 2300, 2301, 5, 66, 0, 0, 2301, 479, 1, 0, 0, 0, 2302, 2303, 5, 67, 0, 0, 2303, 481, 1, 0, 0, 0, 2304, 2305, 5, 68, 0, 0, 2305, 483, 1, 0, 0, 0, 2306, 2307, 5, 70, 0, 0, 2307, 485, 1, 0, 0, 0, 2308, 2309, 5, 71, 0, 0, 2309, 487, 1, 0, 0, 0, 2310, 2311, 5, 72, 0, 0, 2311, 489, 1, 0, 0, 0, 2312, 2313, 5, 73, 0, 0, 2313, 491, 1, 0, 0, 0, 2314, 2315, 5, 74, 0, 0, 2315, 493, 1, 0, 0, 0, 2316, 2317, 5, 75, 0, 0, 2317, 495, 1, 0, 0, 0, 2318, 2319, 5, 76, 0, 0, 2319, 497, 1, 0, 0, 0, 2320, 2321, 5, 77, 0, 0, 2321, 499, 1, 0, 0, 0, 2322, 2323, 5, 78, 0, 0, 2323, 501, 1, 0, 0, 0, 2324, 2325, 5, 79, 0, 0, 2325, 503, 1, 0, 0, 0, 2326, 2327, 5, 80, 0, 0, 2327, 505, 1, 0, 0, 0, 2328, 2329, 5, 82, 0, 0, 2329, 507, 1, 0, 0, 0, 2330, 2331, 5, 84, 0, 0, 2331, 509, 1, 0, 0, 0, 2332, 2333, 5, 87, 0, 0, 2333, 511, 1, 0, 0, 0, 2334, 2335, 5, 88, 0, 0, 2335, 513, 1, 0, 0, 0, 2336, 2337, 5, 89, 0, 0, 2337, 515, 1, 0, 0, 0, 2338, 2339, 5, 90, 0, 0, 2339, 517, 1, 0, 0, 0, 2340, 2341, 5, 93, 0, 0, 2341, 519, 1, 0, 0, 0, 2342, 2343, 5, 92, 0, 0, 2343, 521, 1, 0, 0, 0, 2344, 2345, 5, 94, 0, 0, 2345, 523, 1, 0, 0, 0, 2346, 2347, 5, 95, 0, 0, 2347, 525, 1, 0, 0, 0, 2348, 2349, 5, 96, 0, 0, 2349, 527, 1, 0, 0, 0, 2350, 2351, 5, 97, 0, 0, 2351, 529, 1, 0, 0, 0, 2352, 2353, 5, 99, 0, 0, 2353, 531, 1, 0, 0, 0, 2354, 2355, 5, 100, 0, 0, 2355, 533, 1, 0, 0, 0, 2356, 2357, 5, 101, 0, 0, 2357, 535, 1, 0, 0, 0, 2358, 2359, 5, 103, 0, 0, 2359, 537, 1, 0, 0, 0, 2360, 2361, 5, 107, 0, 0, 2361, 539, 1, 0, 0, 0, 2362, 2363, 5, 109, 0, 0, 2363, 541, 1, 0, 0, 0, 2364, 2365, 5, 110, 0, 0, 2365, 543, 1, 0, 0, 0, 2366, 2367, 5, 111, 0, 0, 2367, 545, 1, 0, 0, 0, 2368, 2369, 5, 112, 0, 0, 2369, 547, 1, 0, 0, 0, 2370, 2371, 5, 114, 0, 0, 2371, 549, 1, 0, 0, 0, 2372, 2373, 5, 115, 0, 0, 2373, 551, 1, 0, 0, 0, 2374, 2375, 5, 117, 0, 0, 2375, 553, 1, 0, 0, 0, 2376, 2377, 5, 118, 0, 0, 2377, 555, 1, 0, 0, 0, 2378, 2379, 5, 119, 0, 0, 2379, 557, 1, 0, 0, 0, 2380, 2381, 5, 121, 0, 0, 2381, 559, 1, 0, 0, 0, 2382, 2383, 5, 122, 0, 0, 2383, 561, 1, 0, 0, 0, 2384, 2385, 5, 123, 0, 0, 2385, 563, 1, 0, 0, 0, 2386, 2387, 5, 124, 0, 0, 2387, 565, 1, 0, 0, 0, 2388, 2389, 5, 125, 0, 0, 2389, 567, 1, 0, 0, 0, 2390, 2391, 5, 127, 0, 0, 2391, 569, 1, 0, 0, 0, 2392, 2393, 5, 128, 0, 0, 2393, 571, 1, 0, 0, 0, 2394, 2395, 5, 130, 0, 0, 2395, 573, 1, 0, 0, 0, 2396, 2397, 5, 132, 0, 0, 2397, 575, 1, 0, 0, 0, 2398, 2399, 5, 133, 0, 0, 2399, 577, 1, 0, 0, 0, 2400, 2401, 5, 135, 0, 0, 2401, 579, 1, 0, 0, 0, 2402, 2403, 5, 136, 0, 0, 2403, 581, 1, 0, 0, 0, 2404, 2405, 5, 137, 0, 0, 2405, 583, 1, 0, 0, 0, 2406, 2407, 5, 138, 0, 0, 2407, 585, 1, 0, 0, 0, 2408, 2409, 5, 139, 0, 0, 2409, 587, 1, 0, 0, 0, 2410, 2411, 5, 140, 0, 0, 2411, 589, 1, 0, 0, 0, 2412, 2413, 5, 142, 0, 0, 2413, 591, 1, 0, 0, 0, 2414, 2415, 5, 143, 0, 0, 2415, 593, 1, 0, 0, 0, 2416, 2417, 5, 144, 0, 0, 2417, 595, 1, 0, 0, 0, 2418, 2419, 5, 145, 0, 0, 2419, 597, 1, 0, 0, 0, 2420, 2421, 5, 113, 0, 0, 2421, 599, 1, 0, 0, 0, 2422, 2423, 5, 65, 0, 0, 2423, 601, 1, 0, 0, 0, 2424, 2425, 5, 1, 0, 0, 2425, 603, 1, 0, 0, 0, 2426, 2427, 5, 2, 0, 0, 2427, 605, 1, 0, 0, 0, 2428, 2429, 5, 3, 0, 0, 2429, 607, 1, 0, 0, 0, 2430, 2431, 5, 4, 0, 0, 2431, 609, 1, 0, 0, 0, 2432, 2433, 5, 20, 0, 0, 2433, 611, 1, 0, 0, 0, 2434, 2435, 5, 21, 0, 0, 2435, 613, 1, 0, 0, 0, 2436, 2437, 5, 5, 0, 0, 2437, 615, 1, 0, 0, 0, 2438, 2439, 5, 6, 0, 0, 2439, 617, 1, 0, 0, 0, 2440, 2441, 5, 7, 0, 0, 2441, 619, 1, 0, 0, 0, 2442, 2443, 5, 9, 0, 0, 2443, 621, 1, 0, 0, 0, 2444, 2445, 3, 600, 300, 0, 2445, 2446, 3, 434, 217, 0, 2446, 2452, 3, 624, 312, 0, 2447, 2448, 3, 618, 309, 0, 2448, 2449, 3, 624, 312, 0, 2449, 2451, 1, 0, 0, 0, 2450, 2447, 1, 0, 0, 0, 2451, 2454, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2452, 2453, 1, 0, 0, 0, 2453, 623, 1, 0, 0, 0, 2454, 2452, 1, 0, 0, 0, 2455, 2456, 5, 174, 0, 0, 2456, 625, 1, 0, 0, 0, 183, 629, 632, 638, 643, 645, 650, 653, 656, 700, 704, 712, 719, 724, 740, 743, 750, 755, 766, 776, 791, 802, 811, 816, 824, 829, 833, 838, 843, 858, 864, 869, 879, 884, 901, 908, 916, 930, 935, 947, 951, 955, 960, 965, 984, 991, 999, 1003, 1008, 1027, 1036, 1051, 1053, 1065, 1079, 1086, 1093, 1101, 1112, 1128, 1147, 1170, 1182, 1198, 1208, 1217, 1236, 1244, 1250, 1255, 1262, 1267, 1275, 1280, 1287, 1292, 1299, 1304, 1311, 1320, 1327, 1334, 1341, 1346, 1353, 1360, 1364, 1367, 1375, 1385, 1396, 1402, 1411, 1424, 1432, 1438, 1443, 1457, 1477, 1486, 1498, 1502, 1506, 1520, 1528, 1537, 1548, 1555, 1558, 1568, 1574, 1592, 1596, 1600, 1605, 1608, 1616, 1621, 1625, 1627, 1630, 1635, 1642, 1645, 1656, 1669, 1676, 1710, 1713, 1729, 1741, 1744, 1757, 1763, 1769, 1773, 1776, 1779, 1797, 1802, 1825, 1837, 1846, 1855, 1859, 1862, 1867, 1870, 1873, 1876, 1879, 1882, 1890, 1897, 1912, 1918, 1927, 1934, 1939, 1943, 1947, 1949, 1969, 2001, 2013, 2025, 2036, 2039, 2072, 2095, 2104, 2107, 2112, 2118, 2122, 2132, 2143, 2159, 2168, 2176, 2180, 2191, 2198, 2452] \ No newline at end of file +[4, 1, 181, 2462, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 1, 0, 4, 0, 636, 8, 0, 11, 0, 12, 0, 637, 1, 0, 3, 0, 641, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 647, 8, 1, 1, 1, 1, 1, 1, 1, 5, 1, 652, 8, 1, 10, 1, 12, 1, 655, 9, 1, 1, 1, 1, 1, 3, 1, 659, 8, 1, 1, 1, 3, 1, 662, 8, 1, 1, 1, 3, 1, 665, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 709, 8, 4, 1, 5, 1, 5, 3, 5, 713, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 721, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 3, 9, 728, 8, 9, 1, 9, 1, 9, 1, 10, 3, 10, 733, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 749, 8, 12, 1, 12, 3, 12, 752, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 759, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 764, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 775, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 785, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 800, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 811, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 820, 8, 16, 1, 17, 1, 17, 1, 17, 3, 17, 825, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 833, 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 838, 8, 18, 1, 18, 1, 18, 3, 18, 842, 8, 18, 1, 19, 1, 19, 1, 19, 3, 19, 847, 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 852, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 865, 8, 20, 10, 20, 12, 20, 868, 9, 20, 1, 21, 1, 21, 1, 21, 3, 21, 873, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 878, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 888, 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 893, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 910, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 917, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 923, 8, 24, 10, 24, 12, 24, 926, 9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 939, 8, 26, 1, 27, 1, 27, 1, 27, 3, 27, 944, 8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 956, 8, 27, 1, 28, 1, 28, 3, 28, 960, 8, 28, 1, 28, 1, 28, 3, 28, 964, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 969, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 974, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 991, 8, 30, 10, 30, 12, 30, 994, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1000, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 1008, 8, 32, 1, 32, 1, 32, 3, 32, 1012, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1017, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1036, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 1043, 8, 34, 10, 34, 12, 34, 1046, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1060, 8, 36, 10, 36, 12, 36, 1063, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1072, 8, 37, 10, 37, 12, 37, 1075, 9, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1088, 8, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, 1095, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1102, 8, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 1110, 8, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1119, 8, 45, 10, 45, 12, 45, 1122, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 5, 47, 1135, 8, 47, 10, 47, 12, 47, 1138, 9, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1156, 8, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1177, 8, 55, 10, 55, 12, 55, 1180, 9, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1189, 8, 57, 10, 57, 12, 57, 1192, 9, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1205, 8, 60, 10, 60, 12, 60, 1208, 9, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1217, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1224, 8, 63, 10, 63, 12, 63, 1227, 9, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1245, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1253, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1259, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1264, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1271, 8, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1276, 8, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1284, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1289, 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1296, 8, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1301, 8, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 3, 70, 1308, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1313, 8, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 3, 71, 1320, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1329, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 1336, 8, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 3, 74, 1343, 8, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 3, 75, 1350, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1355, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1362, 8, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1369, 8, 76, 1, 77, 1, 77, 3, 77, 1373, 8, 77, 1, 77, 3, 77, 1376, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1384, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1392, 8, 79, 10, 79, 12, 79, 1395, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1405, 8, 80, 1, 81, 1, 81, 1, 82, 1, 82, 3, 82, 1411, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 1418, 8, 83, 10, 83, 12, 83, 1421, 9, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 1433, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 5, 87, 1439, 8, 87, 10, 87, 12, 87, 1442, 9, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1447, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1452, 8, 88, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 1466, 8, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 1484, 8, 95, 10, 95, 12, 95, 1487, 9, 95, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 1493, 8, 96, 10, 96, 12, 96, 1496, 9, 96, 1, 97, 1, 97, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 1507, 8, 100, 1, 100, 1, 100, 3, 100, 1511, 8, 100, 1, 101, 1, 101, 3, 101, 1515, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1529, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1535, 8, 103, 10, 103, 12, 103, 1538, 9, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1546, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 3, 107, 1557, 8, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 1564, 8, 108, 1, 108, 3, 108, 1567, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 3, 109, 1577, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1583, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 3, 114, 1601, 8, 114, 1, 114, 1, 114, 3, 114, 1605, 8, 114, 1, 114, 1, 114, 3, 114, 1609, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1614, 8, 114, 1, 114, 3, 114, 1617, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1623, 8, 115, 10, 115, 12, 115, 1626, 9, 115, 1, 116, 1, 116, 3, 116, 1630, 8, 116, 1, 116, 1, 116, 3, 116, 1634, 8, 116, 3, 116, 1636, 8, 116, 1, 117, 3, 117, 1639, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1644, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1651, 8, 117, 1, 117, 3, 117, 1654, 8, 117, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 1663, 8, 119, 10, 119, 12, 119, 1666, 9, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 1676, 8, 121, 10, 121, 12, 121, 1679, 9, 121, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1685, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 1717, 8, 128, 10, 128, 12, 128, 1720, 9, 128, 3, 128, 1722, 8, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1736, 8, 129, 10, 129, 12, 129, 1739, 9, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 1748, 8, 130, 10, 130, 12, 130, 1751, 9, 130, 3, 130, 1753, 8, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1764, 8, 132, 10, 132, 12, 132, 1767, 9, 132, 1, 132, 1, 132, 1, 133, 3, 133, 1772, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1778, 8, 133, 1, 133, 1, 133, 3, 133, 1782, 8, 133, 1, 133, 3, 133, 1785, 8, 133, 1, 133, 3, 133, 1788, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1806, 8, 134, 1, 135, 1, 135, 1, 135, 3, 135, 1811, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1834, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 1844, 8, 142, 10, 142, 12, 142, 1847, 9, 142, 1, 143, 1, 143, 1, 143, 1, 143, 5, 143, 1853, 8, 143, 10, 143, 12, 143, 1856, 9, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1864, 8, 144, 1, 145, 1, 145, 3, 145, 1868, 8, 145, 1, 145, 3, 145, 1871, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1876, 8, 145, 1, 145, 3, 145, 1879, 8, 145, 1, 145, 3, 145, 1882, 8, 145, 1, 145, 3, 145, 1885, 8, 145, 1, 145, 3, 145, 1888, 8, 145, 1, 145, 3, 145, 1891, 8, 145, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 3, 147, 1899, 8, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1906, 8, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 1919, 8, 151, 10, 151, 12, 151, 1922, 9, 151, 1, 152, 1, 152, 1, 152, 3, 152, 1927, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 3, 155, 1936, 8, 155, 1, 155, 1, 155, 1, 155, 5, 155, 1941, 8, 155, 10, 155, 12, 155, 1944, 9, 155, 1, 156, 1, 156, 3, 156, 1948, 8, 156, 1, 156, 1, 156, 3, 156, 1952, 8, 156, 1, 156, 1, 156, 3, 156, 1956, 8, 156, 3, 156, 1958, 8, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 1976, 8, 161, 10, 161, 12, 161, 1979, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2010, 8, 162, 10, 162, 12, 162, 2013, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2022, 8, 162, 10, 162, 12, 162, 2025, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2034, 8, 162, 10, 162, 12, 162, 2037, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2045, 8, 162, 10, 162, 12, 162, 2048, 9, 162, 3, 162, 2050, 8, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2091, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 3, 176, 2110, 8, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 5, 178, 2120, 8, 178, 10, 178, 12, 178, 2123, 9, 178, 1, 179, 1, 179, 1, 179, 3, 179, 2128, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 2137, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2148, 8, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2164, 8, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 2173, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 2181, 8, 189, 1, 190, 1, 190, 3, 190, 2185, 8, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 5, 192, 2194, 8, 192, 10, 192, 12, 192, 2197, 9, 192, 1, 192, 1, 192, 1, 193, 1, 193, 3, 193, 2203, 8, 193, 1, 194, 1, 194, 1, 195, 1, 195, 1, 196, 1, 196, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 207, 1, 207, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 214, 1, 214, 1, 215, 1, 215, 1, 216, 1, 216, 1, 217, 1, 217, 1, 218, 1, 218, 1, 219, 1, 219, 1, 220, 1, 220, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, 1, 224, 1, 224, 1, 225, 1, 225, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, 1, 229, 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, 1, 238, 1, 239, 1, 239, 1, 240, 1, 240, 1, 241, 1, 241, 1, 242, 1, 242, 1, 243, 1, 243, 1, 244, 1, 244, 1, 245, 1, 245, 1, 246, 1, 246, 1, 247, 1, 247, 1, 248, 1, 248, 1, 249, 1, 249, 1, 250, 1, 250, 1, 251, 1, 251, 1, 252, 1, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 262, 1, 262, 1, 263, 1, 263, 1, 264, 1, 264, 1, 265, 1, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 268, 1, 268, 1, 269, 1, 269, 1, 270, 1, 270, 1, 271, 1, 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, 274, 1, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 277, 1, 277, 1, 278, 1, 278, 1, 279, 1, 279, 1, 280, 1, 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 283, 1, 283, 1, 284, 1, 284, 1, 285, 1, 285, 1, 286, 1, 286, 1, 287, 1, 287, 1, 288, 1, 288, 1, 289, 1, 289, 1, 290, 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 293, 1, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 296, 1, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 300, 1, 300, 1, 301, 1, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 306, 1, 306, 1, 307, 1, 307, 1, 308, 1, 308, 1, 309, 1, 309, 1, 310, 1, 310, 1, 311, 1, 311, 1, 312, 1, 312, 1, 313, 1, 313, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 5, 315, 2455, 8, 315, 10, 315, 12, 315, 2458, 9, 315, 1, 316, 1, 316, 1, 316, 0, 0, 317, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 0, 9, 1, 0, 168, 169, 2, 0, 14, 14, 16, 16, 1, 0, 19, 23, 1, 0, 176, 177, 3, 0, 141, 141, 146, 146, 174, 174, 1, 0, 170, 171, 2, 0, 57, 57, 131, 131, 6, 0, 84, 84, 118, 118, 127, 127, 141, 141, 147, 167, 174, 174, 2, 0, 71, 71, 174, 174, 2431, 0, 635, 1, 0, 0, 0, 2, 653, 1, 0, 0, 0, 4, 666, 1, 0, 0, 0, 6, 668, 1, 0, 0, 0, 8, 708, 1, 0, 0, 0, 10, 712, 1, 0, 0, 0, 12, 720, 1, 0, 0, 0, 14, 722, 1, 0, 0, 0, 16, 724, 1, 0, 0, 0, 18, 727, 1, 0, 0, 0, 20, 732, 1, 0, 0, 0, 22, 736, 1, 0, 0, 0, 24, 743, 1, 0, 0, 0, 26, 753, 1, 0, 0, 0, 28, 765, 1, 0, 0, 0, 30, 784, 1, 0, 0, 0, 32, 819, 1, 0, 0, 0, 34, 821, 1, 0, 0, 0, 36, 834, 1, 0, 0, 0, 38, 843, 1, 0, 0, 0, 40, 858, 1, 0, 0, 0, 42, 869, 1, 0, 0, 0, 44, 883, 1, 0, 0, 0, 46, 911, 1, 0, 0, 0, 48, 918, 1, 0, 0, 0, 50, 927, 1, 0, 0, 0, 52, 938, 1, 0, 0, 0, 54, 940, 1, 0, 0, 0, 56, 957, 1, 0, 0, 0, 58, 984, 1, 0, 0, 0, 60, 986, 1, 0, 0, 0, 62, 999, 1, 0, 0, 0, 64, 1005, 1, 0, 0, 0, 66, 1035, 1, 0, 0, 0, 68, 1037, 1, 0, 0, 0, 70, 1049, 1, 0, 0, 0, 72, 1053, 1, 0, 0, 0, 74, 1066, 1, 0, 0, 0, 76, 1078, 1, 0, 0, 0, 78, 1081, 1, 0, 0, 0, 80, 1089, 1, 0, 0, 0, 82, 1094, 1, 0, 0, 0, 84, 1096, 1, 0, 0, 0, 86, 1109, 1, 0, 0, 0, 88, 1111, 1, 0, 0, 0, 90, 1114, 1, 0, 0, 0, 92, 1123, 1, 0, 0, 0, 94, 1127, 1, 0, 0, 0, 96, 1139, 1, 0, 0, 0, 98, 1144, 1, 0, 0, 0, 100, 1155, 1, 0, 0, 0, 102, 1157, 1, 0, 0, 0, 104, 1160, 1, 0, 0, 0, 106, 1165, 1, 0, 0, 0, 108, 1169, 1, 0, 0, 0, 110, 1172, 1, 0, 0, 0, 112, 1181, 1, 0, 0, 0, 114, 1184, 1, 0, 0, 0, 116, 1193, 1, 0, 0, 0, 118, 1197, 1, 0, 0, 0, 120, 1200, 1, 0, 0, 0, 122, 1209, 1, 0, 0, 0, 124, 1212, 1, 0, 0, 0, 126, 1218, 1, 0, 0, 0, 128, 1244, 1, 0, 0, 0, 130, 1246, 1, 0, 0, 0, 132, 1260, 1, 0, 0, 0, 134, 1267, 1, 0, 0, 0, 136, 1279, 1, 0, 0, 0, 138, 1292, 1, 0, 0, 0, 140, 1304, 1, 0, 0, 0, 142, 1316, 1, 0, 0, 0, 144, 1325, 1, 0, 0, 0, 146, 1332, 1, 0, 0, 0, 148, 1339, 1, 0, 0, 0, 150, 1346, 1, 0, 0, 0, 152, 1358, 1, 0, 0, 0, 154, 1370, 1, 0, 0, 0, 156, 1377, 1, 0, 0, 0, 158, 1387, 1, 0, 0, 0, 160, 1404, 1, 0, 0, 0, 162, 1406, 1, 0, 0, 0, 164, 1410, 1, 0, 0, 0, 166, 1412, 1, 0, 0, 0, 168, 1424, 1, 0, 0, 0, 170, 1428, 1, 0, 0, 0, 172, 1432, 1, 0, 0, 0, 174, 1434, 1, 0, 0, 0, 176, 1448, 1, 0, 0, 0, 178, 1453, 1, 0, 0, 0, 180, 1456, 1, 0, 0, 0, 182, 1465, 1, 0, 0, 0, 184, 1467, 1, 0, 0, 0, 186, 1469, 1, 0, 0, 0, 188, 1473, 1, 0, 0, 0, 190, 1479, 1, 0, 0, 0, 192, 1488, 1, 0, 0, 0, 194, 1497, 1, 0, 0, 0, 196, 1499, 1, 0, 0, 0, 198, 1501, 1, 0, 0, 0, 200, 1504, 1, 0, 0, 0, 202, 1514, 1, 0, 0, 0, 204, 1516, 1, 0, 0, 0, 206, 1530, 1, 0, 0, 0, 208, 1545, 1, 0, 0, 0, 210, 1547, 1, 0, 0, 0, 212, 1551, 1, 0, 0, 0, 214, 1554, 1, 0, 0, 0, 216, 1560, 1, 0, 0, 0, 218, 1576, 1, 0, 0, 0, 220, 1582, 1, 0, 0, 0, 222, 1584, 1, 0, 0, 0, 224, 1589, 1, 0, 0, 0, 226, 1594, 1, 0, 0, 0, 228, 1600, 1, 0, 0, 0, 230, 1618, 1, 0, 0, 0, 232, 1635, 1, 0, 0, 0, 234, 1638, 1, 0, 0, 0, 236, 1655, 1, 0, 0, 0, 238, 1658, 1, 0, 0, 0, 240, 1667, 1, 0, 0, 0, 242, 1671, 1, 0, 0, 0, 244, 1684, 1, 0, 0, 0, 246, 1686, 1, 0, 0, 0, 248, 1690, 1, 0, 0, 0, 250, 1696, 1, 0, 0, 0, 252, 1702, 1, 0, 0, 0, 254, 1706, 1, 0, 0, 0, 256, 1711, 1, 0, 0, 0, 258, 1725, 1, 0, 0, 0, 260, 1742, 1, 0, 0, 0, 262, 1756, 1, 0, 0, 0, 264, 1758, 1, 0, 0, 0, 266, 1771, 1, 0, 0, 0, 268, 1805, 1, 0, 0, 0, 270, 1807, 1, 0, 0, 0, 272, 1812, 1, 0, 0, 0, 274, 1815, 1, 0, 0, 0, 276, 1818, 1, 0, 0, 0, 278, 1822, 1, 0, 0, 0, 280, 1833, 1, 0, 0, 0, 282, 1835, 1, 0, 0, 0, 284, 1839, 1, 0, 0, 0, 286, 1848, 1, 0, 0, 0, 288, 1863, 1, 0, 0, 0, 290, 1865, 1, 0, 0, 0, 292, 1892, 1, 0, 0, 0, 294, 1895, 1, 0, 0, 0, 296, 1900, 1, 0, 0, 0, 298, 1905, 1, 0, 0, 0, 300, 1909, 1, 0, 0, 0, 302, 1912, 1, 0, 0, 0, 304, 1923, 1, 0, 0, 0, 306, 1928, 1, 0, 0, 0, 308, 1931, 1, 0, 0, 0, 310, 1935, 1, 0, 0, 0, 312, 1957, 1, 0, 0, 0, 314, 1959, 1, 0, 0, 0, 316, 1961, 1, 0, 0, 0, 318, 1963, 1, 0, 0, 0, 320, 1968, 1, 0, 0, 0, 322, 1971, 1, 0, 0, 0, 324, 2049, 1, 0, 0, 0, 326, 2051, 1, 0, 0, 0, 328, 2053, 1, 0, 0, 0, 330, 2057, 1, 0, 0, 0, 332, 2061, 1, 0, 0, 0, 334, 2065, 1, 0, 0, 0, 336, 2069, 1, 0, 0, 0, 338, 2075, 1, 0, 0, 0, 340, 2079, 1, 0, 0, 0, 342, 2083, 1, 0, 0, 0, 344, 2090, 1, 0, 0, 0, 346, 2092, 1, 0, 0, 0, 348, 2096, 1, 0, 0, 0, 350, 2100, 1, 0, 0, 0, 352, 2106, 1, 0, 0, 0, 354, 2113, 1, 0, 0, 0, 356, 2115, 1, 0, 0, 0, 358, 2127, 1, 0, 0, 0, 360, 2136, 1, 0, 0, 0, 362, 2147, 1, 0, 0, 0, 364, 2149, 1, 0, 0, 0, 366, 2151, 1, 0, 0, 0, 368, 2153, 1, 0, 0, 0, 370, 2155, 1, 0, 0, 0, 372, 2157, 1, 0, 0, 0, 374, 2163, 1, 0, 0, 0, 376, 2172, 1, 0, 0, 0, 378, 2180, 1, 0, 0, 0, 380, 2182, 1, 0, 0, 0, 382, 2186, 1, 0, 0, 0, 384, 2188, 1, 0, 0, 0, 386, 2202, 1, 0, 0, 0, 388, 2204, 1, 0, 0, 0, 390, 2206, 1, 0, 0, 0, 392, 2208, 1, 0, 0, 0, 394, 2210, 1, 0, 0, 0, 396, 2212, 1, 0, 0, 0, 398, 2214, 1, 0, 0, 0, 400, 2216, 1, 0, 0, 0, 402, 2218, 1, 0, 0, 0, 404, 2220, 1, 0, 0, 0, 406, 2222, 1, 0, 0, 0, 408, 2224, 1, 0, 0, 0, 410, 2226, 1, 0, 0, 0, 412, 2229, 1, 0, 0, 0, 414, 2231, 1, 0, 0, 0, 416, 2233, 1, 0, 0, 0, 418, 2235, 1, 0, 0, 0, 420, 2237, 1, 0, 0, 0, 422, 2240, 1, 0, 0, 0, 424, 2242, 1, 0, 0, 0, 426, 2244, 1, 0, 0, 0, 428, 2246, 1, 0, 0, 0, 430, 2248, 1, 0, 0, 0, 432, 2250, 1, 0, 0, 0, 434, 2252, 1, 0, 0, 0, 436, 2254, 1, 0, 0, 0, 438, 2256, 1, 0, 0, 0, 440, 2258, 1, 0, 0, 0, 442, 2260, 1, 0, 0, 0, 444, 2262, 1, 0, 0, 0, 446, 2264, 1, 0, 0, 0, 448, 2266, 1, 0, 0, 0, 450, 2268, 1, 0, 0, 0, 452, 2270, 1, 0, 0, 0, 454, 2272, 1, 0, 0, 0, 456, 2274, 1, 0, 0, 0, 458, 2276, 1, 0, 0, 0, 460, 2278, 1, 0, 0, 0, 462, 2280, 1, 0, 0, 0, 464, 2282, 1, 0, 0, 0, 466, 2284, 1, 0, 0, 0, 468, 2286, 1, 0, 0, 0, 470, 2288, 1, 0, 0, 0, 472, 2290, 1, 0, 0, 0, 474, 2292, 1, 0, 0, 0, 476, 2294, 1, 0, 0, 0, 478, 2296, 1, 0, 0, 0, 480, 2298, 1, 0, 0, 0, 482, 2300, 1, 0, 0, 0, 484, 2302, 1, 0, 0, 0, 486, 2304, 1, 0, 0, 0, 488, 2306, 1, 0, 0, 0, 490, 2308, 1, 0, 0, 0, 492, 2310, 1, 0, 0, 0, 494, 2312, 1, 0, 0, 0, 496, 2314, 1, 0, 0, 0, 498, 2316, 1, 0, 0, 0, 500, 2318, 1, 0, 0, 0, 502, 2320, 1, 0, 0, 0, 504, 2322, 1, 0, 0, 0, 506, 2324, 1, 0, 0, 0, 508, 2326, 1, 0, 0, 0, 510, 2328, 1, 0, 0, 0, 512, 2330, 1, 0, 0, 0, 514, 2332, 1, 0, 0, 0, 516, 2334, 1, 0, 0, 0, 518, 2336, 1, 0, 0, 0, 520, 2338, 1, 0, 0, 0, 522, 2340, 1, 0, 0, 0, 524, 2342, 1, 0, 0, 0, 526, 2344, 1, 0, 0, 0, 528, 2346, 1, 0, 0, 0, 530, 2348, 1, 0, 0, 0, 532, 2350, 1, 0, 0, 0, 534, 2352, 1, 0, 0, 0, 536, 2354, 1, 0, 0, 0, 538, 2356, 1, 0, 0, 0, 540, 2358, 1, 0, 0, 0, 542, 2360, 1, 0, 0, 0, 544, 2362, 1, 0, 0, 0, 546, 2364, 1, 0, 0, 0, 548, 2366, 1, 0, 0, 0, 550, 2368, 1, 0, 0, 0, 552, 2370, 1, 0, 0, 0, 554, 2372, 1, 0, 0, 0, 556, 2374, 1, 0, 0, 0, 558, 2376, 1, 0, 0, 0, 560, 2378, 1, 0, 0, 0, 562, 2380, 1, 0, 0, 0, 564, 2382, 1, 0, 0, 0, 566, 2384, 1, 0, 0, 0, 568, 2386, 1, 0, 0, 0, 570, 2388, 1, 0, 0, 0, 572, 2390, 1, 0, 0, 0, 574, 2392, 1, 0, 0, 0, 576, 2394, 1, 0, 0, 0, 578, 2396, 1, 0, 0, 0, 580, 2398, 1, 0, 0, 0, 582, 2400, 1, 0, 0, 0, 584, 2402, 1, 0, 0, 0, 586, 2404, 1, 0, 0, 0, 588, 2406, 1, 0, 0, 0, 590, 2408, 1, 0, 0, 0, 592, 2410, 1, 0, 0, 0, 594, 2412, 1, 0, 0, 0, 596, 2414, 1, 0, 0, 0, 598, 2416, 1, 0, 0, 0, 600, 2418, 1, 0, 0, 0, 602, 2420, 1, 0, 0, 0, 604, 2422, 1, 0, 0, 0, 606, 2424, 1, 0, 0, 0, 608, 2426, 1, 0, 0, 0, 610, 2428, 1, 0, 0, 0, 612, 2430, 1, 0, 0, 0, 614, 2432, 1, 0, 0, 0, 616, 2434, 1, 0, 0, 0, 618, 2436, 1, 0, 0, 0, 620, 2438, 1, 0, 0, 0, 622, 2440, 1, 0, 0, 0, 624, 2442, 1, 0, 0, 0, 626, 2444, 1, 0, 0, 0, 628, 2446, 1, 0, 0, 0, 630, 2448, 1, 0, 0, 0, 632, 2459, 1, 0, 0, 0, 634, 636, 3, 2, 1, 0, 635, 634, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 640, 1, 0, 0, 0, 639, 641, 5, 15, 0, 0, 640, 639, 1, 0, 0, 0, 640, 641, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 643, 5, 0, 0, 1, 643, 1, 1, 0, 0, 0, 644, 646, 3, 8, 4, 0, 645, 647, 5, 15, 0, 0, 646, 645, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 649, 3, 4, 2, 0, 649, 652, 1, 0, 0, 0, 650, 652, 3, 6, 3, 0, 651, 644, 1, 0, 0, 0, 651, 650, 1, 0, 0, 0, 652, 655, 1, 0, 0, 0, 653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 664, 1, 0, 0, 0, 655, 653, 1, 0, 0, 0, 656, 661, 3, 8, 4, 0, 657, 659, 5, 15, 0, 0, 658, 657, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 660, 1, 0, 0, 0, 660, 662, 3, 4, 2, 0, 661, 658, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 665, 1, 0, 0, 0, 663, 665, 3, 6, 3, 0, 664, 656, 1, 0, 0, 0, 664, 663, 1, 0, 0, 0, 665, 3, 1, 0, 0, 0, 666, 667, 5, 8, 0, 0, 667, 5, 1, 0, 0, 0, 668, 669, 3, 4, 2, 0, 669, 7, 1, 0, 0, 0, 670, 709, 3, 204, 102, 0, 671, 709, 3, 130, 65, 0, 672, 709, 3, 124, 62, 0, 673, 709, 3, 98, 49, 0, 674, 709, 3, 84, 42, 0, 675, 709, 3, 78, 39, 0, 676, 709, 3, 198, 99, 0, 677, 709, 3, 64, 32, 0, 678, 709, 3, 56, 28, 0, 679, 709, 3, 216, 108, 0, 680, 709, 3, 54, 27, 0, 681, 709, 3, 44, 22, 0, 682, 709, 3, 36, 18, 0, 683, 709, 3, 152, 76, 0, 684, 709, 3, 42, 21, 0, 685, 709, 3, 38, 19, 0, 686, 709, 3, 34, 17, 0, 687, 709, 3, 228, 114, 0, 688, 709, 3, 138, 69, 0, 689, 709, 3, 140, 70, 0, 690, 709, 3, 150, 75, 0, 691, 709, 3, 148, 74, 0, 692, 709, 3, 136, 68, 0, 693, 709, 3, 144, 72, 0, 694, 709, 3, 146, 73, 0, 695, 709, 3, 142, 71, 0, 696, 709, 3, 134, 67, 0, 697, 709, 3, 132, 66, 0, 698, 709, 3, 28, 14, 0, 699, 709, 3, 266, 133, 0, 700, 709, 3, 26, 13, 0, 701, 709, 3, 24, 12, 0, 702, 709, 3, 22, 11, 0, 703, 709, 3, 290, 145, 0, 704, 709, 3, 214, 107, 0, 705, 709, 3, 234, 117, 0, 706, 709, 3, 212, 106, 0, 707, 709, 3, 10, 5, 0, 708, 670, 1, 0, 0, 0, 708, 671, 1, 0, 0, 0, 708, 672, 1, 0, 0, 0, 708, 673, 1, 0, 0, 0, 708, 674, 1, 0, 0, 0, 708, 675, 1, 0, 0, 0, 708, 676, 1, 0, 0, 0, 708, 677, 1, 0, 0, 0, 708, 678, 1, 0, 0, 0, 708, 679, 1, 0, 0, 0, 708, 680, 1, 0, 0, 0, 708, 681, 1, 0, 0, 0, 708, 682, 1, 0, 0, 0, 708, 683, 1, 0, 0, 0, 708, 684, 1, 0, 0, 0, 708, 685, 1, 0, 0, 0, 708, 686, 1, 0, 0, 0, 708, 687, 1, 0, 0, 0, 708, 688, 1, 0, 0, 0, 708, 689, 1, 0, 0, 0, 708, 690, 1, 0, 0, 0, 708, 691, 1, 0, 0, 0, 708, 692, 1, 0, 0, 0, 708, 693, 1, 0, 0, 0, 708, 694, 1, 0, 0, 0, 708, 695, 1, 0, 0, 0, 708, 696, 1, 0, 0, 0, 708, 697, 1, 0, 0, 0, 708, 698, 1, 0, 0, 0, 708, 699, 1, 0, 0, 0, 708, 700, 1, 0, 0, 0, 708, 701, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 703, 1, 0, 0, 0, 708, 704, 1, 0, 0, 0, 708, 705, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 708, 707, 1, 0, 0, 0, 709, 9, 1, 0, 0, 0, 710, 713, 3, 456, 228, 0, 711, 713, 3, 458, 229, 0, 712, 710, 1, 0, 0, 0, 712, 711, 1, 0, 0, 0, 713, 714, 1, 0, 0, 0, 714, 715, 3, 12, 6, 0, 715, 11, 1, 0, 0, 0, 716, 721, 3, 14, 7, 0, 717, 721, 3, 16, 8, 0, 718, 721, 3, 18, 9, 0, 719, 721, 3, 20, 10, 0, 720, 716, 1, 0, 0, 0, 720, 717, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 719, 1, 0, 0, 0, 721, 13, 1, 0, 0, 0, 722, 723, 3, 510, 255, 0, 723, 15, 1, 0, 0, 0, 724, 725, 3, 574, 287, 0, 725, 17, 1, 0, 0, 0, 726, 728, 3, 572, 286, 0, 727, 726, 1, 0, 0, 0, 727, 728, 1, 0, 0, 0, 728, 729, 1, 0, 0, 0, 729, 730, 3, 298, 149, 0, 730, 19, 1, 0, 0, 0, 731, 733, 3, 508, 254, 0, 732, 731, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, 735, 3, 374, 187, 0, 735, 21, 1, 0, 0, 0, 736, 737, 3, 606, 303, 0, 737, 738, 3, 30, 15, 0, 738, 739, 3, 536, 268, 0, 739, 740, 3, 32, 16, 0, 740, 741, 3, 476, 238, 0, 741, 742, 3, 388, 194, 0, 742, 23, 1, 0, 0, 0, 743, 744, 3, 516, 258, 0, 744, 748, 3, 558, 279, 0, 745, 746, 3, 534, 267, 0, 746, 747, 3, 388, 194, 0, 747, 749, 1, 0, 0, 0, 748, 745, 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, 749, 751, 1, 0, 0, 0, 750, 752, 3, 528, 264, 0, 751, 750, 1, 0, 0, 0, 751, 752, 1, 0, 0, 0, 752, 25, 1, 0, 0, 0, 753, 754, 3, 516, 258, 0, 754, 758, 3, 30, 15, 0, 755, 756, 3, 536, 268, 0, 756, 757, 3, 32, 16, 0, 757, 759, 1, 0, 0, 0, 758, 755, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 763, 1, 0, 0, 0, 760, 761, 3, 534, 267, 0, 761, 762, 3, 388, 194, 0, 762, 764, 1, 0, 0, 0, 763, 760, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 27, 1, 0, 0, 0, 765, 766, 3, 484, 242, 0, 766, 767, 3, 30, 15, 0, 767, 768, 3, 536, 268, 0, 768, 769, 3, 32, 16, 0, 769, 770, 3, 578, 289, 0, 770, 771, 3, 388, 194, 0, 771, 29, 1, 0, 0, 0, 772, 775, 3, 418, 209, 0, 773, 775, 3, 420, 210, 0, 774, 772, 1, 0, 0, 0, 774, 773, 1, 0, 0, 0, 775, 785, 1, 0, 0, 0, 776, 785, 3, 424, 212, 0, 777, 785, 3, 434, 217, 0, 778, 785, 3, 458, 229, 0, 779, 785, 3, 468, 234, 0, 780, 785, 3, 452, 226, 0, 781, 785, 3, 462, 231, 0, 782, 785, 3, 524, 262, 0, 783, 785, 3, 560, 280, 0, 784, 774, 1, 0, 0, 0, 784, 776, 1, 0, 0, 0, 784, 777, 1, 0, 0, 0, 784, 778, 1, 0, 0, 0, 784, 779, 1, 0, 0, 0, 784, 780, 1, 0, 0, 0, 784, 781, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, 783, 1, 0, 0, 0, 785, 31, 1, 0, 0, 0, 786, 787, 3, 418, 209, 0, 787, 788, 3, 482, 241, 0, 788, 820, 1, 0, 0, 0, 789, 790, 3, 418, 209, 0, 790, 791, 3, 482, 241, 0, 791, 792, 3, 488, 244, 0, 792, 793, 3, 508, 254, 0, 793, 794, 3, 374, 187, 0, 794, 820, 1, 0, 0, 0, 795, 799, 3, 480, 240, 0, 796, 797, 3, 374, 187, 0, 797, 798, 5, 10, 0, 0, 798, 800, 1, 0, 0, 0, 799, 796, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 801, 1, 0, 0, 0, 801, 802, 3, 400, 200, 0, 802, 820, 1, 0, 0, 0, 803, 804, 3, 418, 209, 0, 804, 805, 3, 510, 255, 0, 805, 820, 1, 0, 0, 0, 806, 807, 3, 508, 254, 0, 807, 808, 3, 374, 187, 0, 808, 820, 1, 0, 0, 0, 809, 811, 3, 572, 286, 0, 810, 809, 1, 0, 0, 0, 810, 811, 1, 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 820, 3, 298, 149, 0, 813, 814, 3, 418, 209, 0, 814, 815, 3, 558, 279, 0, 815, 820, 1, 0, 0, 0, 816, 817, 3, 556, 278, 0, 817, 818, 3, 388, 194, 0, 818, 820, 1, 0, 0, 0, 819, 786, 1, 0, 0, 0, 819, 789, 1, 0, 0, 0, 819, 795, 1, 0, 0, 0, 819, 803, 1, 0, 0, 0, 819, 806, 1, 0, 0, 0, 819, 810, 1, 0, 0, 0, 819, 813, 1, 0, 0, 0, 819, 816, 1, 0, 0, 0, 820, 33, 1, 0, 0, 0, 821, 822, 3, 452, 226, 0, 822, 824, 3, 594, 297, 0, 823, 825, 3, 276, 138, 0, 824, 823, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 826, 827, 3, 404, 202, 0, 827, 828, 3, 604, 302, 0, 828, 829, 3, 544, 272, 0, 829, 832, 3, 368, 184, 0, 830, 833, 3, 570, 285, 0, 831, 833, 3, 526, 263, 0, 832, 830, 1, 0, 0, 0, 832, 831, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 35, 1, 0, 0, 0, 834, 835, 3, 452, 226, 0, 835, 837, 3, 556, 278, 0, 836, 838, 3, 276, 138, 0, 837, 836, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 841, 3, 388, 194, 0, 840, 842, 3, 126, 63, 0, 841, 840, 1, 0, 0, 0, 841, 842, 1, 0, 0, 0, 842, 37, 1, 0, 0, 0, 843, 844, 3, 452, 226, 0, 844, 846, 3, 586, 293, 0, 845, 847, 3, 276, 138, 0, 846, 845, 1, 0, 0, 0, 846, 847, 1, 0, 0, 0, 847, 851, 1, 0, 0, 0, 848, 849, 3, 374, 187, 0, 849, 850, 5, 10, 0, 0, 850, 852, 1, 0, 0, 0, 851, 848, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0, 852, 853, 1, 0, 0, 0, 853, 854, 3, 396, 198, 0, 854, 855, 3, 610, 305, 0, 855, 856, 3, 40, 20, 0, 856, 857, 3, 612, 306, 0, 857, 39, 1, 0, 0, 0, 858, 859, 3, 378, 189, 0, 859, 866, 3, 380, 190, 0, 860, 861, 3, 626, 313, 0, 861, 862, 3, 378, 189, 0, 862, 863, 3, 380, 190, 0, 863, 865, 1, 0, 0, 0, 864, 860, 1, 0, 0, 0, 865, 868, 1, 0, 0, 0, 866, 864, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 41, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0, 869, 870, 3, 452, 226, 0, 870, 872, 3, 580, 290, 0, 871, 873, 3, 276, 138, 0, 872, 871, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 877, 1, 0, 0, 0, 874, 875, 3, 374, 187, 0, 875, 876, 5, 10, 0, 0, 876, 878, 1, 0, 0, 0, 877, 874, 1, 0, 0, 0, 877, 878, 1, 0, 0, 0, 878, 879, 1, 0, 0, 0, 879, 880, 3, 390, 195, 0, 880, 881, 3, 596, 298, 0, 881, 882, 3, 392, 196, 0, 882, 43, 1, 0, 0, 0, 883, 884, 3, 452, 226, 0, 884, 885, 3, 522, 261, 0, 885, 887, 3, 600, 300, 0, 886, 888, 3, 276, 138, 0, 887, 886, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 892, 1, 0, 0, 0, 889, 890, 3, 374, 187, 0, 890, 891, 5, 10, 0, 0, 891, 893, 1, 0, 0, 0, 892, 889, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 895, 3, 394, 197, 0, 895, 896, 3, 430, 215, 0, 896, 897, 3, 560, 280, 0, 897, 898, 3, 284, 142, 0, 898, 899, 3, 476, 238, 0, 899, 900, 3, 298, 149, 0, 900, 901, 3, 46, 23, 0, 901, 902, 3, 546, 273, 0, 902, 903, 3, 504, 252, 0, 903, 904, 3, 610, 305, 0, 904, 905, 3, 284, 142, 0, 905, 909, 3, 612, 306, 0, 906, 907, 3, 604, 302, 0, 907, 908, 3, 52, 26, 0, 908, 910, 1, 0, 0, 0, 909, 906, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 45, 1, 0, 0, 0, 911, 912, 3, 602, 301, 0, 912, 916, 3, 48, 24, 0, 913, 914, 3, 426, 213, 0, 914, 915, 3, 322, 161, 0, 915, 917, 1, 0, 0, 0, 916, 913, 1, 0, 0, 0, 916, 917, 1, 0, 0, 0, 917, 47, 1, 0, 0, 0, 918, 924, 3, 50, 25, 0, 919, 920, 3, 426, 213, 0, 920, 921, 3, 50, 25, 0, 921, 923, 1, 0, 0, 0, 922, 919, 1, 0, 0, 0, 923, 926, 1, 0, 0, 0, 924, 922, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 49, 1, 0, 0, 0, 926, 924, 1, 0, 0, 0, 927, 928, 3, 378, 189, 0, 928, 929, 3, 500, 250, 0, 929, 930, 3, 530, 265, 0, 930, 931, 3, 532, 266, 0, 931, 51, 1, 0, 0, 0, 932, 939, 3, 158, 79, 0, 933, 934, 3, 158, 79, 0, 934, 935, 3, 426, 213, 0, 935, 936, 3, 156, 78, 0, 936, 939, 1, 0, 0, 0, 937, 939, 3, 156, 78, 0, 938, 932, 1, 0, 0, 0, 938, 933, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 53, 1, 0, 0, 0, 940, 941, 3, 452, 226, 0, 941, 943, 3, 508, 254, 0, 942, 944, 3, 276, 138, 0, 943, 942, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 3, 374, 187, 0, 946, 947, 3, 604, 302, 0, 947, 948, 3, 552, 276, 0, 948, 949, 5, 19, 0, 0, 949, 950, 3, 614, 307, 0, 950, 951, 3, 206, 103, 0, 951, 955, 3, 616, 308, 0, 952, 953, 3, 426, 213, 0, 953, 954, 3, 210, 105, 0, 954, 956, 1, 0, 0, 0, 955, 952, 1, 0, 0, 0, 955, 956, 1, 0, 0, 0, 956, 55, 1, 0, 0, 0, 957, 959, 3, 452, 226, 0, 958, 960, 3, 76, 38, 0, 959, 958, 1, 0, 0, 0, 959, 960, 1, 0, 0, 0, 960, 961, 1, 0, 0, 0, 961, 963, 3, 480, 240, 0, 962, 964, 3, 276, 138, 0, 963, 962, 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 968, 1, 0, 0, 0, 965, 966, 3, 374, 187, 0, 966, 967, 5, 10, 0, 0, 967, 969, 1, 0, 0, 0, 968, 965, 1, 0, 0, 0, 968, 969, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 971, 3, 400, 200, 0, 971, 973, 3, 610, 305, 0, 972, 974, 3, 60, 30, 0, 973, 972, 1, 0, 0, 0, 973, 974, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 3, 612, 306, 0, 976, 977, 3, 62, 31, 0, 977, 978, 3, 554, 277, 0, 978, 979, 3, 380, 190, 0, 979, 980, 3, 512, 256, 0, 980, 981, 3, 402, 201, 0, 981, 982, 3, 430, 215, 0, 982, 983, 3, 58, 29, 0, 983, 57, 1, 0, 0, 0, 984, 985, 7, 0, 0, 0, 985, 59, 1, 0, 0, 0, 986, 992, 3, 410, 205, 0, 987, 988, 3, 626, 313, 0, 988, 989, 3, 410, 205, 0, 989, 991, 1, 0, 0, 0, 990, 987, 1, 0, 0, 0, 991, 994, 1, 0, 0, 0, 992, 990, 1, 0, 0, 0, 992, 993, 1, 0, 0, 0, 993, 61, 1, 0, 0, 0, 994, 992, 1, 0, 0, 0, 995, 1000, 3, 444, 222, 0, 996, 997, 3, 554, 277, 0, 997, 998, 3, 532, 266, 0, 998, 1000, 1, 0, 0, 0, 999, 995, 1, 0, 0, 0, 999, 996, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 3, 536, 268, 0, 1002, 1003, 3, 532, 266, 0, 1003, 1004, 3, 494, 247, 0, 1004, 63, 1, 0, 0, 0, 1005, 1007, 3, 452, 226, 0, 1006, 1008, 3, 76, 38, 0, 1007, 1006, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 3, 416, 208, 0, 1010, 1012, 3, 276, 138, 0, 1011, 1010, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, 0, 1012, 1016, 1, 0, 0, 0, 1013, 1014, 3, 374, 187, 0, 1014, 1015, 5, 10, 0, 0, 1015, 1017, 1, 0, 0, 0, 1016, 1013, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1019, 3, 398, 199, 0, 1019, 1020, 3, 610, 305, 0, 1020, 1021, 3, 380, 190, 0, 1021, 1022, 3, 612, 306, 0, 1022, 1023, 3, 564, 282, 0, 1023, 1024, 3, 400, 200, 0, 1024, 1025, 3, 568, 284, 0, 1025, 1026, 3, 380, 190, 0, 1026, 1027, 3, 474, 237, 0, 1027, 1028, 3, 400, 200, 0, 1028, 1029, 3, 492, 246, 0, 1029, 1030, 3, 66, 33, 0, 1030, 65, 1, 0, 0, 0, 1031, 1036, 3, 362, 181, 0, 1032, 1036, 3, 74, 37, 0, 1033, 1036, 3, 72, 36, 0, 1034, 1036, 3, 68, 34, 0, 1035, 1031, 1, 0, 0, 0, 1035, 1032, 1, 0, 0, 0, 1035, 1033, 1, 0, 0, 0, 1035, 1034, 1, 0, 0, 0, 1036, 67, 1, 0, 0, 0, 1037, 1038, 3, 614, 307, 0, 1038, 1044, 3, 70, 35, 0, 1039, 1040, 3, 626, 313, 0, 1040, 1041, 3, 70, 35, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1039, 1, 0, 0, 0, 1043, 1046, 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1047, 1, 0, 0, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1048, 3, 616, 308, 0, 1048, 69, 1, 0, 0, 0, 1049, 1050, 3, 408, 204, 0, 1050, 1051, 5, 9, 0, 0, 1051, 1052, 3, 66, 33, 0, 1052, 71, 1, 0, 0, 0, 1053, 1054, 3, 610, 305, 0, 1054, 1061, 3, 74, 37, 0, 1055, 1056, 3, 626, 313, 0, 1056, 1057, 3, 362, 181, 0, 1057, 1060, 1, 0, 0, 0, 1058, 1060, 3, 74, 37, 0, 1059, 1055, 1, 0, 0, 0, 1059, 1058, 1, 0, 0, 0, 1060, 1063, 1, 0, 0, 0, 1061, 1059, 1, 0, 0, 0, 1061, 1062, 1, 0, 0, 0, 1062, 1064, 1, 0, 0, 0, 1063, 1061, 1, 0, 0, 0, 1064, 1065, 3, 612, 306, 0, 1065, 73, 1, 0, 0, 0, 1066, 1067, 3, 610, 305, 0, 1067, 1073, 3, 362, 181, 0, 1068, 1069, 3, 626, 313, 0, 1069, 1070, 3, 362, 181, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1068, 1, 0, 0, 0, 1072, 1075, 1, 0, 0, 0, 1073, 1071, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1076, 1, 0, 0, 0, 1075, 1073, 1, 0, 0, 0, 1076, 1077, 3, 612, 306, 0, 1077, 75, 1, 0, 0, 0, 1078, 1079, 3, 540, 270, 0, 1079, 1080, 3, 550, 275, 0, 1080, 77, 1, 0, 0, 0, 1081, 1082, 3, 424, 212, 0, 1082, 1083, 3, 594, 297, 0, 1083, 1084, 3, 404, 202, 0, 1084, 1085, 3, 604, 302, 0, 1085, 1087, 3, 80, 40, 0, 1086, 1088, 3, 82, 41, 0, 1087, 1086, 1, 0, 0, 0, 1087, 1088, 1, 0, 0, 0, 1088, 79, 1, 0, 0, 0, 1089, 1090, 3, 544, 272, 0, 1090, 1091, 3, 368, 184, 0, 1091, 81, 1, 0, 0, 0, 1092, 1095, 3, 570, 285, 0, 1093, 1095, 3, 526, 263, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1093, 1, 0, 0, 0, 1095, 83, 1, 0, 0, 0, 1096, 1097, 3, 424, 212, 0, 1097, 1101, 3, 586, 293, 0, 1098, 1099, 3, 374, 187, 0, 1099, 1100, 5, 10, 0, 0, 1100, 1102, 1, 0, 0, 0, 1101, 1098, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1102, 1103, 1, 0, 0, 0, 1103, 1104, 3, 396, 198, 0, 1104, 1105, 3, 86, 43, 0, 1105, 85, 1, 0, 0, 0, 1106, 1110, 3, 96, 48, 0, 1107, 1110, 3, 94, 47, 0, 1108, 1110, 3, 88, 44, 0, 1109, 1106, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1109, 1108, 1, 0, 0, 0, 1110, 87, 1, 0, 0, 0, 1111, 1112, 3, 548, 274, 0, 1112, 1113, 3, 90, 45, 0, 1113, 89, 1, 0, 0, 0, 1114, 1120, 3, 92, 46, 0, 1115, 1116, 3, 426, 213, 0, 1116, 1117, 3, 92, 46, 0, 1117, 1119, 1, 0, 0, 0, 1118, 1115, 1, 0, 0, 0, 1119, 1122, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 91, 1, 0, 0, 0, 1122, 1120, 1, 0, 0, 0, 1123, 1124, 3, 378, 189, 0, 1124, 1125, 3, 578, 289, 0, 1125, 1126, 3, 378, 189, 0, 1126, 93, 1, 0, 0, 0, 1127, 1128, 3, 414, 207, 0, 1128, 1129, 3, 378, 189, 0, 1129, 1136, 3, 380, 190, 0, 1130, 1131, 3, 626, 313, 0, 1131, 1132, 3, 378, 189, 0, 1132, 1133, 3, 380, 190, 0, 1133, 1135, 1, 0, 0, 0, 1134, 1130, 1, 0, 0, 0, 1135, 1138, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 95, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1139, 1140, 3, 424, 212, 0, 1140, 1141, 3, 378, 189, 0, 1141, 1142, 3, 586, 293, 0, 1142, 1143, 3, 380, 190, 0, 1143, 97, 1, 0, 0, 0, 1144, 1145, 3, 424, 212, 0, 1145, 1146, 3, 572, 286, 0, 1146, 1147, 3, 298, 149, 0, 1147, 1148, 3, 100, 50, 0, 1148, 99, 1, 0, 0, 0, 1149, 1156, 3, 118, 59, 0, 1150, 1156, 3, 108, 54, 0, 1151, 1156, 3, 106, 53, 0, 1152, 1156, 3, 112, 56, 0, 1153, 1156, 3, 104, 52, 0, 1154, 1156, 3, 102, 51, 0, 1155, 1149, 1, 0, 0, 0, 1155, 1150, 1, 0, 0, 0, 1155, 1151, 1, 0, 0, 0, 1155, 1152, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 101, 1, 0, 0, 0, 1157, 1158, 3, 604, 302, 0, 1158, 1159, 3, 158, 79, 0, 1159, 103, 1, 0, 0, 0, 1160, 1161, 3, 548, 274, 0, 1161, 1162, 3, 378, 189, 0, 1162, 1163, 3, 578, 289, 0, 1163, 1164, 3, 378, 189, 0, 1164, 105, 1, 0, 0, 0, 1165, 1166, 3, 462, 231, 0, 1166, 1167, 3, 448, 224, 0, 1167, 1168, 3, 566, 283, 0, 1168, 107, 1, 0, 0, 0, 1169, 1170, 3, 462, 231, 0, 1170, 1171, 3, 110, 55, 0, 1171, 109, 1, 0, 0, 0, 1172, 1178, 3, 378, 189, 0, 1173, 1174, 3, 626, 313, 0, 1174, 1175, 3, 378, 189, 0, 1175, 1177, 1, 0, 0, 0, 1176, 1173, 1, 0, 0, 0, 1177, 1180, 1, 0, 0, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 111, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1181, 1182, 3, 424, 212, 0, 1182, 1183, 3, 114, 57, 0, 1183, 113, 1, 0, 0, 0, 1184, 1190, 3, 116, 58, 0, 1185, 1186, 3, 626, 313, 0, 1186, 1187, 3, 116, 58, 0, 1187, 1189, 1, 0, 0, 0, 1188, 1185, 1, 0, 0, 0, 1189, 1192, 1, 0, 0, 0, 1190, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 115, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1193, 1194, 3, 378, 189, 0, 1194, 1195, 3, 586, 293, 0, 1195, 1196, 3, 380, 190, 0, 1196, 117, 1, 0, 0, 0, 1197, 1198, 3, 414, 207, 0, 1198, 1199, 3, 120, 60, 0, 1199, 119, 1, 0, 0, 0, 1200, 1206, 3, 122, 61, 0, 1201, 1202, 3, 626, 313, 0, 1202, 1203, 3, 122, 61, 0, 1203, 1205, 1, 0, 0, 0, 1204, 1201, 1, 0, 0, 0, 1205, 1208, 1, 0, 0, 0, 1206, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 121, 1, 0, 0, 0, 1208, 1206, 1, 0, 0, 0, 1209, 1210, 3, 378, 189, 0, 1210, 1211, 3, 380, 190, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 424, 212, 0, 1213, 1214, 3, 556, 278, 0, 1214, 1216, 3, 388, 194, 0, 1215, 1217, 3, 126, 63, 0, 1216, 1215, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 125, 1, 0, 0, 0, 1218, 1219, 3, 604, 302, 0, 1219, 1225, 3, 128, 64, 0, 1220, 1221, 3, 426, 213, 0, 1221, 1222, 3, 128, 64, 0, 1222, 1224, 1, 0, 0, 0, 1223, 1220, 1, 0, 0, 0, 1224, 1227, 1, 0, 0, 0, 1225, 1223, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 127, 1, 0, 0, 0, 1227, 1225, 1, 0, 0, 0, 1228, 1229, 3, 544, 272, 0, 1229, 1230, 5, 19, 0, 0, 1230, 1231, 3, 368, 184, 0, 1231, 1245, 1, 0, 0, 0, 1232, 1233, 3, 520, 260, 0, 1233, 1234, 5, 19, 0, 0, 1234, 1235, 3, 370, 185, 0, 1235, 1245, 1, 0, 0, 0, 1236, 1237, 3, 570, 285, 0, 1237, 1238, 5, 19, 0, 0, 1238, 1239, 3, 370, 185, 0, 1239, 1245, 1, 0, 0, 0, 1240, 1241, 3, 538, 269, 0, 1241, 1242, 5, 19, 0, 0, 1242, 1243, 3, 166, 83, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1228, 1, 0, 0, 0, 1244, 1232, 1, 0, 0, 0, 1244, 1236, 1, 0, 0, 0, 1244, 1240, 1, 0, 0, 0, 1245, 129, 1, 0, 0, 0, 1246, 1247, 3, 424, 212, 0, 1247, 1248, 3, 522, 261, 0, 1248, 1252, 3, 600, 300, 0, 1249, 1250, 3, 374, 187, 0, 1250, 1251, 5, 10, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, 1249, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1258, 3, 394, 197, 0, 1255, 1256, 3, 604, 302, 0, 1256, 1257, 3, 158, 79, 0, 1257, 1259, 1, 0, 0, 0, 1258, 1255, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 131, 1, 0, 0, 0, 1260, 1261, 3, 462, 231, 0, 1261, 1263, 3, 594, 297, 0, 1262, 1264, 3, 278, 139, 0, 1263, 1262, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1266, 3, 404, 202, 0, 1266, 133, 1, 0, 0, 0, 1267, 1268, 3, 462, 231, 0, 1268, 1270, 3, 586, 293, 0, 1269, 1271, 3, 278, 139, 0, 1270, 1269, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, 1275, 1, 0, 0, 0, 1272, 1273, 3, 374, 187, 0, 1273, 1274, 5, 10, 0, 0, 1274, 1276, 1, 0, 0, 0, 1275, 1272, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 1278, 3, 396, 198, 0, 1278, 135, 1, 0, 0, 0, 1279, 1280, 3, 462, 231, 0, 1280, 1281, 3, 522, 261, 0, 1281, 1283, 3, 600, 300, 0, 1282, 1284, 3, 278, 139, 0, 1283, 1282, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1288, 1, 0, 0, 0, 1285, 1286, 3, 374, 187, 0, 1286, 1287, 5, 10, 0, 0, 1287, 1289, 1, 0, 0, 0, 1288, 1285, 1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1291, 3, 394, 197, 0, 1291, 137, 1, 0, 0, 0, 1292, 1293, 3, 462, 231, 0, 1293, 1295, 3, 416, 208, 0, 1294, 1296, 3, 278, 139, 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1300, 1, 0, 0, 0, 1297, 1298, 3, 374, 187, 0, 1298, 1299, 5, 10, 0, 0, 1299, 1301, 1, 0, 0, 0, 1300, 1297, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1303, 3, 398, 199, 0, 1303, 139, 1, 0, 0, 0, 1304, 1305, 3, 462, 231, 0, 1305, 1307, 3, 480, 240, 0, 1306, 1308, 3, 278, 139, 0, 1307, 1306, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1312, 1, 0, 0, 0, 1309, 1310, 3, 374, 187, 0, 1310, 1311, 5, 10, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1309, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1315, 3, 400, 200, 0, 1315, 141, 1, 0, 0, 0, 1316, 1317, 3, 462, 231, 0, 1317, 1319, 3, 580, 290, 0, 1318, 1320, 3, 278, 139, 0, 1319, 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1322, 3, 390, 195, 0, 1322, 1323, 3, 536, 268, 0, 1323, 1324, 3, 298, 149, 0, 1324, 143, 1, 0, 0, 0, 1325, 1326, 3, 462, 231, 0, 1326, 1328, 3, 556, 278, 0, 1327, 1329, 3, 278, 139, 0, 1328, 1327, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 1331, 3, 388, 194, 0, 1331, 145, 1, 0, 0, 0, 1332, 1333, 3, 462, 231, 0, 1333, 1335, 3, 572, 286, 0, 1334, 1336, 3, 278, 139, 0, 1335, 1334, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 1338, 3, 298, 149, 0, 1338, 147, 1, 0, 0, 0, 1339, 1340, 3, 462, 231, 0, 1340, 1342, 3, 508, 254, 0, 1341, 1343, 3, 278, 139, 0, 1342, 1341, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1345, 3, 374, 187, 0, 1345, 149, 1, 0, 0, 0, 1346, 1347, 3, 462, 231, 0, 1347, 1349, 3, 490, 245, 0, 1348, 1350, 3, 278, 139, 0, 1349, 1348, 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, 1354, 1, 0, 0, 0, 1351, 1352, 3, 374, 187, 0, 1352, 1353, 5, 10, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1351, 1, 0, 0, 0, 1354, 1355, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 1357, 3, 218, 109, 0, 1357, 151, 1, 0, 0, 0, 1358, 1359, 3, 452, 226, 0, 1359, 1361, 3, 572, 286, 0, 1360, 1362, 3, 276, 138, 0, 1361, 1360, 1, 0, 0, 0, 1361, 1362, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1364, 3, 298, 149, 0, 1364, 1365, 3, 610, 305, 0, 1365, 1366, 3, 174, 87, 0, 1366, 1368, 3, 612, 306, 0, 1367, 1369, 3, 154, 77, 0, 1368, 1367, 1, 0, 0, 0, 1368, 1369, 1, 0, 0, 0, 1369, 153, 1, 0, 0, 0, 1370, 1372, 3, 604, 302, 0, 1371, 1373, 3, 158, 79, 0, 1372, 1371, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1375, 1, 0, 0, 0, 1374, 1376, 3, 156, 78, 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 155, 1, 0, 0, 0, 1377, 1378, 3, 446, 223, 0, 1378, 1379, 3, 542, 271, 0, 1379, 1380, 3, 442, 221, 0, 1380, 1381, 3, 610, 305, 0, 1381, 1383, 3, 378, 189, 0, 1382, 1384, 3, 386, 193, 0, 1383, 1382, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1385, 1, 0, 0, 0, 1385, 1386, 3, 612, 306, 0, 1386, 157, 1, 0, 0, 0, 1387, 1393, 3, 160, 80, 0, 1388, 1389, 3, 426, 213, 0, 1389, 1390, 3, 160, 80, 0, 1390, 1392, 1, 0, 0, 0, 1391, 1388, 1, 0, 0, 0, 1392, 1395, 1, 0, 0, 0, 1393, 1391, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 159, 1, 0, 0, 0, 1395, 1393, 1, 0, 0, 0, 1396, 1397, 3, 162, 81, 0, 1397, 1398, 5, 19, 0, 0, 1398, 1399, 3, 164, 82, 0, 1399, 1405, 1, 0, 0, 0, 1400, 1401, 3, 162, 81, 0, 1401, 1402, 5, 19, 0, 0, 1402, 1403, 3, 166, 83, 0, 1403, 1405, 1, 0, 0, 0, 1404, 1396, 1, 0, 0, 0, 1404, 1400, 1, 0, 0, 0, 1405, 161, 1, 0, 0, 0, 1406, 1407, 5, 174, 0, 0, 1407, 163, 1, 0, 0, 0, 1408, 1411, 3, 368, 184, 0, 1409, 1411, 3, 366, 183, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, 0, 1411, 165, 1, 0, 0, 0, 1412, 1413, 3, 614, 307, 0, 1413, 1419, 3, 168, 84, 0, 1414, 1415, 3, 626, 313, 0, 1415, 1416, 3, 168, 84, 0, 1416, 1418, 1, 0, 0, 0, 1417, 1414, 1, 0, 0, 0, 1418, 1421, 1, 0, 0, 0, 1419, 1417, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1422, 1, 0, 0, 0, 1421, 1419, 1, 0, 0, 0, 1422, 1423, 3, 616, 308, 0, 1423, 167, 1, 0, 0, 0, 1424, 1425, 3, 170, 85, 0, 1425, 1426, 5, 9, 0, 0, 1426, 1427, 3, 172, 86, 0, 1427, 169, 1, 0, 0, 0, 1428, 1429, 3, 368, 184, 0, 1429, 171, 1, 0, 0, 0, 1430, 1433, 3, 368, 184, 0, 1431, 1433, 3, 366, 183, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1431, 1, 0, 0, 0, 1433, 173, 1, 0, 0, 0, 1434, 1440, 3, 176, 88, 0, 1435, 1436, 3, 626, 313, 0, 1436, 1437, 3, 176, 88, 0, 1437, 1439, 1, 0, 0, 0, 1438, 1435, 1, 0, 0, 0, 1439, 1442, 1, 0, 0, 0, 1440, 1438, 1, 0, 0, 0, 1440, 1441, 1, 0, 0, 0, 1441, 1446, 1, 0, 0, 0, 1442, 1440, 1, 0, 0, 0, 1443, 1444, 3, 626, 313, 0, 1444, 1445, 3, 180, 90, 0, 1445, 1447, 1, 0, 0, 0, 1446, 1443, 1, 0, 0, 0, 1446, 1447, 1, 0, 0, 0, 1447, 175, 1, 0, 0, 0, 1448, 1449, 3, 378, 189, 0, 1449, 1451, 3, 380, 190, 0, 1450, 1452, 3, 178, 89, 0, 1451, 1450, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 177, 1, 0, 0, 0, 1453, 1454, 3, 546, 273, 0, 1454, 1455, 3, 504, 252, 0, 1455, 179, 1, 0, 0, 0, 1456, 1457, 3, 546, 273, 0, 1457, 1458, 3, 504, 252, 0, 1458, 1459, 3, 610, 305, 0, 1459, 1460, 3, 182, 91, 0, 1460, 1461, 3, 612, 306, 0, 1461, 181, 1, 0, 0, 0, 1462, 1466, 3, 184, 92, 0, 1463, 1466, 3, 186, 93, 0, 1464, 1466, 3, 188, 94, 0, 1465, 1462, 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1465, 1464, 1, 0, 0, 0, 1466, 183, 1, 0, 0, 0, 1467, 1468, 3, 378, 189, 0, 1468, 185, 1, 0, 0, 0, 1469, 1470, 3, 194, 97, 0, 1470, 1471, 3, 626, 313, 0, 1471, 1472, 3, 192, 96, 0, 1472, 187, 1, 0, 0, 0, 1473, 1474, 3, 610, 305, 0, 1474, 1475, 3, 190, 95, 0, 1475, 1476, 3, 612, 306, 0, 1476, 1477, 3, 626, 313, 0, 1477, 1478, 3, 192, 96, 0, 1478, 189, 1, 0, 0, 0, 1479, 1485, 3, 194, 97, 0, 1480, 1481, 3, 626, 313, 0, 1481, 1482, 3, 194, 97, 0, 1482, 1484, 1, 0, 0, 0, 1483, 1480, 1, 0, 0, 0, 1484, 1487, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 191, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1488, 1494, 3, 196, 98, 0, 1489, 1490, 3, 626, 313, 0, 1490, 1491, 3, 196, 98, 0, 1491, 1493, 1, 0, 0, 0, 1492, 1489, 1, 0, 0, 0, 1493, 1496, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1494, 1495, 1, 0, 0, 0, 1495, 193, 1, 0, 0, 0, 1496, 1494, 1, 0, 0, 0, 1497, 1498, 3, 378, 189, 0, 1498, 195, 1, 0, 0, 0, 1499, 1500, 3, 378, 189, 0, 1500, 197, 1, 0, 0, 0, 1501, 1502, 3, 428, 214, 0, 1502, 1503, 3, 436, 218, 0, 1503, 199, 1, 0, 0, 0, 1504, 1506, 3, 440, 220, 0, 1505, 1507, 3, 202, 101, 0, 1506, 1505, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 3, 436, 218, 0, 1509, 1511, 3, 274, 137, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 201, 1, 0, 0, 0, 1512, 1515, 3, 518, 259, 0, 1513, 1515, 3, 588, 294, 0, 1514, 1512, 1, 0, 0, 0, 1514, 1513, 1, 0, 0, 0, 1515, 203, 1, 0, 0, 0, 1516, 1517, 3, 424, 212, 0, 1517, 1518, 3, 508, 254, 0, 1518, 1519, 3, 374, 187, 0, 1519, 1520, 3, 604, 302, 0, 1520, 1521, 3, 552, 276, 0, 1521, 1522, 5, 19, 0, 0, 1522, 1523, 3, 614, 307, 0, 1523, 1524, 3, 206, 103, 0, 1524, 1528, 3, 616, 308, 0, 1525, 1526, 3, 426, 213, 0, 1526, 1527, 3, 210, 105, 0, 1527, 1529, 1, 0, 0, 0, 1528, 1525, 1, 0, 0, 0, 1528, 1529, 1, 0, 0, 0, 1529, 205, 1, 0, 0, 0, 1530, 1536, 3, 208, 104, 0, 1531, 1532, 3, 626, 313, 0, 1532, 1533, 3, 208, 104, 0, 1533, 1535, 1, 0, 0, 0, 1534, 1531, 1, 0, 0, 0, 1535, 1538, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1537, 1, 0, 0, 0, 1537, 207, 1, 0, 0, 0, 1538, 1536, 1, 0, 0, 0, 1539, 1540, 5, 169, 0, 0, 1540, 1541, 5, 9, 0, 0, 1541, 1546, 5, 169, 0, 0, 1542, 1543, 5, 169, 0, 0, 1543, 1544, 5, 9, 0, 0, 1544, 1546, 5, 170, 0, 0, 1545, 1539, 1, 0, 0, 0, 1545, 1542, 1, 0, 0, 0, 1546, 209, 1, 0, 0, 0, 1547, 1548, 3, 464, 232, 0, 1548, 1549, 5, 19, 0, 0, 1549, 1550, 3, 370, 185, 0, 1550, 211, 1, 0, 0, 0, 1551, 1552, 3, 592, 296, 0, 1552, 1553, 3, 374, 187, 0, 1553, 213, 1, 0, 0, 0, 1554, 1556, 3, 582, 291, 0, 1555, 1557, 3, 572, 286, 0, 1556, 1555, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1559, 3, 298, 149, 0, 1559, 215, 1, 0, 0, 0, 1560, 1561, 3, 452, 226, 0, 1561, 1563, 3, 490, 245, 0, 1562, 1564, 3, 276, 138, 0, 1563, 1562, 1, 0, 0, 0, 1563, 1564, 1, 0, 0, 0, 1564, 1566, 1, 0, 0, 0, 1565, 1567, 3, 218, 109, 0, 1566, 1565, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 3, 536, 268, 0, 1569, 1570, 3, 298, 149, 0, 1570, 1571, 3, 610, 305, 0, 1571, 1572, 3, 220, 110, 0, 1572, 1573, 3, 612, 306, 0, 1573, 217, 1, 0, 0, 0, 1574, 1577, 5, 174, 0, 0, 1575, 1577, 3, 368, 184, 0, 1576, 1574, 1, 0, 0, 0, 1576, 1575, 1, 0, 0, 0, 1577, 219, 1, 0, 0, 0, 1578, 1583, 3, 378, 189, 0, 1579, 1583, 3, 222, 111, 0, 1580, 1583, 3, 224, 112, 0, 1581, 1583, 3, 226, 113, 0, 1582, 1578, 1, 0, 0, 0, 1582, 1579, 1, 0, 0, 0, 1582, 1580, 1, 0, 0, 0, 1582, 1581, 1, 0, 0, 0, 1583, 221, 1, 0, 0, 0, 1584, 1585, 3, 506, 253, 0, 1585, 1586, 3, 610, 305, 0, 1586, 1587, 5, 174, 0, 0, 1587, 1588, 3, 612, 306, 0, 1588, 223, 1, 0, 0, 0, 1589, 1590, 3, 466, 233, 0, 1590, 1591, 3, 610, 305, 0, 1591, 1592, 5, 174, 0, 0, 1592, 1593, 3, 612, 306, 0, 1593, 225, 1, 0, 0, 0, 1594, 1595, 3, 478, 239, 0, 1595, 1596, 3, 610, 305, 0, 1596, 1597, 5, 174, 0, 0, 1597, 1598, 3, 612, 306, 0, 1598, 227, 1, 0, 0, 0, 1599, 1601, 3, 200, 100, 0, 1600, 1599, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1604, 3, 454, 227, 0, 1603, 1605, 3, 230, 115, 0, 1604, 1603, 1, 0, 0, 0, 1604, 1605, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1608, 3, 300, 150, 0, 1607, 1609, 3, 274, 137, 0, 1608, 1607, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1613, 3, 306, 153, 0, 1611, 1614, 3, 278, 139, 0, 1612, 1614, 3, 236, 118, 0, 1613, 1611, 1, 0, 0, 0, 1613, 1612, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 1616, 1, 0, 0, 0, 1615, 1617, 3, 4, 2, 0, 1616, 1615, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 229, 1, 0, 0, 0, 1618, 1624, 3, 232, 116, 0, 1619, 1620, 3, 626, 313, 0, 1620, 1621, 3, 232, 116, 0, 1621, 1623, 1, 0, 0, 0, 1622, 1619, 1, 0, 0, 0, 1623, 1626, 1, 0, 0, 0, 1624, 1622, 1, 0, 0, 0, 1624, 1625, 1, 0, 0, 0, 1625, 231, 1, 0, 0, 0, 1626, 1624, 1, 0, 0, 0, 1627, 1629, 3, 314, 157, 0, 1628, 1630, 3, 320, 160, 0, 1629, 1628, 1, 0, 0, 0, 1629, 1630, 1, 0, 0, 0, 1630, 1636, 1, 0, 0, 0, 1631, 1633, 3, 318, 159, 0, 1632, 1634, 3, 320, 160, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1627, 1, 0, 0, 0, 1635, 1631, 1, 0, 0, 0, 1636, 233, 1, 0, 0, 0, 1637, 1639, 3, 200, 100, 0, 1638, 1637, 1, 0, 0, 0, 1638, 1639, 1, 0, 0, 0, 1639, 1640, 1, 0, 0, 0, 1640, 1641, 3, 590, 295, 0, 1641, 1643, 3, 298, 149, 0, 1642, 1644, 3, 268, 134, 0, 1643, 1642, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 1646, 3, 562, 281, 0, 1646, 1647, 3, 242, 121, 0, 1647, 1650, 3, 306, 153, 0, 1648, 1651, 3, 278, 139, 0, 1649, 1651, 3, 236, 118, 0, 1650, 1648, 1, 0, 0, 0, 1650, 1649, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1653, 1, 0, 0, 0, 1652, 1654, 3, 4, 2, 0, 1653, 1652, 1, 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 235, 1, 0, 0, 0, 1655, 1656, 3, 486, 243, 0, 1656, 1657, 3, 238, 119, 0, 1657, 237, 1, 0, 0, 0, 1658, 1664, 3, 240, 120, 0, 1659, 1660, 3, 426, 213, 0, 1660, 1661, 3, 240, 120, 0, 1661, 1663, 1, 0, 0, 0, 1662, 1659, 1, 0, 0, 0, 1663, 1666, 1, 0, 0, 0, 1664, 1662, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 239, 1, 0, 0, 0, 1666, 1664, 1, 0, 0, 0, 1667, 1668, 5, 174, 0, 0, 1668, 1669, 5, 19, 0, 0, 1669, 1670, 3, 362, 181, 0, 1670, 241, 1, 0, 0, 0, 1671, 1677, 3, 244, 122, 0, 1672, 1673, 3, 626, 313, 0, 1673, 1674, 3, 244, 122, 0, 1674, 1676, 1, 0, 0, 0, 1675, 1672, 1, 0, 0, 0, 1676, 1679, 1, 0, 0, 0, 1677, 1675, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 243, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1680, 1685, 3, 250, 125, 0, 1681, 1685, 3, 248, 124, 0, 1682, 1685, 3, 246, 123, 0, 1683, 1685, 3, 254, 127, 0, 1684, 1680, 1, 0, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 245, 1, 0, 0, 0, 1686, 1687, 3, 378, 189, 0, 1687, 1688, 5, 19, 0, 0, 1688, 1689, 3, 360, 180, 0, 1689, 247, 1, 0, 0, 0, 1690, 1691, 3, 378, 189, 0, 1691, 1692, 5, 19, 0, 0, 1692, 1693, 3, 360, 180, 0, 1693, 1694, 3, 262, 131, 0, 1694, 1695, 5, 174, 0, 0, 1695, 249, 1, 0, 0, 0, 1696, 1697, 3, 378, 189, 0, 1697, 1698, 5, 19, 0, 0, 1698, 1699, 5, 174, 0, 0, 1699, 1700, 3, 262, 131, 0, 1700, 1701, 3, 360, 180, 0, 1701, 251, 1, 0, 0, 0, 1702, 1703, 3, 622, 311, 0, 1703, 1704, 3, 362, 181, 0, 1704, 1705, 3, 624, 312, 0, 1705, 253, 1, 0, 0, 0, 1706, 1707, 3, 378, 189, 0, 1707, 1708, 3, 252, 126, 0, 1708, 1709, 5, 19, 0, 0, 1709, 1710, 3, 362, 181, 0, 1710, 255, 1, 0, 0, 0, 1711, 1721, 3, 614, 307, 0, 1712, 1718, 3, 362, 181, 0, 1713, 1714, 3, 626, 313, 0, 1714, 1715, 3, 362, 181, 0, 1715, 1717, 1, 0, 0, 0, 1716, 1713, 1, 0, 0, 0, 1717, 1720, 1, 0, 0, 0, 1718, 1716, 1, 0, 0, 0, 1718, 1719, 1, 0, 0, 0, 1719, 1722, 1, 0, 0, 0, 1720, 1718, 1, 0, 0, 0, 1721, 1712, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1724, 3, 616, 308, 0, 1724, 257, 1, 0, 0, 0, 1725, 1726, 3, 614, 307, 0, 1726, 1727, 3, 362, 181, 0, 1727, 1728, 3, 628, 314, 0, 1728, 1729, 3, 362, 181, 0, 1729, 1737, 1, 0, 0, 0, 1730, 1731, 3, 626, 313, 0, 1731, 1732, 3, 362, 181, 0, 1732, 1733, 3, 628, 314, 0, 1733, 1734, 3, 362, 181, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1730, 1, 0, 0, 0, 1736, 1739, 1, 0, 0, 0, 1737, 1735, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1740, 1, 0, 0, 0, 1739, 1737, 1, 0, 0, 0, 1740, 1741, 3, 616, 308, 0, 1741, 259, 1, 0, 0, 0, 1742, 1752, 3, 622, 311, 0, 1743, 1749, 3, 362, 181, 0, 1744, 1745, 3, 626, 313, 0, 1745, 1746, 3, 362, 181, 0, 1746, 1748, 1, 0, 0, 0, 1747, 1744, 1, 0, 0, 0, 1748, 1751, 1, 0, 0, 0, 1749, 1747, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1753, 1, 0, 0, 0, 1751, 1749, 1, 0, 0, 0, 1752, 1743, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1754, 1, 0, 0, 0, 1754, 1755, 3, 624, 312, 0, 1755, 261, 1, 0, 0, 0, 1756, 1757, 7, 1, 0, 0, 1757, 263, 1, 0, 0, 0, 1758, 1759, 3, 610, 305, 0, 1759, 1765, 3, 288, 144, 0, 1760, 1761, 3, 626, 313, 0, 1761, 1762, 3, 288, 144, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1760, 1, 0, 0, 0, 1764, 1767, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1765, 1766, 1, 0, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1765, 1, 0, 0, 0, 1768, 1769, 3, 612, 306, 0, 1769, 265, 1, 0, 0, 0, 1770, 1772, 3, 200, 100, 0, 1771, 1770, 1, 0, 0, 0, 1771, 1772, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1774, 3, 496, 248, 0, 1774, 1775, 3, 498, 249, 0, 1775, 1777, 3, 298, 149, 0, 1776, 1778, 3, 282, 141, 0, 1777, 1776, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1781, 3, 280, 140, 0, 1780, 1782, 3, 276, 138, 0, 1781, 1780, 1, 0, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 1784, 1, 0, 0, 0, 1783, 1785, 3, 268, 134, 0, 1784, 1783, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1787, 1, 0, 0, 0, 1786, 1788, 3, 4, 2, 0, 1787, 1786, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 267, 1, 0, 0, 0, 1789, 1790, 3, 596, 298, 0, 1790, 1791, 3, 272, 136, 0, 1791, 1806, 1, 0, 0, 0, 1792, 1793, 3, 596, 298, 0, 1793, 1794, 3, 272, 136, 0, 1794, 1795, 3, 426, 213, 0, 1795, 1796, 3, 270, 135, 0, 1796, 1806, 1, 0, 0, 0, 1797, 1798, 3, 596, 298, 0, 1798, 1799, 3, 270, 135, 0, 1799, 1806, 1, 0, 0, 0, 1800, 1801, 3, 596, 298, 0, 1801, 1802, 3, 270, 135, 0, 1802, 1803, 3, 426, 213, 0, 1803, 1804, 3, 272, 136, 0, 1804, 1806, 1, 0, 0, 0, 1805, 1789, 1, 0, 0, 0, 1805, 1792, 1, 0, 0, 0, 1805, 1797, 1, 0, 0, 0, 1805, 1800, 1, 0, 0, 0, 1806, 269, 1, 0, 0, 0, 1807, 1810, 3, 576, 288, 0, 1808, 1811, 3, 342, 171, 0, 1809, 1811, 3, 364, 182, 0, 1810, 1808, 1, 0, 0, 0, 1810, 1809, 1, 0, 0, 0, 1811, 271, 1, 0, 0, 0, 1812, 1813, 3, 584, 292, 0, 1813, 1814, 3, 364, 182, 0, 1814, 273, 1, 0, 0, 0, 1815, 1816, 3, 596, 298, 0, 1816, 1817, 3, 270, 135, 0, 1817, 275, 1, 0, 0, 0, 1818, 1819, 3, 486, 243, 0, 1819, 1820, 3, 530, 265, 0, 1820, 1821, 3, 470, 235, 0, 1821, 277, 1, 0, 0, 0, 1822, 1823, 3, 486, 243, 0, 1823, 1824, 3, 470, 235, 0, 1824, 279, 1, 0, 0, 0, 1825, 1826, 3, 598, 299, 0, 1826, 1827, 5, 1, 0, 0, 1827, 1828, 3, 286, 143, 0, 1828, 1829, 5, 2, 0, 0, 1829, 1834, 1, 0, 0, 0, 1830, 1831, 3, 502, 251, 0, 1831, 1832, 3, 362, 181, 0, 1832, 1834, 1, 0, 0, 0, 1833, 1825, 1, 0, 0, 0, 1833, 1830, 1, 0, 0, 0, 1834, 281, 1, 0, 0, 0, 1835, 1836, 5, 1, 0, 0, 1836, 1837, 3, 284, 142, 0, 1837, 1838, 5, 2, 0, 0, 1838, 283, 1, 0, 0, 0, 1839, 1845, 3, 378, 189, 0, 1840, 1841, 3, 626, 313, 0, 1841, 1842, 3, 378, 189, 0, 1842, 1844, 1, 0, 0, 0, 1843, 1840, 1, 0, 0, 0, 1844, 1847, 1, 0, 0, 0, 1845, 1843, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 285, 1, 0, 0, 0, 1847, 1845, 1, 0, 0, 0, 1848, 1854, 3, 360, 180, 0, 1849, 1850, 3, 626, 313, 0, 1850, 1851, 3, 360, 180, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1849, 1, 0, 0, 0, 1853, 1856, 1, 0, 0, 0, 1854, 1852, 1, 0, 0, 0, 1854, 1855, 1, 0, 0, 0, 1855, 287, 1, 0, 0, 0, 1856, 1854, 1, 0, 0, 0, 1857, 1864, 3, 362, 181, 0, 1858, 1864, 3, 352, 176, 0, 1859, 1864, 3, 258, 129, 0, 1860, 1864, 3, 256, 128, 0, 1861, 1864, 3, 260, 130, 0, 1862, 1864, 3, 264, 132, 0, 1863, 1857, 1, 0, 0, 0, 1863, 1858, 1, 0, 0, 0, 1863, 1859, 1, 0, 0, 0, 1863, 1860, 1, 0, 0, 0, 1863, 1861, 1, 0, 0, 0, 1863, 1862, 1, 0, 0, 0, 1864, 289, 1, 0, 0, 0, 1865, 1867, 3, 560, 280, 0, 1866, 1868, 3, 308, 154, 0, 1867, 1866, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1871, 3, 502, 251, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1873, 3, 310, 155, 0, 1873, 1875, 3, 300, 150, 0, 1874, 1876, 3, 306, 153, 0, 1875, 1874, 1, 0, 0, 0, 1875, 1876, 1, 0, 0, 0, 1876, 1878, 1, 0, 0, 0, 1877, 1879, 3, 630, 315, 0, 1878, 1877, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 1881, 1, 0, 0, 0, 1880, 1882, 3, 302, 151, 0, 1881, 1880, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1884, 1, 0, 0, 0, 1883, 1885, 3, 294, 147, 0, 1884, 1883, 1, 0, 0, 0, 1884, 1885, 1, 0, 0, 0, 1885, 1887, 1, 0, 0, 0, 1886, 1888, 3, 292, 146, 0, 1887, 1886, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1891, 3, 4, 2, 0, 1890, 1889, 1, 0, 0, 0, 1890, 1891, 1, 0, 0, 0, 1891, 291, 1, 0, 0, 0, 1892, 1893, 3, 422, 211, 0, 1893, 1894, 3, 472, 236, 0, 1894, 293, 1, 0, 0, 0, 1895, 1898, 3, 514, 257, 0, 1896, 1899, 3, 342, 171, 0, 1897, 1899, 3, 364, 182, 0, 1898, 1896, 1, 0, 0, 0, 1898, 1897, 1, 0, 0, 0, 1899, 295, 1, 0, 0, 0, 1900, 1901, 5, 83, 0, 0, 1901, 297, 1, 0, 0, 0, 1902, 1903, 3, 374, 187, 0, 1903, 1904, 5, 10, 0, 0, 1904, 1906, 1, 0, 0, 0, 1905, 1902, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1908, 3, 376, 188, 0, 1908, 299, 1, 0, 0, 0, 1909, 1910, 3, 476, 238, 0, 1910, 1911, 3, 298, 149, 0, 1911, 301, 1, 0, 0, 0, 1912, 1913, 3, 542, 271, 0, 1913, 1914, 3, 442, 221, 0, 1914, 1920, 3, 304, 152, 0, 1915, 1916, 3, 626, 313, 0, 1916, 1917, 3, 304, 152, 0, 1917, 1919, 1, 0, 0, 0, 1918, 1915, 1, 0, 0, 0, 1919, 1922, 1, 0, 0, 0, 1920, 1918, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 303, 1, 0, 0, 0, 1922, 1920, 1, 0, 0, 0, 1923, 1926, 5, 174, 0, 0, 1924, 1927, 3, 432, 216, 0, 1925, 1927, 3, 456, 228, 0, 1926, 1924, 1, 0, 0, 0, 1926, 1925, 1, 0, 0, 0, 1926, 1927, 1, 0, 0, 0, 1927, 305, 1, 0, 0, 0, 1928, 1929, 3, 602, 301, 0, 1929, 1930, 3, 322, 161, 0, 1930, 307, 1, 0, 0, 0, 1931, 1932, 3, 460, 230, 0, 1932, 309, 1, 0, 0, 0, 1933, 1936, 5, 11, 0, 0, 1934, 1936, 3, 312, 156, 0, 1935, 1933, 1, 0, 0, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1942, 1, 0, 0, 0, 1937, 1938, 3, 626, 313, 0, 1938, 1939, 3, 312, 156, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1937, 1, 0, 0, 0, 1941, 1944, 1, 0, 0, 0, 1942, 1940, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 311, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1945, 1947, 3, 314, 157, 0, 1946, 1948, 3, 320, 160, 0, 1947, 1946, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1958, 1, 0, 0, 0, 1949, 1951, 3, 316, 158, 0, 1950, 1952, 3, 320, 160, 0, 1951, 1950, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1958, 1, 0, 0, 0, 1953, 1955, 3, 318, 159, 0, 1954, 1956, 3, 320, 160, 0, 1955, 1954, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1958, 1, 0, 0, 0, 1957, 1945, 1, 0, 0, 0, 1957, 1949, 1, 0, 0, 0, 1957, 1953, 1, 0, 0, 0, 1958, 313, 1, 0, 0, 0, 1959, 1960, 3, 378, 189, 0, 1960, 315, 1, 0, 0, 0, 1961, 1962, 3, 352, 176, 0, 1962, 317, 1, 0, 0, 0, 1963, 1964, 3, 378, 189, 0, 1964, 1965, 3, 622, 311, 0, 1965, 1966, 3, 362, 181, 0, 1966, 1967, 3, 624, 312, 0, 1967, 319, 1, 0, 0, 0, 1968, 1969, 3, 430, 215, 0, 1969, 1970, 5, 174, 0, 0, 1970, 321, 1, 0, 0, 0, 1971, 1977, 3, 324, 162, 0, 1972, 1973, 3, 426, 213, 0, 1973, 1974, 3, 324, 162, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1972, 1, 0, 0, 0, 1976, 1979, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 323, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1980, 2050, 3, 338, 169, 0, 1981, 2050, 3, 340, 170, 0, 1982, 2050, 3, 336, 168, 0, 1983, 2050, 3, 328, 164, 0, 1984, 2050, 3, 330, 165, 0, 1985, 2050, 3, 332, 166, 0, 1986, 2050, 3, 334, 167, 0, 1987, 2050, 3, 350, 175, 0, 1988, 2050, 3, 348, 174, 0, 1989, 2050, 3, 346, 173, 0, 1990, 1991, 5, 174, 0, 0, 1991, 1992, 5, 10, 0, 0, 1992, 1993, 5, 174, 0, 0, 1993, 1994, 3, 296, 148, 0, 1994, 1995, 3, 362, 181, 0, 1995, 2050, 1, 0, 0, 0, 1996, 1997, 5, 174, 0, 0, 1997, 1998, 5, 10, 0, 0, 1998, 1999, 5, 174, 0, 0, 1999, 2000, 3, 438, 219, 0, 2000, 2001, 3, 362, 181, 0, 2001, 2002, 3, 426, 213, 0, 2002, 2003, 3, 362, 181, 0, 2003, 2050, 1, 0, 0, 0, 2004, 2005, 5, 1, 0, 0, 2005, 2011, 5, 174, 0, 0, 2006, 2007, 3, 626, 313, 0, 2007, 2008, 5, 174, 0, 0, 2008, 2010, 1, 0, 0, 0, 2009, 2006, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2015, 5, 2, 0, 0, 2015, 2016, 3, 488, 244, 0, 2016, 2017, 5, 1, 0, 0, 2017, 2023, 3, 264, 132, 0, 2018, 2019, 3, 626, 313, 0, 2019, 2020, 3, 264, 132, 0, 2020, 2022, 1, 0, 0, 0, 2021, 2018, 1, 0, 0, 0, 2022, 2025, 1, 0, 0, 0, 2023, 2021, 1, 0, 0, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2026, 1, 0, 0, 0, 2025, 2023, 1, 0, 0, 0, 2026, 2027, 5, 2, 0, 0, 2027, 2050, 1, 0, 0, 0, 2028, 2029, 5, 1, 0, 0, 2029, 2035, 5, 174, 0, 0, 2030, 2031, 3, 626, 313, 0, 2031, 2032, 5, 174, 0, 0, 2032, 2034, 1, 0, 0, 0, 2033, 2030, 1, 0, 0, 0, 2034, 2037, 1, 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2038, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2038, 2039, 5, 2, 0, 0, 2039, 2040, 3, 326, 163, 0, 2040, 2046, 3, 264, 132, 0, 2041, 2042, 3, 626, 313, 0, 2042, 2043, 3, 264, 132, 0, 2043, 2045, 1, 0, 0, 0, 2044, 2041, 1, 0, 0, 0, 2045, 2048, 1, 0, 0, 0, 2046, 2044, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2050, 1, 0, 0, 0, 2048, 2046, 1, 0, 0, 0, 2049, 1980, 1, 0, 0, 0, 2049, 1981, 1, 0, 0, 0, 2049, 1982, 1, 0, 0, 0, 2049, 1983, 1, 0, 0, 0, 2049, 1984, 1, 0, 0, 0, 2049, 1985, 1, 0, 0, 0, 2049, 1986, 1, 0, 0, 0, 2049, 1987, 1, 0, 0, 0, 2049, 1988, 1, 0, 0, 0, 2049, 1989, 1, 0, 0, 0, 2049, 1990, 1, 0, 0, 0, 2049, 1996, 1, 0, 0, 0, 2049, 2004, 1, 0, 0, 0, 2049, 2028, 1, 0, 0, 0, 2050, 325, 1, 0, 0, 0, 2051, 2052, 7, 2, 0, 0, 2052, 327, 1, 0, 0, 0, 2053, 2054, 3, 352, 176, 0, 2054, 2055, 3, 326, 163, 0, 2055, 2056, 3, 362, 181, 0, 2056, 329, 1, 0, 0, 0, 2057, 2058, 3, 352, 176, 0, 2058, 2059, 3, 326, 163, 0, 2059, 2060, 3, 352, 176, 0, 2060, 331, 1, 0, 0, 0, 2061, 2062, 3, 378, 189, 0, 2062, 2063, 3, 326, 163, 0, 2063, 2064, 3, 352, 176, 0, 2064, 333, 1, 0, 0, 0, 2065, 2066, 3, 352, 176, 0, 2066, 2067, 3, 326, 163, 0, 2067, 2068, 3, 378, 189, 0, 2068, 335, 1, 0, 0, 0, 2069, 2070, 3, 378, 189, 0, 2070, 2071, 3, 438, 219, 0, 2071, 2072, 3, 360, 180, 0, 2072, 2073, 3, 426, 213, 0, 2073, 2074, 3, 360, 180, 0, 2074, 337, 1, 0, 0, 0, 2075, 2076, 3, 378, 189, 0, 2076, 2077, 3, 326, 163, 0, 2077, 2078, 3, 362, 181, 0, 2078, 339, 1, 0, 0, 0, 2079, 2080, 3, 378, 189, 0, 2080, 2081, 3, 296, 148, 0, 2081, 2082, 3, 362, 181, 0, 2082, 341, 1, 0, 0, 0, 2083, 2084, 7, 3, 0, 0, 2084, 343, 1, 0, 0, 0, 2085, 2091, 3, 342, 171, 0, 2086, 2087, 5, 1, 0, 0, 2087, 2088, 3, 356, 178, 0, 2088, 2089, 5, 2, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2085, 1, 0, 0, 0, 2090, 2086, 1, 0, 0, 0, 2091, 345, 1, 0, 0, 0, 2092, 2093, 3, 378, 189, 0, 2093, 2094, 3, 488, 244, 0, 2094, 2095, 3, 344, 172, 0, 2095, 347, 1, 0, 0, 0, 2096, 2097, 3, 378, 189, 0, 2097, 2098, 3, 450, 225, 0, 2098, 2099, 3, 362, 181, 0, 2099, 349, 1, 0, 0, 0, 2100, 2101, 3, 378, 189, 0, 2101, 2102, 3, 450, 225, 0, 2102, 2103, 3, 504, 252, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2105, 3, 362, 181, 0, 2105, 351, 1, 0, 0, 0, 2106, 2107, 3, 354, 177, 0, 2107, 2109, 5, 1, 0, 0, 2108, 2110, 3, 356, 178, 0, 2109, 2108, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2112, 5, 2, 0, 0, 2112, 353, 1, 0, 0, 0, 2113, 2114, 7, 4, 0, 0, 2114, 355, 1, 0, 0, 0, 2115, 2121, 3, 358, 179, 0, 2116, 2117, 3, 626, 313, 0, 2117, 2118, 3, 358, 179, 0, 2118, 2120, 1, 0, 0, 0, 2119, 2116, 1, 0, 0, 0, 2120, 2123, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 357, 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2124, 2128, 3, 360, 180, 0, 2125, 2128, 3, 378, 189, 0, 2126, 2128, 5, 11, 0, 0, 2127, 2124, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2126, 1, 0, 0, 0, 2128, 359, 1, 0, 0, 0, 2129, 2137, 3, 342, 171, 0, 2130, 2137, 3, 362, 181, 0, 2131, 2137, 3, 352, 176, 0, 2132, 2137, 3, 258, 129, 0, 2133, 2137, 3, 256, 128, 0, 2134, 2137, 3, 260, 130, 0, 2135, 2137, 3, 264, 132, 0, 2136, 2129, 1, 0, 0, 0, 2136, 2130, 1, 0, 0, 0, 2136, 2131, 1, 0, 0, 0, 2136, 2132, 1, 0, 0, 0, 2136, 2133, 1, 0, 0, 0, 2136, 2134, 1, 0, 0, 0, 2136, 2135, 1, 0, 0, 0, 2137, 361, 1, 0, 0, 0, 2138, 2148, 3, 342, 171, 0, 2139, 2148, 3, 532, 266, 0, 2140, 2148, 5, 175, 0, 0, 2141, 2148, 3, 368, 184, 0, 2142, 2148, 3, 364, 182, 0, 2143, 2148, 3, 366, 183, 0, 2144, 2148, 3, 372, 186, 0, 2145, 2148, 3, 370, 185, 0, 2146, 2148, 3, 58, 29, 0, 2147, 2138, 1, 0, 0, 0, 2147, 2139, 1, 0, 0, 0, 2147, 2140, 1, 0, 0, 0, 2147, 2141, 1, 0, 0, 0, 2147, 2142, 1, 0, 0, 0, 2147, 2143, 1, 0, 0, 0, 2147, 2144, 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2147, 2146, 1, 0, 0, 0, 2148, 363, 1, 0, 0, 0, 2149, 2150, 5, 170, 0, 0, 2150, 365, 1, 0, 0, 0, 2151, 2152, 7, 5, 0, 0, 2152, 367, 1, 0, 0, 0, 2153, 2154, 5, 169, 0, 0, 2154, 369, 1, 0, 0, 0, 2155, 2156, 7, 6, 0, 0, 2156, 371, 1, 0, 0, 0, 2157, 2158, 5, 172, 0, 0, 2158, 373, 1, 0, 0, 0, 2159, 2164, 5, 174, 0, 0, 2160, 2161, 5, 17, 0, 0, 2161, 2162, 5, 174, 0, 0, 2162, 2164, 5, 17, 0, 0, 2163, 2159, 1, 0, 0, 0, 2163, 2160, 1, 0, 0, 0, 2164, 375, 1, 0, 0, 0, 2165, 2173, 5, 174, 0, 0, 2166, 2173, 5, 79, 0, 0, 2167, 2173, 5, 125, 0, 0, 2168, 2173, 5, 63, 0, 0, 2169, 2170, 5, 17, 0, 0, 2170, 2171, 5, 174, 0, 0, 2171, 2173, 5, 17, 0, 0, 2172, 2165, 1, 0, 0, 0, 2172, 2166, 1, 0, 0, 0, 2172, 2167, 1, 0, 0, 0, 2172, 2168, 1, 0, 0, 0, 2172, 2169, 1, 0, 0, 0, 2173, 377, 1, 0, 0, 0, 2174, 2181, 5, 174, 0, 0, 2175, 2181, 3, 586, 293, 0, 2176, 2181, 5, 76, 0, 0, 2177, 2178, 5, 17, 0, 0, 2178, 2179, 5, 174, 0, 0, 2179, 2181, 5, 17, 0, 0, 2180, 2174, 1, 0, 0, 0, 2180, 2175, 1, 0, 0, 0, 2180, 2176, 1, 0, 0, 0, 2180, 2177, 1, 0, 0, 0, 2181, 379, 1, 0, 0, 0, 2182, 2184, 3, 382, 191, 0, 2183, 2185, 3, 384, 192, 0, 2184, 2183, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 381, 1, 0, 0, 0, 2186, 2187, 7, 7, 0, 0, 2187, 383, 1, 0, 0, 0, 2188, 2189, 3, 618, 309, 0, 2189, 2195, 3, 380, 190, 0, 2190, 2191, 3, 626, 313, 0, 2191, 2192, 3, 380, 190, 0, 2192, 2194, 1, 0, 0, 0, 2193, 2190, 1, 0, 0, 0, 2194, 2197, 1, 0, 0, 0, 2195, 2193, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2198, 1, 0, 0, 0, 2197, 2195, 1, 0, 0, 0, 2198, 2199, 3, 620, 310, 0, 2199, 385, 1, 0, 0, 0, 2200, 2203, 3, 432, 216, 0, 2201, 2203, 3, 456, 228, 0, 2202, 2200, 1, 0, 0, 0, 2202, 2201, 1, 0, 0, 0, 2203, 387, 1, 0, 0, 0, 2204, 2205, 5, 174, 0, 0, 2205, 389, 1, 0, 0, 0, 2206, 2207, 5, 174, 0, 0, 2207, 391, 1, 0, 0, 0, 2208, 2209, 3, 368, 184, 0, 2209, 393, 1, 0, 0, 0, 2210, 2211, 5, 174, 0, 0, 2211, 395, 1, 0, 0, 0, 2212, 2213, 5, 174, 0, 0, 2213, 397, 1, 0, 0, 0, 2214, 2215, 5, 174, 0, 0, 2215, 399, 1, 0, 0, 0, 2216, 2217, 5, 174, 0, 0, 2217, 401, 1, 0, 0, 0, 2218, 2219, 5, 174, 0, 0, 2219, 403, 1, 0, 0, 0, 2220, 2221, 5, 174, 0, 0, 2221, 405, 1, 0, 0, 0, 2222, 2223, 3, 368, 184, 0, 2223, 407, 1, 0, 0, 0, 2224, 2225, 5, 174, 0, 0, 2225, 409, 1, 0, 0, 0, 2226, 2227, 3, 412, 206, 0, 2227, 2228, 3, 380, 190, 0, 2228, 411, 1, 0, 0, 0, 2229, 2230, 7, 8, 0, 0, 2230, 413, 1, 0, 0, 0, 2231, 2232, 5, 24, 0, 0, 2232, 415, 1, 0, 0, 0, 2233, 2234, 5, 25, 0, 0, 2234, 417, 1, 0, 0, 0, 2235, 2236, 5, 26, 0, 0, 2236, 419, 1, 0, 0, 0, 2237, 2238, 5, 26, 0, 0, 2238, 2239, 5, 106, 0, 0, 2239, 421, 1, 0, 0, 0, 2240, 2241, 5, 27, 0, 0, 2241, 423, 1, 0, 0, 0, 2242, 2243, 5, 28, 0, 0, 2243, 425, 1, 0, 0, 0, 2244, 2245, 5, 29, 0, 0, 2245, 427, 1, 0, 0, 0, 2246, 2247, 5, 31, 0, 0, 2247, 429, 1, 0, 0, 0, 2248, 2249, 5, 32, 0, 0, 2249, 431, 1, 0, 0, 0, 2250, 2251, 5, 33, 0, 0, 2251, 433, 1, 0, 0, 0, 2252, 2253, 5, 34, 0, 0, 2253, 435, 1, 0, 0, 0, 2254, 2255, 5, 35, 0, 0, 2255, 437, 1, 0, 0, 0, 2256, 2257, 5, 37, 0, 0, 2257, 439, 1, 0, 0, 0, 2258, 2259, 5, 36, 0, 0, 2259, 441, 1, 0, 0, 0, 2260, 2261, 5, 38, 0, 0, 2261, 443, 1, 0, 0, 0, 2262, 2263, 5, 39, 0, 0, 2263, 445, 1, 0, 0, 0, 2264, 2265, 5, 40, 0, 0, 2265, 447, 1, 0, 0, 0, 2266, 2267, 5, 42, 0, 0, 2267, 449, 1, 0, 0, 0, 2268, 2269, 5, 44, 0, 0, 2269, 451, 1, 0, 0, 0, 2270, 2271, 5, 45, 0, 0, 2271, 453, 1, 0, 0, 0, 2272, 2273, 5, 47, 0, 0, 2273, 455, 1, 0, 0, 0, 2274, 2275, 5, 48, 0, 0, 2275, 457, 1, 0, 0, 0, 2276, 2277, 5, 49, 0, 0, 2277, 459, 1, 0, 0, 0, 2278, 2279, 5, 50, 0, 0, 2279, 461, 1, 0, 0, 0, 2280, 2281, 5, 51, 0, 0, 2281, 463, 1, 0, 0, 0, 2282, 2283, 5, 52, 0, 0, 2283, 465, 1, 0, 0, 0, 2284, 2285, 5, 54, 0, 0, 2285, 467, 1, 0, 0, 0, 2286, 2287, 5, 55, 0, 0, 2287, 469, 1, 0, 0, 0, 2288, 2289, 5, 56, 0, 0, 2289, 471, 1, 0, 0, 0, 2290, 2291, 5, 58, 0, 0, 2291, 473, 1, 0, 0, 0, 2292, 2293, 5, 59, 0, 0, 2293, 475, 1, 0, 0, 0, 2294, 2295, 5, 60, 0, 0, 2295, 477, 1, 0, 0, 0, 2296, 2297, 5, 61, 0, 0, 2297, 479, 1, 0, 0, 0, 2298, 2299, 5, 62, 0, 0, 2299, 481, 1, 0, 0, 0, 2300, 2301, 5, 63, 0, 0, 2301, 483, 1, 0, 0, 0, 2302, 2303, 5, 64, 0, 0, 2303, 485, 1, 0, 0, 0, 2304, 2305, 5, 66, 0, 0, 2305, 487, 1, 0, 0, 0, 2306, 2307, 5, 67, 0, 0, 2307, 489, 1, 0, 0, 0, 2308, 2309, 5, 68, 0, 0, 2309, 491, 1, 0, 0, 0, 2310, 2311, 5, 70, 0, 0, 2311, 493, 1, 0, 0, 0, 2312, 2313, 5, 71, 0, 0, 2313, 495, 1, 0, 0, 0, 2314, 2315, 5, 72, 0, 0, 2315, 497, 1, 0, 0, 0, 2316, 2317, 5, 73, 0, 0, 2317, 499, 1, 0, 0, 0, 2318, 2319, 5, 74, 0, 0, 2319, 501, 1, 0, 0, 0, 2320, 2321, 5, 75, 0, 0, 2321, 503, 1, 0, 0, 0, 2322, 2323, 5, 76, 0, 0, 2323, 505, 1, 0, 0, 0, 2324, 2325, 5, 77, 0, 0, 2325, 507, 1, 0, 0, 0, 2326, 2327, 5, 78, 0, 0, 2327, 509, 1, 0, 0, 0, 2328, 2329, 5, 79, 0, 0, 2329, 511, 1, 0, 0, 0, 2330, 2331, 5, 80, 0, 0, 2331, 513, 1, 0, 0, 0, 2332, 2333, 5, 82, 0, 0, 2333, 515, 1, 0, 0, 0, 2334, 2335, 5, 84, 0, 0, 2335, 517, 1, 0, 0, 0, 2336, 2337, 5, 87, 0, 0, 2337, 519, 1, 0, 0, 0, 2338, 2339, 5, 88, 0, 0, 2339, 521, 1, 0, 0, 0, 2340, 2341, 5, 89, 0, 0, 2341, 523, 1, 0, 0, 0, 2342, 2343, 5, 90, 0, 0, 2343, 525, 1, 0, 0, 0, 2344, 2345, 5, 93, 0, 0, 2345, 527, 1, 0, 0, 0, 2346, 2347, 5, 92, 0, 0, 2347, 529, 1, 0, 0, 0, 2348, 2349, 5, 94, 0, 0, 2349, 531, 1, 0, 0, 0, 2350, 2351, 5, 95, 0, 0, 2351, 533, 1, 0, 0, 0, 2352, 2353, 5, 96, 0, 0, 2353, 535, 1, 0, 0, 0, 2354, 2355, 5, 97, 0, 0, 2355, 537, 1, 0, 0, 0, 2356, 2357, 5, 99, 0, 0, 2357, 539, 1, 0, 0, 0, 2358, 2359, 5, 100, 0, 0, 2359, 541, 1, 0, 0, 0, 2360, 2361, 5, 101, 0, 0, 2361, 543, 1, 0, 0, 0, 2362, 2363, 5, 103, 0, 0, 2363, 545, 1, 0, 0, 0, 2364, 2365, 5, 107, 0, 0, 2365, 547, 1, 0, 0, 0, 2366, 2367, 5, 109, 0, 0, 2367, 549, 1, 0, 0, 0, 2368, 2369, 5, 110, 0, 0, 2369, 551, 1, 0, 0, 0, 2370, 2371, 5, 111, 0, 0, 2371, 553, 1, 0, 0, 0, 2372, 2373, 5, 112, 0, 0, 2373, 555, 1, 0, 0, 0, 2374, 2375, 5, 114, 0, 0, 2375, 557, 1, 0, 0, 0, 2376, 2377, 5, 115, 0, 0, 2377, 559, 1, 0, 0, 0, 2378, 2379, 5, 117, 0, 0, 2379, 561, 1, 0, 0, 0, 2380, 2381, 5, 118, 0, 0, 2381, 563, 1, 0, 0, 0, 2382, 2383, 5, 119, 0, 0, 2383, 565, 1, 0, 0, 0, 2384, 2385, 5, 121, 0, 0, 2385, 567, 1, 0, 0, 0, 2386, 2387, 5, 122, 0, 0, 2387, 569, 1, 0, 0, 0, 2388, 2389, 5, 123, 0, 0, 2389, 571, 1, 0, 0, 0, 2390, 2391, 5, 124, 0, 0, 2391, 573, 1, 0, 0, 0, 2392, 2393, 5, 125, 0, 0, 2393, 575, 1, 0, 0, 0, 2394, 2395, 5, 127, 0, 0, 2395, 577, 1, 0, 0, 0, 2396, 2397, 5, 128, 0, 0, 2397, 579, 1, 0, 0, 0, 2398, 2399, 5, 130, 0, 0, 2399, 581, 1, 0, 0, 0, 2400, 2401, 5, 132, 0, 0, 2401, 583, 1, 0, 0, 0, 2402, 2403, 5, 133, 0, 0, 2403, 585, 1, 0, 0, 0, 2404, 2405, 5, 135, 0, 0, 2405, 587, 1, 0, 0, 0, 2406, 2407, 5, 136, 0, 0, 2407, 589, 1, 0, 0, 0, 2408, 2409, 5, 137, 0, 0, 2409, 591, 1, 0, 0, 0, 2410, 2411, 5, 138, 0, 0, 2411, 593, 1, 0, 0, 0, 2412, 2413, 5, 139, 0, 0, 2413, 595, 1, 0, 0, 0, 2414, 2415, 5, 140, 0, 0, 2415, 597, 1, 0, 0, 0, 2416, 2417, 5, 142, 0, 0, 2417, 599, 1, 0, 0, 0, 2418, 2419, 5, 143, 0, 0, 2419, 601, 1, 0, 0, 0, 2420, 2421, 5, 144, 0, 0, 2421, 603, 1, 0, 0, 0, 2422, 2423, 5, 145, 0, 0, 2423, 605, 1, 0, 0, 0, 2424, 2425, 5, 113, 0, 0, 2425, 607, 1, 0, 0, 0, 2426, 2427, 5, 65, 0, 0, 2427, 609, 1, 0, 0, 0, 2428, 2429, 5, 1, 0, 0, 2429, 611, 1, 0, 0, 0, 2430, 2431, 5, 2, 0, 0, 2431, 613, 1, 0, 0, 0, 2432, 2433, 5, 3, 0, 0, 2433, 615, 1, 0, 0, 0, 2434, 2435, 5, 4, 0, 0, 2435, 617, 1, 0, 0, 0, 2436, 2437, 5, 20, 0, 0, 2437, 619, 1, 0, 0, 0, 2438, 2439, 5, 21, 0, 0, 2439, 621, 1, 0, 0, 0, 2440, 2441, 5, 5, 0, 0, 2441, 623, 1, 0, 0, 0, 2442, 2443, 5, 6, 0, 0, 2443, 625, 1, 0, 0, 0, 2444, 2445, 5, 7, 0, 0, 2445, 627, 1, 0, 0, 0, 2446, 2447, 5, 9, 0, 0, 2447, 629, 1, 0, 0, 0, 2448, 2449, 3, 608, 304, 0, 2449, 2450, 3, 442, 221, 0, 2450, 2456, 3, 632, 316, 0, 2451, 2452, 3, 626, 313, 0, 2452, 2453, 3, 632, 316, 0, 2453, 2455, 1, 0, 0, 0, 2454, 2451, 1, 0, 0, 0, 2455, 2458, 1, 0, 0, 0, 2456, 2454, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 631, 1, 0, 0, 0, 2458, 2456, 1, 0, 0, 0, 2459, 2460, 5, 174, 0, 0, 2460, 633, 1, 0, 0, 0, 180, 637, 640, 646, 651, 653, 658, 661, 664, 708, 712, 720, 727, 732, 748, 751, 758, 763, 774, 784, 799, 810, 819, 824, 832, 837, 841, 846, 851, 866, 872, 877, 887, 892, 909, 916, 924, 938, 943, 955, 959, 963, 968, 973, 992, 999, 1007, 1011, 1016, 1035, 1044, 1059, 1061, 1073, 1087, 1094, 1101, 1109, 1120, 1136, 1155, 1178, 1190, 1206, 1216, 1225, 1244, 1252, 1258, 1263, 1270, 1275, 1283, 1288, 1295, 1300, 1307, 1312, 1319, 1328, 1335, 1342, 1349, 1354, 1361, 1368, 1372, 1375, 1383, 1393, 1404, 1410, 1419, 1432, 1440, 1446, 1451, 1465, 1485, 1494, 1506, 1510, 1514, 1528, 1536, 1545, 1556, 1563, 1566, 1576, 1582, 1600, 1604, 1608, 1613, 1616, 1624, 1629, 1633, 1635, 1638, 1643, 1650, 1653, 1664, 1677, 1684, 1718, 1721, 1737, 1749, 1752, 1765, 1771, 1777, 1781, 1784, 1787, 1805, 1810, 1833, 1845, 1854, 1863, 1867, 1870, 1875, 1878, 1881, 1884, 1887, 1890, 1898, 1905, 1920, 1926, 1935, 1942, 1947, 1951, 1955, 1957, 1977, 2011, 2023, 2035, 2046, 2049, 2090, 2109, 2121, 2127, 2136, 2147, 2163, 2172, 2180, 2184, 2195, 2202, 2456] \ No newline at end of file diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cql_parser.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cql_parser.go index 969b3dfa..f5c0340d 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cql_parser.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cql_parser.go @@ -131,11 +131,12 @@ func cqlparserParserInit() { "distinctSpec", "selectElements", "selectElement", "selectColumn", "selectFunction", "selectIndex", "asSpec", "relationElements", "relationElement", "compareOperator", "relationFunctionCompareConstant", "relationFunctionCompareFunction", - "relationBetween", "relationCompare", "relationLike", "marker", "tupleValue", - "relationIn", "relationContains", "relationContainsKey", "functionCall", - "functionArgs", "valueAny", "constant", "decimalLiteral", "floatLiteral", - "stringLiteral", "booleanLiteral", "hexadecimalLiteral", "keyspace", - "table", "column", "dataType", "dataTypeName", "dataTypeDefinition", + "relationColumnCompareFunction", "relationFunctionCompareColumn", "relationBetween", + "relationCompare", "relationLike", "marker", "tupleValue", "relationIn", + "relationContains", "relationContainsKey", "functionCall", "functionName", + "functionArgs", "functionArg", "valueAny", "constant", "decimalLiteral", + "floatLiteral", "stringLiteral", "booleanLiteral", "hexadecimalLiteral", + "keyspace", "table", "column", "dataType", "dataTypeName", "dataTypeDefinition", "orderDirection", "role", "trigger", "triggerClass", "materializedView", "type_", "aggregate", "function_", "language", "user", "password", "hashKey", "param", "paramName", "kwAdd", "kwAggregate", "kwAll", "kwAllPermissions", @@ -160,7 +161,7 @@ func cqlparserParserInit() { } staticData.PredictionContextCache = antlr.NewPredictionContextCache() staticData.serializedATN = []int32{ - 4, 1, 181, 2458, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 4, 1, 181, 2462, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, @@ -226,1076 +227,1076 @@ func cqlparserParserInit() { 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, - 311, 7, 311, 2, 312, 7, 312, 1, 0, 4, 0, 628, 8, 0, 11, 0, 12, 0, 629, - 1, 0, 3, 0, 633, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 639, 8, 1, 1, 1, 1, - 1, 1, 1, 5, 1, 644, 8, 1, 10, 1, 12, 1, 647, 9, 1, 1, 1, 1, 1, 3, 1, 651, - 8, 1, 1, 1, 3, 1, 654, 8, 1, 1, 1, 3, 1, 657, 8, 1, 1, 2, 1, 2, 1, 3, 1, - 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, + 315, 2, 316, 7, 316, 1, 0, 4, 0, 636, 8, 0, 11, 0, 12, 0, 637, 1, 0, 3, + 0, 641, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 647, 8, 1, 1, 1, 1, 1, 1, 1, + 5, 1, 652, 8, 1, 10, 1, 12, 1, 655, 9, 1, 1, 1, 1, 1, 3, 1, 659, 8, 1, + 1, 1, 3, 1, 662, 8, 1, 1, 1, 3, 1, 665, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, - 4, 1, 4, 1, 4, 3, 4, 701, 8, 4, 1, 5, 1, 5, 3, 5, 705, 8, 5, 1, 5, 1, 5, - 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 713, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, - 3, 9, 720, 8, 9, 1, 9, 1, 9, 1, 10, 3, 10, 725, 8, 10, 1, 10, 1, 10, 1, - 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, - 1, 12, 3, 12, 741, 8, 12, 1, 12, 3, 12, 744, 8, 12, 1, 13, 1, 13, 1, 13, - 1, 13, 1, 13, 3, 13, 751, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 756, 8, 13, - 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 767, - 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 777, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 3, 4, 709, 8, 4, 1, 5, 1, 5, 3, 5, 713, 8, 5, 1, 5, 1, 5, 1, 6, + 1, 6, 1, 6, 1, 6, 3, 6, 721, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 3, 9, + 728, 8, 9, 1, 9, 1, 9, 1, 10, 3, 10, 733, 8, 10, 1, 10, 1, 10, 1, 11, 1, + 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, + 3, 12, 749, 8, 12, 1, 12, 3, 12, 752, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, + 1, 13, 3, 13, 759, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 764, 8, 13, 1, 14, + 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 775, 8, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 785, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, - 16, 1, 16, 1, 16, 1, 16, 3, 16, 792, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, - 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 803, 8, 16, 1, 16, 1, 16, 1, - 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 812, 8, 16, 1, 17, 1, 17, 1, 17, - 3, 17, 817, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 825, - 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 830, 8, 18, 1, 18, 1, 18, 3, 18, 834, - 8, 18, 1, 19, 1, 19, 1, 19, 3, 19, 839, 8, 19, 1, 19, 1, 19, 1, 19, 3, - 19, 844, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, - 1, 20, 1, 20, 1, 20, 5, 20, 857, 8, 20, 10, 20, 12, 20, 860, 9, 20, 1, - 21, 1, 21, 1, 21, 3, 21, 865, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 870, 8, - 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 880, - 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 885, 8, 22, 1, 22, 1, 22, 1, 22, 1, + 16, 1, 16, 1, 16, 1, 16, 3, 16, 800, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 811, 8, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 820, 8, 16, 1, 17, 1, 17, 1, 17, + 3, 17, 825, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 833, + 8, 17, 1, 18, 1, 18, 1, 18, 3, 18, 838, 8, 18, 1, 18, 1, 18, 3, 18, 842, + 8, 18, 1, 19, 1, 19, 1, 19, 3, 19, 847, 8, 19, 1, 19, 1, 19, 1, 19, 3, + 19, 852, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 20, 5, 20, 865, 8, 20, 10, 20, 12, 20, 868, 9, 20, 1, + 21, 1, 21, 1, 21, 3, 21, 873, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 878, 8, + 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 888, + 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 893, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, - 1, 22, 3, 22, 902, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 909, - 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 915, 8, 24, 10, 24, 12, 24, 918, + 1, 22, 3, 22, 910, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 917, + 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 923, 8, 24, 10, 24, 12, 24, 926, 9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, - 26, 1, 26, 3, 26, 931, 8, 26, 1, 27, 1, 27, 1, 27, 3, 27, 936, 8, 27, 1, + 26, 1, 26, 3, 26, 939, 8, 26, 1, 27, 1, 27, 1, 27, 3, 27, 944, 8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, - 948, 8, 27, 1, 28, 1, 28, 3, 28, 952, 8, 28, 1, 28, 1, 28, 3, 28, 956, - 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 961, 8, 28, 1, 28, 1, 28, 1, 28, 3, - 28, 966, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, - 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 983, 8, 30, 10, - 30, 12, 30, 986, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 992, 8, 31, - 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 1000, 8, 32, 1, 32, 1, - 32, 3, 32, 1004, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1009, 8, 32, 1, 32, + 956, 8, 27, 1, 28, 1, 28, 3, 28, 960, 8, 28, 1, 28, 1, 28, 3, 28, 964, + 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 969, 8, 28, 1, 28, 1, 28, 1, 28, 3, + 28, 974, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, + 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 991, 8, 30, 10, + 30, 12, 30, 994, 9, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1000, 8, 31, + 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 1008, 8, 32, 1, 32, 1, + 32, 3, 32, 1012, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1017, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, - 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1028, 8, 33, 1, 34, 1, 34, - 1, 34, 1, 34, 1, 34, 5, 34, 1035, 8, 34, 10, 34, 12, 34, 1038, 9, 34, 1, + 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1036, 8, 33, 1, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 5, 34, 1043, 8, 34, 10, 34, 12, 34, 1046, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, - 1, 36, 5, 36, 1052, 8, 36, 10, 36, 12, 36, 1055, 9, 36, 1, 36, 1, 36, 1, - 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1064, 8, 37, 10, 37, 12, 37, 1067, + 1, 36, 5, 36, 1060, 8, 36, 10, 36, 12, 36, 1063, 9, 36, 1, 36, 1, 36, 1, + 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1072, 8, 37, 10, 37, 12, 37, 1075, 9, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, - 39, 1, 39, 3, 39, 1080, 8, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, - 1087, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1094, 8, 42, 1, - 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 1102, 8, 43, 1, 44, 1, 44, - 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1111, 8, 45, 10, 45, 12, 45, - 1114, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, - 47, 1, 47, 1, 47, 5, 47, 1127, 8, 47, 10, 47, 12, 47, 1130, 9, 47, 1, 48, + 39, 1, 39, 3, 39, 1088, 8, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, + 1095, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 1102, 8, 42, 1, + 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 1110, 8, 43, 1, 44, 1, 44, + 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1119, 8, 45, 10, 45, 12, 45, + 1122, 9, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 1, 47, 1, 47, 5, 47, 1135, 8, 47, 10, 47, 12, 47, 1138, 9, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, - 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1148, 8, 50, 1, 51, 1, 51, 1, 51, + 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1156, 8, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, - 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1169, 8, 55, 10, 55, 12, - 55, 1172, 9, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, - 1181, 8, 57, 10, 57, 12, 57, 1184, 9, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, - 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1197, 8, 60, 10, 60, - 12, 60, 1200, 9, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 3, - 62, 1209, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1216, 8, 63, - 10, 63, 12, 63, 1219, 9, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, + 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1177, 8, 55, 10, 55, 12, + 55, 1180, 9, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, + 1189, 8, 57, 10, 57, 12, 57, 1192, 9, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1205, 8, 60, 10, 60, + 12, 60, 1208, 9, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 3, + 62, 1217, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1224, 8, 63, + 10, 63, 12, 63, 1227, 9, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, - 64, 1237, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1245, - 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1251, 8, 65, 1, 66, 1, 66, 1, - 66, 3, 66, 1256, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1263, - 8, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1268, 8, 67, 1, 67, 1, 67, 1, 68, 1, - 68, 1, 68, 1, 68, 3, 68, 1276, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1281, - 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1288, 8, 69, 1, 69, 1, - 69, 1, 69, 3, 69, 1293, 8, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 3, 70, - 1300, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1305, 8, 70, 1, 70, 1, 70, 1, - 71, 1, 71, 1, 71, 3, 71, 1312, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, - 1, 72, 1, 72, 3, 72, 1321, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, - 73, 1328, 8, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 3, 74, 1335, 8, 74, - 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 3, 75, 1342, 8, 75, 1, 75, 1, 75, 1, - 75, 3, 75, 1347, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1354, - 8, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1361, 8, 76, 1, 77, 1, - 77, 3, 77, 1365, 8, 77, 1, 77, 3, 77, 1368, 8, 77, 1, 78, 1, 78, 1, 78, - 1, 78, 1, 78, 1, 78, 3, 78, 1376, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, - 79, 1, 79, 5, 79, 1384, 8, 79, 10, 79, 12, 79, 1387, 9, 79, 1, 80, 1, 80, - 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1397, 8, 80, 1, 81, 1, - 81, 1, 82, 1, 82, 3, 82, 1403, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, - 5, 83, 1410, 8, 83, 10, 83, 12, 83, 1413, 9, 83, 1, 83, 1, 83, 1, 84, 1, - 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 1425, 8, 86, 1, 87, - 1, 87, 1, 87, 1, 87, 5, 87, 1431, 8, 87, 10, 87, 12, 87, 1434, 9, 87, 1, - 87, 1, 87, 1, 87, 3, 87, 1439, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1444, + 64, 1245, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1253, + 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1259, 8, 65, 1, 66, 1, 66, 1, + 66, 3, 66, 1264, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1271, + 8, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1276, 8, 67, 1, 67, 1, 67, 1, 68, 1, + 68, 1, 68, 1, 68, 3, 68, 1284, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1289, + 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1296, 8, 69, 1, 69, 1, + 69, 1, 69, 3, 69, 1301, 8, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 3, 70, + 1308, 8, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1313, 8, 70, 1, 70, 1, 70, 1, + 71, 1, 71, 1, 71, 3, 71, 1320, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, + 1, 72, 1, 72, 3, 72, 1329, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, + 73, 1336, 8, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 3, 74, 1343, 8, 74, + 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 3, 75, 1350, 8, 75, 1, 75, 1, 75, 1, + 75, 3, 75, 1355, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1362, + 8, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1369, 8, 76, 1, 77, 1, + 77, 3, 77, 1373, 8, 77, 1, 77, 3, 77, 1376, 8, 77, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 3, 78, 1384, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, + 79, 1, 79, 5, 79, 1392, 8, 79, 10, 79, 12, 79, 1395, 9, 79, 1, 80, 1, 80, + 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1405, 8, 80, 1, 81, 1, + 81, 1, 82, 1, 82, 3, 82, 1411, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, + 5, 83, 1418, 8, 83, 10, 83, 12, 83, 1421, 9, 83, 1, 83, 1, 83, 1, 84, 1, + 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 1433, 8, 86, 1, 87, + 1, 87, 1, 87, 1, 87, 5, 87, 1439, 8, 87, 10, 87, 12, 87, 1442, 9, 87, 1, + 87, 1, 87, 1, 87, 3, 87, 1447, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1452, 8, 88, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, - 91, 1, 91, 1, 91, 3, 91, 1458, 8, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, + 91, 1, 91, 1, 91, 3, 91, 1466, 8, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, - 95, 5, 95, 1476, 8, 95, 10, 95, 12, 95, 1479, 9, 95, 1, 96, 1, 96, 1, 96, - 1, 96, 5, 96, 1485, 8, 96, 10, 96, 12, 96, 1488, 9, 96, 1, 97, 1, 97, 1, - 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 1499, 8, 100, 1, - 100, 1, 100, 3, 100, 1503, 8, 100, 1, 101, 1, 101, 3, 101, 1507, 8, 101, + 95, 5, 95, 1484, 8, 95, 10, 95, 12, 95, 1487, 9, 95, 1, 96, 1, 96, 1, 96, + 1, 96, 5, 96, 1493, 8, 96, 10, 96, 12, 96, 1496, 9, 96, 1, 97, 1, 97, 1, + 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 1507, 8, 100, 1, + 100, 1, 100, 3, 100, 1511, 8, 100, 1, 101, 1, 101, 3, 101, 1515, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, - 1, 102, 1, 102, 1, 102, 3, 102, 1521, 8, 102, 1, 103, 1, 103, 1, 103, 1, - 103, 5, 103, 1527, 8, 103, 10, 103, 12, 103, 1530, 9, 103, 1, 104, 1, 104, - 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1538, 8, 104, 1, 105, 1, 105, 1, - 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 3, 107, 1549, 8, 107, - 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 1556, 8, 108, 1, 108, 3, - 108, 1559, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, - 1, 109, 3, 109, 1569, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1575, + 1, 102, 1, 102, 1, 102, 3, 102, 1529, 8, 102, 1, 103, 1, 103, 1, 103, 1, + 103, 5, 103, 1535, 8, 103, 10, 103, 12, 103, 1538, 9, 103, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1546, 8, 104, 1, 105, 1, 105, 1, + 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 3, 107, 1557, 8, 107, + 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 1564, 8, 108, 1, 108, 3, + 108, 1567, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, + 1, 109, 3, 109, 1577, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1583, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 3, 114, - 1593, 8, 114, 1, 114, 1, 114, 3, 114, 1597, 8, 114, 1, 114, 1, 114, 3, - 114, 1601, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1606, 8, 114, 1, 114, - 3, 114, 1609, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1615, 8, - 115, 10, 115, 12, 115, 1618, 9, 115, 1, 116, 1, 116, 3, 116, 1622, 8, 116, - 1, 116, 1, 116, 3, 116, 1626, 8, 116, 3, 116, 1628, 8, 116, 1, 117, 3, - 117, 1631, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1636, 8, 117, 1, 117, - 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1643, 8, 117, 1, 117, 3, 117, 1646, + 1601, 8, 114, 1, 114, 1, 114, 3, 114, 1605, 8, 114, 1, 114, 1, 114, 3, + 114, 1609, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1614, 8, 114, 1, 114, + 3, 114, 1617, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1623, 8, + 115, 10, 115, 12, 115, 1626, 9, 115, 1, 116, 1, 116, 3, 116, 1630, 8, 116, + 1, 116, 1, 116, 3, 116, 1634, 8, 116, 3, 116, 1636, 8, 116, 1, 117, 3, + 117, 1639, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1644, 8, 117, 1, 117, + 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1651, 8, 117, 1, 117, 3, 117, 1654, 8, 117, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, - 1655, 8, 119, 10, 119, 12, 119, 1658, 9, 119, 1, 120, 1, 120, 1, 120, 1, - 120, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 1668, 8, 121, 10, 121, 12, - 121, 1671, 9, 121, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1677, 8, 122, + 1663, 8, 119, 10, 119, 12, 119, 1666, 9, 119, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 1676, 8, 121, 10, 121, 12, + 121, 1679, 9, 121, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1685, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, - 1, 128, 1, 128, 1, 128, 5, 128, 1709, 8, 128, 10, 128, 12, 128, 1712, 9, - 128, 3, 128, 1714, 8, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, - 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1728, 8, 129, 10, - 129, 12, 129, 1731, 9, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, - 130, 1, 130, 5, 130, 1740, 8, 130, 10, 130, 12, 130, 1743, 9, 130, 3, 130, - 1745, 8, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, - 132, 1, 132, 5, 132, 1756, 8, 132, 10, 132, 12, 132, 1759, 9, 132, 1, 132, - 1, 132, 1, 133, 3, 133, 1764, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, - 133, 1770, 8, 133, 1, 133, 1, 133, 3, 133, 1774, 8, 133, 1, 133, 3, 133, - 1777, 8, 133, 1, 133, 3, 133, 1780, 8, 133, 1, 134, 1, 134, 1, 134, 1, + 1, 128, 1, 128, 1, 128, 5, 128, 1717, 8, 128, 10, 128, 12, 128, 1720, 9, + 128, 3, 128, 1722, 8, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1736, 8, 129, 10, + 129, 12, 129, 1739, 9, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, + 130, 1, 130, 5, 130, 1748, 8, 130, 10, 130, 12, 130, 1751, 9, 130, 3, 130, + 1753, 8, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, + 132, 1, 132, 5, 132, 1764, 8, 132, 10, 132, 12, 132, 1767, 9, 132, 1, 132, + 1, 132, 1, 133, 3, 133, 1772, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, + 133, 1778, 8, 133, 1, 133, 1, 133, 3, 133, 1782, 8, 133, 1, 133, 3, 133, + 1785, 8, 133, 1, 133, 3, 133, 1788, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, - 134, 1, 134, 1, 134, 1, 134, 3, 134, 1798, 8, 134, 1, 135, 1, 135, 1, 135, - 3, 135, 1803, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, + 134, 1, 134, 1, 134, 1, 134, 3, 134, 1806, 8, 134, 1, 135, 1, 135, 1, 135, + 3, 135, 1811, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, - 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1826, 8, 140, 1, 141, - 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 1836, 8, - 142, 10, 142, 12, 142, 1839, 9, 142, 1, 143, 1, 143, 1, 143, 1, 143, 5, - 143, 1845, 8, 143, 10, 143, 12, 143, 1848, 9, 143, 1, 144, 1, 144, 1, 144, - 1, 144, 1, 144, 1, 144, 3, 144, 1856, 8, 144, 1, 145, 1, 145, 3, 145, 1860, - 8, 145, 1, 145, 3, 145, 1863, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1868, - 8, 145, 1, 145, 3, 145, 1871, 8, 145, 1, 145, 3, 145, 1874, 8, 145, 1, - 145, 3, 145, 1877, 8, 145, 1, 145, 3, 145, 1880, 8, 145, 1, 145, 3, 145, - 1883, 8, 145, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 3, 147, 1891, - 8, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1898, 8, 149, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 1834, 8, 140, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 1844, 8, + 142, 10, 142, 12, 142, 1847, 9, 142, 1, 143, 1, 143, 1, 143, 1, 143, 5, + 143, 1853, 8, 143, 10, 143, 12, 143, 1856, 9, 143, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 144, 1, 144, 3, 144, 1864, 8, 144, 1, 145, 1, 145, 3, 145, 1868, + 8, 145, 1, 145, 3, 145, 1871, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 1876, + 8, 145, 1, 145, 3, 145, 1879, 8, 145, 1, 145, 3, 145, 1882, 8, 145, 1, + 145, 3, 145, 1885, 8, 145, 1, 145, 3, 145, 1888, 8, 145, 1, 145, 3, 145, + 1891, 8, 145, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 3, 147, 1899, + 8, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 3, 149, 1906, 8, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, - 151, 1, 151, 5, 151, 1911, 8, 151, 10, 151, 12, 151, 1914, 9, 151, 1, 152, - 1, 152, 1, 152, 3, 152, 1919, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, - 154, 1, 155, 1, 155, 3, 155, 1928, 8, 155, 1, 155, 1, 155, 1, 155, 5, 155, - 1933, 8, 155, 10, 155, 12, 155, 1936, 9, 155, 1, 156, 1, 156, 3, 156, 1940, - 8, 156, 1, 156, 1, 156, 3, 156, 1944, 8, 156, 1, 156, 1, 156, 3, 156, 1948, - 8, 156, 3, 156, 1950, 8, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, + 151, 1, 151, 5, 151, 1919, 8, 151, 10, 151, 12, 151, 1922, 9, 151, 1, 152, + 1, 152, 1, 152, 3, 152, 1927, 8, 152, 1, 153, 1, 153, 1, 153, 1, 154, 1, + 154, 1, 155, 1, 155, 3, 155, 1936, 8, 155, 1, 155, 1, 155, 1, 155, 5, 155, + 1941, 8, 155, 10, 155, 12, 155, 1944, 9, 155, 1, 156, 1, 156, 3, 156, 1948, + 8, 156, 1, 156, 1, 156, 3, 156, 1952, 8, 156, 1, 156, 1, 156, 3, 156, 1956, + 8, 156, 3, 156, 1958, 8, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, - 161, 1, 161, 5, 161, 1968, 8, 161, 10, 161, 12, 161, 1971, 9, 161, 1, 162, + 161, 1, 161, 5, 161, 1976, 8, 161, 10, 161, 12, 161, 1979, 9, 161, 1, 162, + 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, - 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, - 2000, 8, 162, 10, 162, 12, 162, 2003, 9, 162, 1, 162, 1, 162, 1, 162, 1, - 162, 1, 162, 1, 162, 1, 162, 5, 162, 2012, 8, 162, 10, 162, 12, 162, 2015, - 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, - 2024, 8, 162, 10, 162, 12, 162, 2027, 9, 162, 1, 162, 1, 162, 1, 162, 1, - 162, 1, 162, 1, 162, 5, 162, 2035, 8, 162, 10, 162, 12, 162, 2038, 9, 162, - 3, 162, 2040, 8, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, - 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, - 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, - 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2073, 8, 170, - 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, - 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, - 1, 174, 1, 174, 1, 174, 3, 174, 2096, 8, 174, 1, 174, 1, 174, 1, 174, 1, - 174, 1, 174, 1, 174, 1, 174, 3, 174, 2105, 8, 174, 1, 174, 3, 174, 2108, - 8, 174, 1, 175, 1, 175, 1, 175, 3, 175, 2113, 8, 175, 1, 175, 1, 175, 1, - 175, 1, 175, 3, 175, 2119, 8, 175, 5, 175, 2121, 8, 175, 10, 175, 12, 175, - 2124, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, - 176, 2133, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, - 1, 177, 1, 177, 3, 177, 2144, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 1, - 180, 1, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, - 183, 3, 183, 2160, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, - 1, 184, 3, 184, 2169, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, - 185, 3, 185, 2177, 8, 185, 1, 186, 1, 186, 3, 186, 2181, 8, 186, 1, 187, - 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 5, 188, 2190, 8, 188, 10, - 188, 12, 188, 2193, 9, 188, 1, 188, 1, 188, 1, 189, 1, 189, 3, 189, 2199, - 8, 189, 1, 190, 1, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 193, 1, 193, - 1, 194, 1, 194, 1, 195, 1, 195, 1, 196, 1, 196, 1, 197, 1, 197, 1, 198, - 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, - 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 205, 1, 205, 1, 206, 1, 206, - 1, 206, 1, 207, 1, 207, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, - 1, 211, 1, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 214, 1, 214, 1, 215, - 1, 215, 1, 216, 1, 216, 1, 217, 1, 217, 1, 218, 1, 218, 1, 219, 1, 219, - 1, 220, 1, 220, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, 1, 224, - 1, 224, 1, 225, 1, 225, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, - 1, 229, 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, - 1, 233, 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 237, 1, 237, - 1, 238, 1, 238, 1, 239, 1, 239, 1, 240, 1, 240, 1, 241, 1, 241, 1, 242, - 1, 242, 1, 243, 1, 243, 1, 244, 1, 244, 1, 245, 1, 245, 1, 246, 1, 246, - 1, 247, 1, 247, 1, 248, 1, 248, 1, 249, 1, 249, 1, 250, 1, 250, 1, 251, - 1, 251, 1, 252, 1, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 255, 1, 255, - 1, 256, 1, 256, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 260, - 1, 260, 1, 261, 1, 261, 1, 262, 1, 262, 1, 263, 1, 263, 1, 264, 1, 264, - 1, 265, 1, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 268, 1, 268, 1, 269, - 1, 269, 1, 270, 1, 270, 1, 271, 1, 271, 1, 272, 1, 272, 1, 273, 1, 273, - 1, 274, 1, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 277, 1, 277, 1, 278, - 1, 278, 1, 279, 1, 279, 1, 280, 1, 280, 1, 281, 1, 281, 1, 282, 1, 282, - 1, 283, 1, 283, 1, 284, 1, 284, 1, 285, 1, 285, 1, 286, 1, 286, 1, 287, - 1, 287, 1, 288, 1, 288, 1, 289, 1, 289, 1, 290, 1, 290, 1, 291, 1, 291, - 1, 292, 1, 292, 1, 293, 1, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 296, - 1, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 300, 1, 300, - 1, 301, 1, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 304, 1, 304, 1, 305, - 1, 305, 1, 306, 1, 306, 1, 307, 1, 307, 1, 308, 1, 308, 1, 309, 1, 309, - 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, - 2451, 8, 311, 10, 311, 12, 311, 2454, 9, 311, 1, 312, 1, 312, 1, 312, 0, - 0, 313, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, - 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, - 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, - 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, - 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, - 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, - 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, - 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, - 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, - 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, - 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, - 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, - 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, - 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, - 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, - 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, - 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, - 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, - 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, - 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, - 616, 618, 620, 622, 624, 0, 8, 1, 0, 168, 169, 2, 0, 14, 14, 16, 16, 1, - 0, 19, 23, 1, 0, 176, 177, 1, 0, 170, 171, 2, 0, 57, 57, 131, 131, 6, 0, - 84, 84, 118, 118, 127, 127, 141, 141, 147, 167, 174, 174, 2, 0, 71, 71, - 174, 174, 2435, 0, 627, 1, 0, 0, 0, 2, 645, 1, 0, 0, 0, 4, 658, 1, 0, 0, - 0, 6, 660, 1, 0, 0, 0, 8, 700, 1, 0, 0, 0, 10, 704, 1, 0, 0, 0, 12, 712, - 1, 0, 0, 0, 14, 714, 1, 0, 0, 0, 16, 716, 1, 0, 0, 0, 18, 719, 1, 0, 0, - 0, 20, 724, 1, 0, 0, 0, 22, 728, 1, 0, 0, 0, 24, 735, 1, 0, 0, 0, 26, 745, - 1, 0, 0, 0, 28, 757, 1, 0, 0, 0, 30, 776, 1, 0, 0, 0, 32, 811, 1, 0, 0, - 0, 34, 813, 1, 0, 0, 0, 36, 826, 1, 0, 0, 0, 38, 835, 1, 0, 0, 0, 40, 850, - 1, 0, 0, 0, 42, 861, 1, 0, 0, 0, 44, 875, 1, 0, 0, 0, 46, 903, 1, 0, 0, - 0, 48, 910, 1, 0, 0, 0, 50, 919, 1, 0, 0, 0, 52, 930, 1, 0, 0, 0, 54, 932, - 1, 0, 0, 0, 56, 949, 1, 0, 0, 0, 58, 976, 1, 0, 0, 0, 60, 978, 1, 0, 0, - 0, 62, 991, 1, 0, 0, 0, 64, 997, 1, 0, 0, 0, 66, 1027, 1, 0, 0, 0, 68, - 1029, 1, 0, 0, 0, 70, 1041, 1, 0, 0, 0, 72, 1045, 1, 0, 0, 0, 74, 1058, - 1, 0, 0, 0, 76, 1070, 1, 0, 0, 0, 78, 1073, 1, 0, 0, 0, 80, 1081, 1, 0, - 0, 0, 82, 1086, 1, 0, 0, 0, 84, 1088, 1, 0, 0, 0, 86, 1101, 1, 0, 0, 0, - 88, 1103, 1, 0, 0, 0, 90, 1106, 1, 0, 0, 0, 92, 1115, 1, 0, 0, 0, 94, 1119, - 1, 0, 0, 0, 96, 1131, 1, 0, 0, 0, 98, 1136, 1, 0, 0, 0, 100, 1147, 1, 0, - 0, 0, 102, 1149, 1, 0, 0, 0, 104, 1152, 1, 0, 0, 0, 106, 1157, 1, 0, 0, - 0, 108, 1161, 1, 0, 0, 0, 110, 1164, 1, 0, 0, 0, 112, 1173, 1, 0, 0, 0, - 114, 1176, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1189, 1, 0, 0, 0, 120, - 1192, 1, 0, 0, 0, 122, 1201, 1, 0, 0, 0, 124, 1204, 1, 0, 0, 0, 126, 1210, - 1, 0, 0, 0, 128, 1236, 1, 0, 0, 0, 130, 1238, 1, 0, 0, 0, 132, 1252, 1, - 0, 0, 0, 134, 1259, 1, 0, 0, 0, 136, 1271, 1, 0, 0, 0, 138, 1284, 1, 0, - 0, 0, 140, 1296, 1, 0, 0, 0, 142, 1308, 1, 0, 0, 0, 144, 1317, 1, 0, 0, - 0, 146, 1324, 1, 0, 0, 0, 148, 1331, 1, 0, 0, 0, 150, 1338, 1, 0, 0, 0, - 152, 1350, 1, 0, 0, 0, 154, 1362, 1, 0, 0, 0, 156, 1369, 1, 0, 0, 0, 158, - 1379, 1, 0, 0, 0, 160, 1396, 1, 0, 0, 0, 162, 1398, 1, 0, 0, 0, 164, 1402, - 1, 0, 0, 0, 166, 1404, 1, 0, 0, 0, 168, 1416, 1, 0, 0, 0, 170, 1420, 1, - 0, 0, 0, 172, 1424, 1, 0, 0, 0, 174, 1426, 1, 0, 0, 0, 176, 1440, 1, 0, - 0, 0, 178, 1445, 1, 0, 0, 0, 180, 1448, 1, 0, 0, 0, 182, 1457, 1, 0, 0, - 0, 184, 1459, 1, 0, 0, 0, 186, 1461, 1, 0, 0, 0, 188, 1465, 1, 0, 0, 0, - 190, 1471, 1, 0, 0, 0, 192, 1480, 1, 0, 0, 0, 194, 1489, 1, 0, 0, 0, 196, - 1491, 1, 0, 0, 0, 198, 1493, 1, 0, 0, 0, 200, 1496, 1, 0, 0, 0, 202, 1506, - 1, 0, 0, 0, 204, 1508, 1, 0, 0, 0, 206, 1522, 1, 0, 0, 0, 208, 1537, 1, - 0, 0, 0, 210, 1539, 1, 0, 0, 0, 212, 1543, 1, 0, 0, 0, 214, 1546, 1, 0, - 0, 0, 216, 1552, 1, 0, 0, 0, 218, 1568, 1, 0, 0, 0, 220, 1574, 1, 0, 0, - 0, 222, 1576, 1, 0, 0, 0, 224, 1581, 1, 0, 0, 0, 226, 1586, 1, 0, 0, 0, - 228, 1592, 1, 0, 0, 0, 230, 1610, 1, 0, 0, 0, 232, 1627, 1, 0, 0, 0, 234, - 1630, 1, 0, 0, 0, 236, 1647, 1, 0, 0, 0, 238, 1650, 1, 0, 0, 0, 240, 1659, - 1, 0, 0, 0, 242, 1663, 1, 0, 0, 0, 244, 1676, 1, 0, 0, 0, 246, 1678, 1, - 0, 0, 0, 248, 1682, 1, 0, 0, 0, 250, 1688, 1, 0, 0, 0, 252, 1694, 1, 0, - 0, 0, 254, 1698, 1, 0, 0, 0, 256, 1703, 1, 0, 0, 0, 258, 1717, 1, 0, 0, - 0, 260, 1734, 1, 0, 0, 0, 262, 1748, 1, 0, 0, 0, 264, 1750, 1, 0, 0, 0, - 266, 1763, 1, 0, 0, 0, 268, 1797, 1, 0, 0, 0, 270, 1799, 1, 0, 0, 0, 272, - 1804, 1, 0, 0, 0, 274, 1807, 1, 0, 0, 0, 276, 1810, 1, 0, 0, 0, 278, 1814, - 1, 0, 0, 0, 280, 1825, 1, 0, 0, 0, 282, 1827, 1, 0, 0, 0, 284, 1831, 1, - 0, 0, 0, 286, 1840, 1, 0, 0, 0, 288, 1855, 1, 0, 0, 0, 290, 1857, 1, 0, - 0, 0, 292, 1884, 1, 0, 0, 0, 294, 1887, 1, 0, 0, 0, 296, 1892, 1, 0, 0, - 0, 298, 1897, 1, 0, 0, 0, 300, 1901, 1, 0, 0, 0, 302, 1904, 1, 0, 0, 0, - 304, 1915, 1, 0, 0, 0, 306, 1920, 1, 0, 0, 0, 308, 1923, 1, 0, 0, 0, 310, - 1927, 1, 0, 0, 0, 312, 1949, 1, 0, 0, 0, 314, 1951, 1, 0, 0, 0, 316, 1953, - 1, 0, 0, 0, 318, 1955, 1, 0, 0, 0, 320, 1960, 1, 0, 0, 0, 322, 1963, 1, - 0, 0, 0, 324, 2039, 1, 0, 0, 0, 326, 2041, 1, 0, 0, 0, 328, 2043, 1, 0, - 0, 0, 330, 2047, 1, 0, 0, 0, 332, 2051, 1, 0, 0, 0, 334, 2057, 1, 0, 0, - 0, 336, 2061, 1, 0, 0, 0, 338, 2065, 1, 0, 0, 0, 340, 2072, 1, 0, 0, 0, - 342, 2074, 1, 0, 0, 0, 344, 2078, 1, 0, 0, 0, 346, 2082, 1, 0, 0, 0, 348, - 2107, 1, 0, 0, 0, 350, 2112, 1, 0, 0, 0, 352, 2132, 1, 0, 0, 0, 354, 2143, - 1, 0, 0, 0, 356, 2145, 1, 0, 0, 0, 358, 2147, 1, 0, 0, 0, 360, 2149, 1, - 0, 0, 0, 362, 2151, 1, 0, 0, 0, 364, 2153, 1, 0, 0, 0, 366, 2159, 1, 0, - 0, 0, 368, 2168, 1, 0, 0, 0, 370, 2176, 1, 0, 0, 0, 372, 2178, 1, 0, 0, - 0, 374, 2182, 1, 0, 0, 0, 376, 2184, 1, 0, 0, 0, 378, 2198, 1, 0, 0, 0, - 380, 2200, 1, 0, 0, 0, 382, 2202, 1, 0, 0, 0, 384, 2204, 1, 0, 0, 0, 386, - 2206, 1, 0, 0, 0, 388, 2208, 1, 0, 0, 0, 390, 2210, 1, 0, 0, 0, 392, 2212, - 1, 0, 0, 0, 394, 2214, 1, 0, 0, 0, 396, 2216, 1, 0, 0, 0, 398, 2218, 1, - 0, 0, 0, 400, 2220, 1, 0, 0, 0, 402, 2222, 1, 0, 0, 0, 404, 2225, 1, 0, - 0, 0, 406, 2227, 1, 0, 0, 0, 408, 2229, 1, 0, 0, 0, 410, 2231, 1, 0, 0, - 0, 412, 2233, 1, 0, 0, 0, 414, 2236, 1, 0, 0, 0, 416, 2238, 1, 0, 0, 0, - 418, 2240, 1, 0, 0, 0, 420, 2242, 1, 0, 0, 0, 422, 2244, 1, 0, 0, 0, 424, - 2246, 1, 0, 0, 0, 426, 2248, 1, 0, 0, 0, 428, 2250, 1, 0, 0, 0, 430, 2252, - 1, 0, 0, 0, 432, 2254, 1, 0, 0, 0, 434, 2256, 1, 0, 0, 0, 436, 2258, 1, - 0, 0, 0, 438, 2260, 1, 0, 0, 0, 440, 2262, 1, 0, 0, 0, 442, 2264, 1, 0, - 0, 0, 444, 2266, 1, 0, 0, 0, 446, 2268, 1, 0, 0, 0, 448, 2270, 1, 0, 0, - 0, 450, 2272, 1, 0, 0, 0, 452, 2274, 1, 0, 0, 0, 454, 2276, 1, 0, 0, 0, - 456, 2278, 1, 0, 0, 0, 458, 2280, 1, 0, 0, 0, 460, 2282, 1, 0, 0, 0, 462, - 2284, 1, 0, 0, 0, 464, 2286, 1, 0, 0, 0, 466, 2288, 1, 0, 0, 0, 468, 2290, - 1, 0, 0, 0, 470, 2292, 1, 0, 0, 0, 472, 2294, 1, 0, 0, 0, 474, 2296, 1, - 0, 0, 0, 476, 2298, 1, 0, 0, 0, 478, 2300, 1, 0, 0, 0, 480, 2302, 1, 0, - 0, 0, 482, 2304, 1, 0, 0, 0, 484, 2306, 1, 0, 0, 0, 486, 2308, 1, 0, 0, - 0, 488, 2310, 1, 0, 0, 0, 490, 2312, 1, 0, 0, 0, 492, 2314, 1, 0, 0, 0, - 494, 2316, 1, 0, 0, 0, 496, 2318, 1, 0, 0, 0, 498, 2320, 1, 0, 0, 0, 500, - 2322, 1, 0, 0, 0, 502, 2324, 1, 0, 0, 0, 504, 2326, 1, 0, 0, 0, 506, 2328, - 1, 0, 0, 0, 508, 2330, 1, 0, 0, 0, 510, 2332, 1, 0, 0, 0, 512, 2334, 1, - 0, 0, 0, 514, 2336, 1, 0, 0, 0, 516, 2338, 1, 0, 0, 0, 518, 2340, 1, 0, - 0, 0, 520, 2342, 1, 0, 0, 0, 522, 2344, 1, 0, 0, 0, 524, 2346, 1, 0, 0, - 0, 526, 2348, 1, 0, 0, 0, 528, 2350, 1, 0, 0, 0, 530, 2352, 1, 0, 0, 0, - 532, 2354, 1, 0, 0, 0, 534, 2356, 1, 0, 0, 0, 536, 2358, 1, 0, 0, 0, 538, - 2360, 1, 0, 0, 0, 540, 2362, 1, 0, 0, 0, 542, 2364, 1, 0, 0, 0, 544, 2366, - 1, 0, 0, 0, 546, 2368, 1, 0, 0, 0, 548, 2370, 1, 0, 0, 0, 550, 2372, 1, - 0, 0, 0, 552, 2374, 1, 0, 0, 0, 554, 2376, 1, 0, 0, 0, 556, 2378, 1, 0, - 0, 0, 558, 2380, 1, 0, 0, 0, 560, 2382, 1, 0, 0, 0, 562, 2384, 1, 0, 0, - 0, 564, 2386, 1, 0, 0, 0, 566, 2388, 1, 0, 0, 0, 568, 2390, 1, 0, 0, 0, - 570, 2392, 1, 0, 0, 0, 572, 2394, 1, 0, 0, 0, 574, 2396, 1, 0, 0, 0, 576, - 2398, 1, 0, 0, 0, 578, 2400, 1, 0, 0, 0, 580, 2402, 1, 0, 0, 0, 582, 2404, - 1, 0, 0, 0, 584, 2406, 1, 0, 0, 0, 586, 2408, 1, 0, 0, 0, 588, 2410, 1, - 0, 0, 0, 590, 2412, 1, 0, 0, 0, 592, 2414, 1, 0, 0, 0, 594, 2416, 1, 0, - 0, 0, 596, 2418, 1, 0, 0, 0, 598, 2420, 1, 0, 0, 0, 600, 2422, 1, 0, 0, - 0, 602, 2424, 1, 0, 0, 0, 604, 2426, 1, 0, 0, 0, 606, 2428, 1, 0, 0, 0, - 608, 2430, 1, 0, 0, 0, 610, 2432, 1, 0, 0, 0, 612, 2434, 1, 0, 0, 0, 614, - 2436, 1, 0, 0, 0, 616, 2438, 1, 0, 0, 0, 618, 2440, 1, 0, 0, 0, 620, 2442, - 1, 0, 0, 0, 622, 2444, 1, 0, 0, 0, 624, 2455, 1, 0, 0, 0, 626, 628, 3, - 2, 1, 0, 627, 626, 1, 0, 0, 0, 628, 629, 1, 0, 0, 0, 629, 627, 1, 0, 0, - 0, 629, 630, 1, 0, 0, 0, 630, 632, 1, 0, 0, 0, 631, 633, 5, 15, 0, 0, 632, - 631, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 635, - 5, 0, 0, 1, 635, 1, 1, 0, 0, 0, 636, 638, 3, 8, 4, 0, 637, 639, 5, 15, - 0, 0, 638, 637, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, - 640, 641, 3, 4, 2, 0, 641, 644, 1, 0, 0, 0, 642, 644, 3, 6, 3, 0, 643, - 636, 1, 0, 0, 0, 643, 642, 1, 0, 0, 0, 644, 647, 1, 0, 0, 0, 645, 643, - 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 656, 1, 0, 0, 0, 647, 645, 1, 0, - 0, 0, 648, 653, 3, 8, 4, 0, 649, 651, 5, 15, 0, 0, 650, 649, 1, 0, 0, 0, - 650, 651, 1, 0, 0, 0, 651, 652, 1, 0, 0, 0, 652, 654, 3, 4, 2, 0, 653, - 650, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 657, 1, 0, 0, 0, 655, 657, - 3, 6, 3, 0, 656, 648, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 3, 1, 0, 0, - 0, 658, 659, 5, 8, 0, 0, 659, 5, 1, 0, 0, 0, 660, 661, 3, 4, 2, 0, 661, - 7, 1, 0, 0, 0, 662, 701, 3, 204, 102, 0, 663, 701, 3, 130, 65, 0, 664, - 701, 3, 124, 62, 0, 665, 701, 3, 98, 49, 0, 666, 701, 3, 84, 42, 0, 667, - 701, 3, 78, 39, 0, 668, 701, 3, 198, 99, 0, 669, 701, 3, 64, 32, 0, 670, - 701, 3, 56, 28, 0, 671, 701, 3, 216, 108, 0, 672, 701, 3, 54, 27, 0, 673, - 701, 3, 44, 22, 0, 674, 701, 3, 36, 18, 0, 675, 701, 3, 152, 76, 0, 676, - 701, 3, 42, 21, 0, 677, 701, 3, 38, 19, 0, 678, 701, 3, 34, 17, 0, 679, - 701, 3, 228, 114, 0, 680, 701, 3, 138, 69, 0, 681, 701, 3, 140, 70, 0, - 682, 701, 3, 150, 75, 0, 683, 701, 3, 148, 74, 0, 684, 701, 3, 136, 68, - 0, 685, 701, 3, 144, 72, 0, 686, 701, 3, 146, 73, 0, 687, 701, 3, 142, - 71, 0, 688, 701, 3, 134, 67, 0, 689, 701, 3, 132, 66, 0, 690, 701, 3, 28, - 14, 0, 691, 701, 3, 266, 133, 0, 692, 701, 3, 26, 13, 0, 693, 701, 3, 24, - 12, 0, 694, 701, 3, 22, 11, 0, 695, 701, 3, 290, 145, 0, 696, 701, 3, 214, - 107, 0, 697, 701, 3, 234, 117, 0, 698, 701, 3, 212, 106, 0, 699, 701, 3, - 10, 5, 0, 700, 662, 1, 0, 0, 0, 700, 663, 1, 0, 0, 0, 700, 664, 1, 0, 0, - 0, 700, 665, 1, 0, 0, 0, 700, 666, 1, 0, 0, 0, 700, 667, 1, 0, 0, 0, 700, - 668, 1, 0, 0, 0, 700, 669, 1, 0, 0, 0, 700, 670, 1, 0, 0, 0, 700, 671, - 1, 0, 0, 0, 700, 672, 1, 0, 0, 0, 700, 673, 1, 0, 0, 0, 700, 674, 1, 0, - 0, 0, 700, 675, 1, 0, 0, 0, 700, 676, 1, 0, 0, 0, 700, 677, 1, 0, 0, 0, - 700, 678, 1, 0, 0, 0, 700, 679, 1, 0, 0, 0, 700, 680, 1, 0, 0, 0, 700, - 681, 1, 0, 0, 0, 700, 682, 1, 0, 0, 0, 700, 683, 1, 0, 0, 0, 700, 684, - 1, 0, 0, 0, 700, 685, 1, 0, 0, 0, 700, 686, 1, 0, 0, 0, 700, 687, 1, 0, - 0, 0, 700, 688, 1, 0, 0, 0, 700, 689, 1, 0, 0, 0, 700, 690, 1, 0, 0, 0, - 700, 691, 1, 0, 0, 0, 700, 692, 1, 0, 0, 0, 700, 693, 1, 0, 0, 0, 700, - 694, 1, 0, 0, 0, 700, 695, 1, 0, 0, 0, 700, 696, 1, 0, 0, 0, 700, 697, - 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 700, 699, 1, 0, 0, 0, 701, 9, 1, 0, 0, - 0, 702, 705, 3, 448, 224, 0, 703, 705, 3, 450, 225, 0, 704, 702, 1, 0, - 0, 0, 704, 703, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 707, 3, 12, 6, 0, - 707, 11, 1, 0, 0, 0, 708, 713, 3, 14, 7, 0, 709, 713, 3, 16, 8, 0, 710, - 713, 3, 18, 9, 0, 711, 713, 3, 20, 10, 0, 712, 708, 1, 0, 0, 0, 712, 709, - 1, 0, 0, 0, 712, 710, 1, 0, 0, 0, 712, 711, 1, 0, 0, 0, 713, 13, 1, 0, - 0, 0, 714, 715, 3, 502, 251, 0, 715, 15, 1, 0, 0, 0, 716, 717, 3, 566, - 283, 0, 717, 17, 1, 0, 0, 0, 718, 720, 3, 564, 282, 0, 719, 718, 1, 0, - 0, 0, 719, 720, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 722, 3, 298, 149, - 0, 722, 19, 1, 0, 0, 0, 723, 725, 3, 500, 250, 0, 724, 723, 1, 0, 0, 0, - 724, 725, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 727, 3, 366, 183, 0, 727, - 21, 1, 0, 0, 0, 728, 729, 3, 598, 299, 0, 729, 730, 3, 30, 15, 0, 730, - 731, 3, 528, 264, 0, 731, 732, 3, 32, 16, 0, 732, 733, 3, 468, 234, 0, - 733, 734, 3, 380, 190, 0, 734, 23, 1, 0, 0, 0, 735, 736, 3, 508, 254, 0, - 736, 740, 3, 550, 275, 0, 737, 738, 3, 526, 263, 0, 738, 739, 3, 380, 190, - 0, 739, 741, 1, 0, 0, 0, 740, 737, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, - 743, 1, 0, 0, 0, 742, 744, 3, 520, 260, 0, 743, 742, 1, 0, 0, 0, 743, 744, - 1, 0, 0, 0, 744, 25, 1, 0, 0, 0, 745, 746, 3, 508, 254, 0, 746, 750, 3, - 30, 15, 0, 747, 748, 3, 528, 264, 0, 748, 749, 3, 32, 16, 0, 749, 751, - 1, 0, 0, 0, 750, 747, 1, 0, 0, 0, 750, 751, 1, 0, 0, 0, 751, 755, 1, 0, - 0, 0, 752, 753, 3, 526, 263, 0, 753, 754, 3, 380, 190, 0, 754, 756, 1, - 0, 0, 0, 755, 752, 1, 0, 0, 0, 755, 756, 1, 0, 0, 0, 756, 27, 1, 0, 0, - 0, 757, 758, 3, 476, 238, 0, 758, 759, 3, 30, 15, 0, 759, 760, 3, 528, - 264, 0, 760, 761, 3, 32, 16, 0, 761, 762, 3, 570, 285, 0, 762, 763, 3, - 380, 190, 0, 763, 29, 1, 0, 0, 0, 764, 767, 3, 410, 205, 0, 765, 767, 3, - 412, 206, 0, 766, 764, 1, 0, 0, 0, 766, 765, 1, 0, 0, 0, 767, 777, 1, 0, - 0, 0, 768, 777, 3, 416, 208, 0, 769, 777, 3, 426, 213, 0, 770, 777, 3, - 450, 225, 0, 771, 777, 3, 460, 230, 0, 772, 777, 3, 444, 222, 0, 773, 777, - 3, 454, 227, 0, 774, 777, 3, 516, 258, 0, 775, 777, 3, 552, 276, 0, 776, - 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, - 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 776, 772, 1, 0, 0, 0, 776, 773, 1, 0, - 0, 0, 776, 774, 1, 0, 0, 0, 776, 775, 1, 0, 0, 0, 777, 31, 1, 0, 0, 0, - 778, 779, 3, 410, 205, 0, 779, 780, 3, 474, 237, 0, 780, 812, 1, 0, 0, - 0, 781, 782, 3, 410, 205, 0, 782, 783, 3, 474, 237, 0, 783, 784, 3, 480, - 240, 0, 784, 785, 3, 500, 250, 0, 785, 786, 3, 366, 183, 0, 786, 812, 1, - 0, 0, 0, 787, 791, 3, 472, 236, 0, 788, 789, 3, 366, 183, 0, 789, 790, - 5, 10, 0, 0, 790, 792, 1, 0, 0, 0, 791, 788, 1, 0, 0, 0, 791, 792, 1, 0, - 0, 0, 792, 793, 1, 0, 0, 0, 793, 794, 3, 392, 196, 0, 794, 812, 1, 0, 0, - 0, 795, 796, 3, 410, 205, 0, 796, 797, 3, 502, 251, 0, 797, 812, 1, 0, - 0, 0, 798, 799, 3, 500, 250, 0, 799, 800, 3, 366, 183, 0, 800, 812, 1, - 0, 0, 0, 801, 803, 3, 564, 282, 0, 802, 801, 1, 0, 0, 0, 802, 803, 1, 0, - 0, 0, 803, 804, 1, 0, 0, 0, 804, 812, 3, 298, 149, 0, 805, 806, 3, 410, - 205, 0, 806, 807, 3, 550, 275, 0, 807, 812, 1, 0, 0, 0, 808, 809, 3, 548, - 274, 0, 809, 810, 3, 380, 190, 0, 810, 812, 1, 0, 0, 0, 811, 778, 1, 0, - 0, 0, 811, 781, 1, 0, 0, 0, 811, 787, 1, 0, 0, 0, 811, 795, 1, 0, 0, 0, - 811, 798, 1, 0, 0, 0, 811, 802, 1, 0, 0, 0, 811, 805, 1, 0, 0, 0, 811, - 808, 1, 0, 0, 0, 812, 33, 1, 0, 0, 0, 813, 814, 3, 444, 222, 0, 814, 816, - 3, 586, 293, 0, 815, 817, 3, 276, 138, 0, 816, 815, 1, 0, 0, 0, 816, 817, - 1, 0, 0, 0, 817, 818, 1, 0, 0, 0, 818, 819, 3, 396, 198, 0, 819, 820, 3, - 596, 298, 0, 820, 821, 3, 536, 268, 0, 821, 824, 3, 360, 180, 0, 822, 825, - 3, 562, 281, 0, 823, 825, 3, 518, 259, 0, 824, 822, 1, 0, 0, 0, 824, 823, - 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 35, 1, 0, 0, 0, 826, 827, 3, 444, - 222, 0, 827, 829, 3, 548, 274, 0, 828, 830, 3, 276, 138, 0, 829, 828, 1, - 0, 0, 0, 829, 830, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 833, 3, 380, - 190, 0, 832, 834, 3, 126, 63, 0, 833, 832, 1, 0, 0, 0, 833, 834, 1, 0, - 0, 0, 834, 37, 1, 0, 0, 0, 835, 836, 3, 444, 222, 0, 836, 838, 3, 578, - 289, 0, 837, 839, 3, 276, 138, 0, 838, 837, 1, 0, 0, 0, 838, 839, 1, 0, - 0, 0, 839, 843, 1, 0, 0, 0, 840, 841, 3, 366, 183, 0, 841, 842, 5, 10, - 0, 0, 842, 844, 1, 0, 0, 0, 843, 840, 1, 0, 0, 0, 843, 844, 1, 0, 0, 0, - 844, 845, 1, 0, 0, 0, 845, 846, 3, 388, 194, 0, 846, 847, 3, 602, 301, - 0, 847, 848, 3, 40, 20, 0, 848, 849, 3, 604, 302, 0, 849, 39, 1, 0, 0, - 0, 850, 851, 3, 370, 185, 0, 851, 858, 3, 372, 186, 0, 852, 853, 3, 618, - 309, 0, 853, 854, 3, 370, 185, 0, 854, 855, 3, 372, 186, 0, 855, 857, 1, - 0, 0, 0, 856, 852, 1, 0, 0, 0, 857, 860, 1, 0, 0, 0, 858, 856, 1, 0, 0, - 0, 858, 859, 1, 0, 0, 0, 859, 41, 1, 0, 0, 0, 860, 858, 1, 0, 0, 0, 861, - 862, 3, 444, 222, 0, 862, 864, 3, 572, 286, 0, 863, 865, 3, 276, 138, 0, - 864, 863, 1, 0, 0, 0, 864, 865, 1, 0, 0, 0, 865, 869, 1, 0, 0, 0, 866, - 867, 3, 366, 183, 0, 867, 868, 5, 10, 0, 0, 868, 870, 1, 0, 0, 0, 869, - 866, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 871, 1, 0, 0, 0, 871, 872, - 3, 382, 191, 0, 872, 873, 3, 588, 294, 0, 873, 874, 3, 384, 192, 0, 874, - 43, 1, 0, 0, 0, 875, 876, 3, 444, 222, 0, 876, 877, 3, 514, 257, 0, 877, - 879, 3, 592, 296, 0, 878, 880, 3, 276, 138, 0, 879, 878, 1, 0, 0, 0, 879, - 880, 1, 0, 0, 0, 880, 884, 1, 0, 0, 0, 881, 882, 3, 366, 183, 0, 882, 883, - 5, 10, 0, 0, 883, 885, 1, 0, 0, 0, 884, 881, 1, 0, 0, 0, 884, 885, 1, 0, - 0, 0, 885, 886, 1, 0, 0, 0, 886, 887, 3, 386, 193, 0, 887, 888, 3, 422, - 211, 0, 888, 889, 3, 552, 276, 0, 889, 890, 3, 284, 142, 0, 890, 891, 3, - 468, 234, 0, 891, 892, 3, 298, 149, 0, 892, 893, 3, 46, 23, 0, 893, 894, - 3, 538, 269, 0, 894, 895, 3, 496, 248, 0, 895, 896, 3, 602, 301, 0, 896, - 897, 3, 284, 142, 0, 897, 901, 3, 604, 302, 0, 898, 899, 3, 596, 298, 0, - 899, 900, 3, 52, 26, 0, 900, 902, 1, 0, 0, 0, 901, 898, 1, 0, 0, 0, 901, - 902, 1, 0, 0, 0, 902, 45, 1, 0, 0, 0, 903, 904, 3, 594, 297, 0, 904, 908, - 3, 48, 24, 0, 905, 906, 3, 418, 209, 0, 906, 907, 3, 322, 161, 0, 907, - 909, 1, 0, 0, 0, 908, 905, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 47, 1, - 0, 0, 0, 910, 916, 3, 50, 25, 0, 911, 912, 3, 418, 209, 0, 912, 913, 3, - 50, 25, 0, 913, 915, 1, 0, 0, 0, 914, 911, 1, 0, 0, 0, 915, 918, 1, 0, - 0, 0, 916, 914, 1, 0, 0, 0, 916, 917, 1, 0, 0, 0, 917, 49, 1, 0, 0, 0, - 918, 916, 1, 0, 0, 0, 919, 920, 3, 370, 185, 0, 920, 921, 3, 492, 246, - 0, 921, 922, 3, 522, 261, 0, 922, 923, 3, 524, 262, 0, 923, 51, 1, 0, 0, - 0, 924, 931, 3, 158, 79, 0, 925, 926, 3, 158, 79, 0, 926, 927, 3, 418, - 209, 0, 927, 928, 3, 156, 78, 0, 928, 931, 1, 0, 0, 0, 929, 931, 3, 156, - 78, 0, 930, 924, 1, 0, 0, 0, 930, 925, 1, 0, 0, 0, 930, 929, 1, 0, 0, 0, - 931, 53, 1, 0, 0, 0, 932, 933, 3, 444, 222, 0, 933, 935, 3, 500, 250, 0, - 934, 936, 3, 276, 138, 0, 935, 934, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, - 937, 1, 0, 0, 0, 937, 938, 3, 366, 183, 0, 938, 939, 3, 596, 298, 0, 939, - 940, 3, 544, 272, 0, 940, 941, 5, 19, 0, 0, 941, 942, 3, 606, 303, 0, 942, - 943, 3, 206, 103, 0, 943, 947, 3, 608, 304, 0, 944, 945, 3, 418, 209, 0, - 945, 946, 3, 210, 105, 0, 946, 948, 1, 0, 0, 0, 947, 944, 1, 0, 0, 0, 947, - 948, 1, 0, 0, 0, 948, 55, 1, 0, 0, 0, 949, 951, 3, 444, 222, 0, 950, 952, - 3, 76, 38, 0, 951, 950, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 1, - 0, 0, 0, 953, 955, 3, 472, 236, 0, 954, 956, 3, 276, 138, 0, 955, 954, - 1, 0, 0, 0, 955, 956, 1, 0, 0, 0, 956, 960, 1, 0, 0, 0, 957, 958, 3, 366, - 183, 0, 958, 959, 5, 10, 0, 0, 959, 961, 1, 0, 0, 0, 960, 957, 1, 0, 0, - 0, 960, 961, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 3, 392, 196, 0, - 963, 965, 3, 602, 301, 0, 964, 966, 3, 60, 30, 0, 965, 964, 1, 0, 0, 0, - 965, 966, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 968, 3, 604, 302, 0, 968, - 969, 3, 62, 31, 0, 969, 970, 3, 546, 273, 0, 970, 971, 3, 372, 186, 0, - 971, 972, 3, 504, 252, 0, 972, 973, 3, 394, 197, 0, 973, 974, 3, 422, 211, - 0, 974, 975, 3, 58, 29, 0, 975, 57, 1, 0, 0, 0, 976, 977, 7, 0, 0, 0, 977, - 59, 1, 0, 0, 0, 978, 984, 3, 402, 201, 0, 979, 980, 3, 618, 309, 0, 980, - 981, 3, 402, 201, 0, 981, 983, 1, 0, 0, 0, 982, 979, 1, 0, 0, 0, 983, 986, - 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 61, 1, 0, - 0, 0, 986, 984, 1, 0, 0, 0, 987, 992, 3, 436, 218, 0, 988, 989, 3, 546, - 273, 0, 989, 990, 3, 524, 262, 0, 990, 992, 1, 0, 0, 0, 991, 987, 1, 0, - 0, 0, 991, 988, 1, 0, 0, 0, 992, 993, 1, 0, 0, 0, 993, 994, 3, 528, 264, - 0, 994, 995, 3, 524, 262, 0, 995, 996, 3, 486, 243, 0, 996, 63, 1, 0, 0, - 0, 997, 999, 3, 444, 222, 0, 998, 1000, 3, 76, 38, 0, 999, 998, 1, 0, 0, - 0, 999, 1000, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1003, 3, 408, 204, - 0, 1002, 1004, 3, 276, 138, 0, 1003, 1002, 1, 0, 0, 0, 1003, 1004, 1, 0, - 0, 0, 1004, 1008, 1, 0, 0, 0, 1005, 1006, 3, 366, 183, 0, 1006, 1007, 5, - 10, 0, 0, 1007, 1009, 1, 0, 0, 0, 1008, 1005, 1, 0, 0, 0, 1008, 1009, 1, - 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 3, 390, 195, 0, 1011, 1012, - 3, 602, 301, 0, 1012, 1013, 3, 372, 186, 0, 1013, 1014, 3, 604, 302, 0, - 1014, 1015, 3, 556, 278, 0, 1015, 1016, 3, 392, 196, 0, 1016, 1017, 3, - 560, 280, 0, 1017, 1018, 3, 372, 186, 0, 1018, 1019, 3, 466, 233, 0, 1019, - 1020, 3, 392, 196, 0, 1020, 1021, 3, 484, 242, 0, 1021, 1022, 3, 66, 33, - 0, 1022, 65, 1, 0, 0, 0, 1023, 1028, 3, 354, 177, 0, 1024, 1028, 3, 74, - 37, 0, 1025, 1028, 3, 72, 36, 0, 1026, 1028, 3, 68, 34, 0, 1027, 1023, - 1, 0, 0, 0, 1027, 1024, 1, 0, 0, 0, 1027, 1025, 1, 0, 0, 0, 1027, 1026, - 1, 0, 0, 0, 1028, 67, 1, 0, 0, 0, 1029, 1030, 3, 606, 303, 0, 1030, 1036, - 3, 70, 35, 0, 1031, 1032, 3, 618, 309, 0, 1032, 1033, 3, 70, 35, 0, 1033, - 1035, 1, 0, 0, 0, 1034, 1031, 1, 0, 0, 0, 1035, 1038, 1, 0, 0, 0, 1036, - 1034, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1039, 1, 0, 0, 0, 1038, - 1036, 1, 0, 0, 0, 1039, 1040, 3, 608, 304, 0, 1040, 69, 1, 0, 0, 0, 1041, - 1042, 3, 400, 200, 0, 1042, 1043, 5, 9, 0, 0, 1043, 1044, 3, 66, 33, 0, - 1044, 71, 1, 0, 0, 0, 1045, 1046, 3, 602, 301, 0, 1046, 1053, 3, 74, 37, - 0, 1047, 1048, 3, 618, 309, 0, 1048, 1049, 3, 354, 177, 0, 1049, 1052, - 1, 0, 0, 0, 1050, 1052, 3, 74, 37, 0, 1051, 1047, 1, 0, 0, 0, 1051, 1050, - 1, 0, 0, 0, 1052, 1055, 1, 0, 0, 0, 1053, 1051, 1, 0, 0, 0, 1053, 1054, - 1, 0, 0, 0, 1054, 1056, 1, 0, 0, 0, 1055, 1053, 1, 0, 0, 0, 1056, 1057, - 3, 604, 302, 0, 1057, 73, 1, 0, 0, 0, 1058, 1059, 3, 602, 301, 0, 1059, - 1065, 3, 354, 177, 0, 1060, 1061, 3, 618, 309, 0, 1061, 1062, 3, 354, 177, - 0, 1062, 1064, 1, 0, 0, 0, 1063, 1060, 1, 0, 0, 0, 1064, 1067, 1, 0, 0, - 0, 1065, 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1068, 1, 0, 0, - 0, 1067, 1065, 1, 0, 0, 0, 1068, 1069, 3, 604, 302, 0, 1069, 75, 1, 0, - 0, 0, 1070, 1071, 3, 532, 266, 0, 1071, 1072, 3, 542, 271, 0, 1072, 77, - 1, 0, 0, 0, 1073, 1074, 3, 416, 208, 0, 1074, 1075, 3, 586, 293, 0, 1075, - 1076, 3, 396, 198, 0, 1076, 1077, 3, 596, 298, 0, 1077, 1079, 3, 80, 40, - 0, 1078, 1080, 3, 82, 41, 0, 1079, 1078, 1, 0, 0, 0, 1079, 1080, 1, 0, - 0, 0, 1080, 79, 1, 0, 0, 0, 1081, 1082, 3, 536, 268, 0, 1082, 1083, 3, - 360, 180, 0, 1083, 81, 1, 0, 0, 0, 1084, 1087, 3, 562, 281, 0, 1085, 1087, - 3, 518, 259, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1085, 1, 0, 0, 0, 1087, 83, - 1, 0, 0, 0, 1088, 1089, 3, 416, 208, 0, 1089, 1093, 3, 578, 289, 0, 1090, - 1091, 3, 366, 183, 0, 1091, 1092, 5, 10, 0, 0, 1092, 1094, 1, 0, 0, 0, - 1093, 1090, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, - 1095, 1096, 3, 388, 194, 0, 1096, 1097, 3, 86, 43, 0, 1097, 85, 1, 0, 0, - 0, 1098, 1102, 3, 96, 48, 0, 1099, 1102, 3, 94, 47, 0, 1100, 1102, 3, 88, - 44, 0, 1101, 1098, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1101, 1100, 1, 0, - 0, 0, 1102, 87, 1, 0, 0, 0, 1103, 1104, 3, 540, 270, 0, 1104, 1105, 3, - 90, 45, 0, 1105, 89, 1, 0, 0, 0, 1106, 1112, 3, 92, 46, 0, 1107, 1108, - 3, 418, 209, 0, 1108, 1109, 3, 92, 46, 0, 1109, 1111, 1, 0, 0, 0, 1110, - 1107, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, - 1113, 1, 0, 0, 0, 1113, 91, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, - 3, 370, 185, 0, 1116, 1117, 3, 570, 285, 0, 1117, 1118, 3, 370, 185, 0, - 1118, 93, 1, 0, 0, 0, 1119, 1120, 3, 406, 203, 0, 1120, 1121, 3, 370, 185, - 0, 1121, 1128, 3, 372, 186, 0, 1122, 1123, 3, 618, 309, 0, 1123, 1124, - 3, 370, 185, 0, 1124, 1125, 3, 372, 186, 0, 1125, 1127, 1, 0, 0, 0, 1126, - 1122, 1, 0, 0, 0, 1127, 1130, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1128, - 1129, 1, 0, 0, 0, 1129, 95, 1, 0, 0, 0, 1130, 1128, 1, 0, 0, 0, 1131, 1132, - 3, 416, 208, 0, 1132, 1133, 3, 370, 185, 0, 1133, 1134, 3, 578, 289, 0, - 1134, 1135, 3, 372, 186, 0, 1135, 97, 1, 0, 0, 0, 1136, 1137, 3, 416, 208, - 0, 1137, 1138, 3, 564, 282, 0, 1138, 1139, 3, 298, 149, 0, 1139, 1140, - 3, 100, 50, 0, 1140, 99, 1, 0, 0, 0, 1141, 1148, 3, 118, 59, 0, 1142, 1148, - 3, 108, 54, 0, 1143, 1148, 3, 106, 53, 0, 1144, 1148, 3, 112, 56, 0, 1145, - 1148, 3, 104, 52, 0, 1146, 1148, 3, 102, 51, 0, 1147, 1141, 1, 0, 0, 0, - 1147, 1142, 1, 0, 0, 0, 1147, 1143, 1, 0, 0, 0, 1147, 1144, 1, 0, 0, 0, - 1147, 1145, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 101, 1, 0, 0, 0, - 1149, 1150, 3, 596, 298, 0, 1150, 1151, 3, 158, 79, 0, 1151, 103, 1, 0, - 0, 0, 1152, 1153, 3, 540, 270, 0, 1153, 1154, 3, 370, 185, 0, 1154, 1155, - 3, 570, 285, 0, 1155, 1156, 3, 370, 185, 0, 1156, 105, 1, 0, 0, 0, 1157, - 1158, 3, 454, 227, 0, 1158, 1159, 3, 440, 220, 0, 1159, 1160, 3, 558, 279, - 0, 1160, 107, 1, 0, 0, 0, 1161, 1162, 3, 454, 227, 0, 1162, 1163, 3, 110, - 55, 0, 1163, 109, 1, 0, 0, 0, 1164, 1170, 3, 370, 185, 0, 1165, 1166, 3, - 618, 309, 0, 1166, 1167, 3, 370, 185, 0, 1167, 1169, 1, 0, 0, 0, 1168, - 1165, 1, 0, 0, 0, 1169, 1172, 1, 0, 0, 0, 1170, 1168, 1, 0, 0, 0, 1170, - 1171, 1, 0, 0, 0, 1171, 111, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1173, - 1174, 3, 416, 208, 0, 1174, 1175, 3, 114, 57, 0, 1175, 113, 1, 0, 0, 0, - 1176, 1182, 3, 116, 58, 0, 1177, 1178, 3, 618, 309, 0, 1178, 1179, 3, 116, - 58, 0, 1179, 1181, 1, 0, 0, 0, 1180, 1177, 1, 0, 0, 0, 1181, 1184, 1, 0, - 0, 0, 1182, 1180, 1, 0, 0, 0, 1182, 1183, 1, 0, 0, 0, 1183, 115, 1, 0, - 0, 0, 1184, 1182, 1, 0, 0, 0, 1185, 1186, 3, 370, 185, 0, 1186, 1187, 3, - 578, 289, 0, 1187, 1188, 3, 372, 186, 0, 1188, 117, 1, 0, 0, 0, 1189, 1190, - 3, 406, 203, 0, 1190, 1191, 3, 120, 60, 0, 1191, 119, 1, 0, 0, 0, 1192, - 1198, 3, 122, 61, 0, 1193, 1194, 3, 618, 309, 0, 1194, 1195, 3, 122, 61, - 0, 1195, 1197, 1, 0, 0, 0, 1196, 1193, 1, 0, 0, 0, 1197, 1200, 1, 0, 0, - 0, 1198, 1196, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 121, 1, 0, 0, - 0, 1200, 1198, 1, 0, 0, 0, 1201, 1202, 3, 370, 185, 0, 1202, 1203, 3, 372, - 186, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 416, 208, 0, 1205, 1206, - 3, 548, 274, 0, 1206, 1208, 3, 380, 190, 0, 1207, 1209, 3, 126, 63, 0, - 1208, 1207, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 125, 1, 0, 0, 0, - 1210, 1211, 3, 596, 298, 0, 1211, 1217, 3, 128, 64, 0, 1212, 1213, 3, 418, - 209, 0, 1213, 1214, 3, 128, 64, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1212, - 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, - 1, 0, 0, 0, 1218, 127, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1221, - 3, 536, 268, 0, 1221, 1222, 5, 19, 0, 0, 1222, 1223, 3, 360, 180, 0, 1223, - 1237, 1, 0, 0, 0, 1224, 1225, 3, 512, 256, 0, 1225, 1226, 5, 19, 0, 0, - 1226, 1227, 3, 362, 181, 0, 1227, 1237, 1, 0, 0, 0, 1228, 1229, 3, 562, - 281, 0, 1229, 1230, 5, 19, 0, 0, 1230, 1231, 3, 362, 181, 0, 1231, 1237, - 1, 0, 0, 0, 1232, 1233, 3, 530, 265, 0, 1233, 1234, 5, 19, 0, 0, 1234, - 1235, 3, 166, 83, 0, 1235, 1237, 1, 0, 0, 0, 1236, 1220, 1, 0, 0, 0, 1236, - 1224, 1, 0, 0, 0, 1236, 1228, 1, 0, 0, 0, 1236, 1232, 1, 0, 0, 0, 1237, - 129, 1, 0, 0, 0, 1238, 1239, 3, 416, 208, 0, 1239, 1240, 3, 514, 257, 0, - 1240, 1244, 3, 592, 296, 0, 1241, 1242, 3, 366, 183, 0, 1242, 1243, 5, - 10, 0, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1241, 1, 0, 0, 0, 1244, 1245, 1, - 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1250, 3, 386, 193, 0, 1247, 1248, - 3, 596, 298, 0, 1248, 1249, 3, 158, 79, 0, 1249, 1251, 1, 0, 0, 0, 1250, - 1247, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 131, 1, 0, 0, 0, 1252, - 1253, 3, 454, 227, 0, 1253, 1255, 3, 586, 293, 0, 1254, 1256, 3, 278, 139, - 0, 1255, 1254, 1, 0, 0, 0, 1255, 1256, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, - 0, 1257, 1258, 3, 396, 198, 0, 1258, 133, 1, 0, 0, 0, 1259, 1260, 3, 454, - 227, 0, 1260, 1262, 3, 578, 289, 0, 1261, 1263, 3, 278, 139, 0, 1262, 1261, - 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1267, 1, 0, 0, 0, 1264, 1265, - 3, 366, 183, 0, 1265, 1266, 5, 10, 0, 0, 1266, 1268, 1, 0, 0, 0, 1267, - 1264, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, - 1270, 3, 388, 194, 0, 1270, 135, 1, 0, 0, 0, 1271, 1272, 3, 454, 227, 0, - 1272, 1273, 3, 514, 257, 0, 1273, 1275, 3, 592, 296, 0, 1274, 1276, 3, - 278, 139, 0, 1275, 1274, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1280, - 1, 0, 0, 0, 1277, 1278, 3, 366, 183, 0, 1278, 1279, 5, 10, 0, 0, 1279, - 1281, 1, 0, 0, 0, 1280, 1277, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, - 1282, 1, 0, 0, 0, 1282, 1283, 3, 386, 193, 0, 1283, 137, 1, 0, 0, 0, 1284, - 1285, 3, 454, 227, 0, 1285, 1287, 3, 408, 204, 0, 1286, 1288, 3, 278, 139, - 0, 1287, 1286, 1, 0, 0, 0, 1287, 1288, 1, 0, 0, 0, 1288, 1292, 1, 0, 0, - 0, 1289, 1290, 3, 366, 183, 0, 1290, 1291, 5, 10, 0, 0, 1291, 1293, 1, - 0, 0, 0, 1292, 1289, 1, 0, 0, 0, 1292, 1293, 1, 0, 0, 0, 1293, 1294, 1, - 0, 0, 0, 1294, 1295, 3, 390, 195, 0, 1295, 139, 1, 0, 0, 0, 1296, 1297, - 3, 454, 227, 0, 1297, 1299, 3, 472, 236, 0, 1298, 1300, 3, 278, 139, 0, - 1299, 1298, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1304, 1, 0, 0, 0, - 1301, 1302, 3, 366, 183, 0, 1302, 1303, 5, 10, 0, 0, 1303, 1305, 1, 0, - 0, 0, 1304, 1301, 1, 0, 0, 0, 1304, 1305, 1, 0, 0, 0, 1305, 1306, 1, 0, - 0, 0, 1306, 1307, 3, 392, 196, 0, 1307, 141, 1, 0, 0, 0, 1308, 1309, 3, - 454, 227, 0, 1309, 1311, 3, 572, 286, 0, 1310, 1312, 3, 278, 139, 0, 1311, - 1310, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, - 1314, 3, 382, 191, 0, 1314, 1315, 3, 528, 264, 0, 1315, 1316, 3, 298, 149, - 0, 1316, 143, 1, 0, 0, 0, 1317, 1318, 3, 454, 227, 0, 1318, 1320, 3, 548, - 274, 0, 1319, 1321, 3, 278, 139, 0, 1320, 1319, 1, 0, 0, 0, 1320, 1321, - 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, 3, 380, 190, 0, 1323, 145, - 1, 0, 0, 0, 1324, 1325, 3, 454, 227, 0, 1325, 1327, 3, 564, 282, 0, 1326, - 1328, 3, 278, 139, 0, 1327, 1326, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, - 1329, 1, 0, 0, 0, 1329, 1330, 3, 298, 149, 0, 1330, 147, 1, 0, 0, 0, 1331, - 1332, 3, 454, 227, 0, 1332, 1334, 3, 500, 250, 0, 1333, 1335, 3, 278, 139, - 0, 1334, 1333, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, - 0, 1336, 1337, 3, 366, 183, 0, 1337, 149, 1, 0, 0, 0, 1338, 1339, 3, 454, - 227, 0, 1339, 1341, 3, 482, 241, 0, 1340, 1342, 3, 278, 139, 0, 1341, 1340, - 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1346, 1, 0, 0, 0, 1343, 1344, - 3, 366, 183, 0, 1344, 1345, 5, 10, 0, 0, 1345, 1347, 1, 0, 0, 0, 1346, - 1343, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1348, 1, 0, 0, 0, 1348, - 1349, 3, 218, 109, 0, 1349, 151, 1, 0, 0, 0, 1350, 1351, 3, 444, 222, 0, - 1351, 1353, 3, 564, 282, 0, 1352, 1354, 3, 276, 138, 0, 1353, 1352, 1, - 0, 0, 0, 1353, 1354, 1, 0, 0, 0, 1354, 1355, 1, 0, 0, 0, 1355, 1356, 3, - 298, 149, 0, 1356, 1357, 3, 602, 301, 0, 1357, 1358, 3, 174, 87, 0, 1358, - 1360, 3, 604, 302, 0, 1359, 1361, 3, 154, 77, 0, 1360, 1359, 1, 0, 0, 0, - 1360, 1361, 1, 0, 0, 0, 1361, 153, 1, 0, 0, 0, 1362, 1364, 3, 596, 298, - 0, 1363, 1365, 3, 158, 79, 0, 1364, 1363, 1, 0, 0, 0, 1364, 1365, 1, 0, - 0, 0, 1365, 1367, 1, 0, 0, 0, 1366, 1368, 3, 156, 78, 0, 1367, 1366, 1, - 0, 0, 0, 1367, 1368, 1, 0, 0, 0, 1368, 155, 1, 0, 0, 0, 1369, 1370, 3, - 438, 219, 0, 1370, 1371, 3, 534, 267, 0, 1371, 1372, 3, 434, 217, 0, 1372, - 1373, 3, 602, 301, 0, 1373, 1375, 3, 370, 185, 0, 1374, 1376, 3, 378, 189, - 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1377, 1, 0, 0, - 0, 1377, 1378, 3, 604, 302, 0, 1378, 157, 1, 0, 0, 0, 1379, 1385, 3, 160, - 80, 0, 1380, 1381, 3, 418, 209, 0, 1381, 1382, 3, 160, 80, 0, 1382, 1384, - 1, 0, 0, 0, 1383, 1380, 1, 0, 0, 0, 1384, 1387, 1, 0, 0, 0, 1385, 1383, - 1, 0, 0, 0, 1385, 1386, 1, 0, 0, 0, 1386, 159, 1, 0, 0, 0, 1387, 1385, - 1, 0, 0, 0, 1388, 1389, 3, 162, 81, 0, 1389, 1390, 5, 19, 0, 0, 1390, 1391, - 3, 164, 82, 0, 1391, 1397, 1, 0, 0, 0, 1392, 1393, 3, 162, 81, 0, 1393, - 1394, 5, 19, 0, 0, 1394, 1395, 3, 166, 83, 0, 1395, 1397, 1, 0, 0, 0, 1396, - 1388, 1, 0, 0, 0, 1396, 1392, 1, 0, 0, 0, 1397, 161, 1, 0, 0, 0, 1398, - 1399, 5, 174, 0, 0, 1399, 163, 1, 0, 0, 0, 1400, 1403, 3, 360, 180, 0, - 1401, 1403, 3, 358, 179, 0, 1402, 1400, 1, 0, 0, 0, 1402, 1401, 1, 0, 0, - 0, 1403, 165, 1, 0, 0, 0, 1404, 1405, 3, 606, 303, 0, 1405, 1411, 3, 168, - 84, 0, 1406, 1407, 3, 618, 309, 0, 1407, 1408, 3, 168, 84, 0, 1408, 1410, - 1, 0, 0, 0, 1409, 1406, 1, 0, 0, 0, 1410, 1413, 1, 0, 0, 0, 1411, 1409, - 1, 0, 0, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1411, - 1, 0, 0, 0, 1414, 1415, 3, 608, 304, 0, 1415, 167, 1, 0, 0, 0, 1416, 1417, - 3, 170, 85, 0, 1417, 1418, 5, 9, 0, 0, 1418, 1419, 3, 172, 86, 0, 1419, - 169, 1, 0, 0, 0, 1420, 1421, 3, 360, 180, 0, 1421, 171, 1, 0, 0, 0, 1422, - 1425, 3, 360, 180, 0, 1423, 1425, 3, 358, 179, 0, 1424, 1422, 1, 0, 0, - 0, 1424, 1423, 1, 0, 0, 0, 1425, 173, 1, 0, 0, 0, 1426, 1432, 3, 176, 88, - 0, 1427, 1428, 3, 618, 309, 0, 1428, 1429, 3, 176, 88, 0, 1429, 1431, 1, - 0, 0, 0, 1430, 1427, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, - 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1438, 1, 0, 0, 0, 1434, 1432, 1, - 0, 0, 0, 1435, 1436, 3, 618, 309, 0, 1436, 1437, 3, 180, 90, 0, 1437, 1439, - 1, 0, 0, 0, 1438, 1435, 1, 0, 0, 0, 1438, 1439, 1, 0, 0, 0, 1439, 175, - 1, 0, 0, 0, 1440, 1441, 3, 370, 185, 0, 1441, 1443, 3, 372, 186, 0, 1442, - 1444, 3, 178, 89, 0, 1443, 1442, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, - 177, 1, 0, 0, 0, 1445, 1446, 3, 538, 269, 0, 1446, 1447, 3, 496, 248, 0, - 1447, 179, 1, 0, 0, 0, 1448, 1449, 3, 538, 269, 0, 1449, 1450, 3, 496, - 248, 0, 1450, 1451, 3, 602, 301, 0, 1451, 1452, 3, 182, 91, 0, 1452, 1453, - 3, 604, 302, 0, 1453, 181, 1, 0, 0, 0, 1454, 1458, 3, 184, 92, 0, 1455, - 1458, 3, 186, 93, 0, 1456, 1458, 3, 188, 94, 0, 1457, 1454, 1, 0, 0, 0, - 1457, 1455, 1, 0, 0, 0, 1457, 1456, 1, 0, 0, 0, 1458, 183, 1, 0, 0, 0, - 1459, 1460, 3, 370, 185, 0, 1460, 185, 1, 0, 0, 0, 1461, 1462, 3, 194, - 97, 0, 1462, 1463, 3, 618, 309, 0, 1463, 1464, 3, 192, 96, 0, 1464, 187, - 1, 0, 0, 0, 1465, 1466, 3, 602, 301, 0, 1466, 1467, 3, 190, 95, 0, 1467, - 1468, 3, 604, 302, 0, 1468, 1469, 3, 618, 309, 0, 1469, 1470, 3, 192, 96, - 0, 1470, 189, 1, 0, 0, 0, 1471, 1477, 3, 194, 97, 0, 1472, 1473, 3, 618, - 309, 0, 1473, 1474, 3, 194, 97, 0, 1474, 1476, 1, 0, 0, 0, 1475, 1472, - 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1477, 1478, - 1, 0, 0, 0, 1478, 191, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1486, - 3, 196, 98, 0, 1481, 1482, 3, 618, 309, 0, 1482, 1483, 3, 196, 98, 0, 1483, - 1485, 1, 0, 0, 0, 1484, 1481, 1, 0, 0, 0, 1485, 1488, 1, 0, 0, 0, 1486, - 1484, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 193, 1, 0, 0, 0, 1488, - 1486, 1, 0, 0, 0, 1489, 1490, 3, 370, 185, 0, 1490, 195, 1, 0, 0, 0, 1491, - 1492, 3, 370, 185, 0, 1492, 197, 1, 0, 0, 0, 1493, 1494, 3, 420, 210, 0, - 1494, 1495, 3, 428, 214, 0, 1495, 199, 1, 0, 0, 0, 1496, 1498, 3, 432, - 216, 0, 1497, 1499, 3, 202, 101, 0, 1498, 1497, 1, 0, 0, 0, 1498, 1499, - 1, 0, 0, 0, 1499, 1500, 1, 0, 0, 0, 1500, 1502, 3, 428, 214, 0, 1501, 1503, - 3, 274, 137, 0, 1502, 1501, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 201, - 1, 0, 0, 0, 1504, 1507, 3, 510, 255, 0, 1505, 1507, 3, 580, 290, 0, 1506, - 1504, 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 203, 1, 0, 0, 0, 1508, - 1509, 3, 416, 208, 0, 1509, 1510, 3, 500, 250, 0, 1510, 1511, 3, 366, 183, - 0, 1511, 1512, 3, 596, 298, 0, 1512, 1513, 3, 544, 272, 0, 1513, 1514, - 5, 19, 0, 0, 1514, 1515, 3, 606, 303, 0, 1515, 1516, 3, 206, 103, 0, 1516, - 1520, 3, 608, 304, 0, 1517, 1518, 3, 418, 209, 0, 1518, 1519, 3, 210, 105, - 0, 1519, 1521, 1, 0, 0, 0, 1520, 1517, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, - 0, 1521, 205, 1, 0, 0, 0, 1522, 1528, 3, 208, 104, 0, 1523, 1524, 3, 618, - 309, 0, 1524, 1525, 3, 208, 104, 0, 1525, 1527, 1, 0, 0, 0, 1526, 1523, - 1, 0, 0, 0, 1527, 1530, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1528, 1529, - 1, 0, 0, 0, 1529, 207, 1, 0, 0, 0, 1530, 1528, 1, 0, 0, 0, 1531, 1532, - 5, 169, 0, 0, 1532, 1533, 5, 9, 0, 0, 1533, 1538, 5, 169, 0, 0, 1534, 1535, - 5, 169, 0, 0, 1535, 1536, 5, 9, 0, 0, 1536, 1538, 5, 170, 0, 0, 1537, 1531, - 1, 0, 0, 0, 1537, 1534, 1, 0, 0, 0, 1538, 209, 1, 0, 0, 0, 1539, 1540, - 3, 456, 228, 0, 1540, 1541, 5, 19, 0, 0, 1541, 1542, 3, 362, 181, 0, 1542, - 211, 1, 0, 0, 0, 1543, 1544, 3, 584, 292, 0, 1544, 1545, 3, 366, 183, 0, - 1545, 213, 1, 0, 0, 0, 1546, 1548, 3, 574, 287, 0, 1547, 1549, 3, 564, - 282, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 1, - 0, 0, 0, 1550, 1551, 3, 298, 149, 0, 1551, 215, 1, 0, 0, 0, 1552, 1553, - 3, 444, 222, 0, 1553, 1555, 3, 482, 241, 0, 1554, 1556, 3, 276, 138, 0, - 1555, 1554, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1558, 1, 0, 0, 0, - 1557, 1559, 3, 218, 109, 0, 1558, 1557, 1, 0, 0, 0, 1558, 1559, 1, 0, 0, - 0, 1559, 1560, 1, 0, 0, 0, 1560, 1561, 3, 528, 264, 0, 1561, 1562, 3, 298, - 149, 0, 1562, 1563, 3, 602, 301, 0, 1563, 1564, 3, 220, 110, 0, 1564, 1565, - 3, 604, 302, 0, 1565, 217, 1, 0, 0, 0, 1566, 1569, 5, 174, 0, 0, 1567, - 1569, 3, 360, 180, 0, 1568, 1566, 1, 0, 0, 0, 1568, 1567, 1, 0, 0, 0, 1569, - 219, 1, 0, 0, 0, 1570, 1575, 3, 370, 185, 0, 1571, 1575, 3, 222, 111, 0, - 1572, 1575, 3, 224, 112, 0, 1573, 1575, 3, 226, 113, 0, 1574, 1570, 1, - 0, 0, 0, 1574, 1571, 1, 0, 0, 0, 1574, 1572, 1, 0, 0, 0, 1574, 1573, 1, - 0, 0, 0, 1575, 221, 1, 0, 0, 0, 1576, 1577, 3, 498, 249, 0, 1577, 1578, - 3, 602, 301, 0, 1578, 1579, 5, 174, 0, 0, 1579, 1580, 3, 604, 302, 0, 1580, - 223, 1, 0, 0, 0, 1581, 1582, 3, 458, 229, 0, 1582, 1583, 3, 602, 301, 0, - 1583, 1584, 5, 174, 0, 0, 1584, 1585, 3, 604, 302, 0, 1585, 225, 1, 0, - 0, 0, 1586, 1587, 3, 470, 235, 0, 1587, 1588, 3, 602, 301, 0, 1588, 1589, - 5, 174, 0, 0, 1589, 1590, 3, 604, 302, 0, 1590, 227, 1, 0, 0, 0, 1591, - 1593, 3, 200, 100, 0, 1592, 1591, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, - 1594, 1, 0, 0, 0, 1594, 1596, 3, 446, 223, 0, 1595, 1597, 3, 230, 115, - 0, 1596, 1595, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, - 0, 1598, 1600, 3, 300, 150, 0, 1599, 1601, 3, 274, 137, 0, 1600, 1599, - 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1605, - 3, 306, 153, 0, 1603, 1606, 3, 278, 139, 0, 1604, 1606, 3, 236, 118, 0, - 1605, 1603, 1, 0, 0, 0, 1605, 1604, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, - 1606, 1608, 1, 0, 0, 0, 1607, 1609, 3, 4, 2, 0, 1608, 1607, 1, 0, 0, 0, - 1608, 1609, 1, 0, 0, 0, 1609, 229, 1, 0, 0, 0, 1610, 1616, 3, 232, 116, - 0, 1611, 1612, 3, 618, 309, 0, 1612, 1613, 3, 232, 116, 0, 1613, 1615, - 1, 0, 0, 0, 1614, 1611, 1, 0, 0, 0, 1615, 1618, 1, 0, 0, 0, 1616, 1614, - 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 231, 1, 0, 0, 0, 1618, 1616, - 1, 0, 0, 0, 1619, 1621, 3, 314, 157, 0, 1620, 1622, 3, 320, 160, 0, 1621, - 1620, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1628, 1, 0, 0, 0, 1623, - 1625, 3, 318, 159, 0, 1624, 1626, 3, 320, 160, 0, 1625, 1624, 1, 0, 0, - 0, 1625, 1626, 1, 0, 0, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1619, 1, 0, 0, - 0, 1627, 1623, 1, 0, 0, 0, 1628, 233, 1, 0, 0, 0, 1629, 1631, 3, 200, 100, - 0, 1630, 1629, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, - 0, 1632, 1633, 3, 582, 291, 0, 1633, 1635, 3, 298, 149, 0, 1634, 1636, - 3, 268, 134, 0, 1635, 1634, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1637, - 1, 0, 0, 0, 1637, 1638, 3, 554, 277, 0, 1638, 1639, 3, 242, 121, 0, 1639, - 1642, 3, 306, 153, 0, 1640, 1643, 3, 278, 139, 0, 1641, 1643, 3, 236, 118, - 0, 1642, 1640, 1, 0, 0, 0, 1642, 1641, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, - 0, 1643, 1645, 1, 0, 0, 0, 1644, 1646, 3, 4, 2, 0, 1645, 1644, 1, 0, 0, - 0, 1645, 1646, 1, 0, 0, 0, 1646, 235, 1, 0, 0, 0, 1647, 1648, 3, 478, 239, - 0, 1648, 1649, 3, 238, 119, 0, 1649, 237, 1, 0, 0, 0, 1650, 1656, 3, 240, - 120, 0, 1651, 1652, 3, 418, 209, 0, 1652, 1653, 3, 240, 120, 0, 1653, 1655, - 1, 0, 0, 0, 1654, 1651, 1, 0, 0, 0, 1655, 1658, 1, 0, 0, 0, 1656, 1654, - 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, 1657, 239, 1, 0, 0, 0, 1658, 1656, - 1, 0, 0, 0, 1659, 1660, 5, 174, 0, 0, 1660, 1661, 5, 19, 0, 0, 1661, 1662, - 3, 354, 177, 0, 1662, 241, 1, 0, 0, 0, 1663, 1669, 3, 244, 122, 0, 1664, - 1665, 3, 618, 309, 0, 1665, 1666, 3, 244, 122, 0, 1666, 1668, 1, 0, 0, - 0, 1667, 1664, 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, - 0, 1669, 1670, 1, 0, 0, 0, 1670, 243, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, - 0, 1672, 1677, 3, 250, 125, 0, 1673, 1677, 3, 248, 124, 0, 1674, 1677, - 3, 246, 123, 0, 1675, 1677, 3, 254, 127, 0, 1676, 1672, 1, 0, 0, 0, 1676, - 1673, 1, 0, 0, 0, 1676, 1674, 1, 0, 0, 0, 1676, 1675, 1, 0, 0, 0, 1677, - 245, 1, 0, 0, 0, 1678, 1679, 3, 370, 185, 0, 1679, 1680, 5, 19, 0, 0, 1680, - 1681, 3, 352, 176, 0, 1681, 247, 1, 0, 0, 0, 1682, 1683, 3, 370, 185, 0, - 1683, 1684, 5, 19, 0, 0, 1684, 1685, 3, 352, 176, 0, 1685, 1686, 3, 262, - 131, 0, 1686, 1687, 5, 174, 0, 0, 1687, 249, 1, 0, 0, 0, 1688, 1689, 3, - 370, 185, 0, 1689, 1690, 5, 19, 0, 0, 1690, 1691, 5, 174, 0, 0, 1691, 1692, - 3, 262, 131, 0, 1692, 1693, 3, 352, 176, 0, 1693, 251, 1, 0, 0, 0, 1694, - 1695, 3, 614, 307, 0, 1695, 1696, 3, 354, 177, 0, 1696, 1697, 3, 616, 308, - 0, 1697, 253, 1, 0, 0, 0, 1698, 1699, 3, 370, 185, 0, 1699, 1700, 3, 252, - 126, 0, 1700, 1701, 5, 19, 0, 0, 1701, 1702, 3, 354, 177, 0, 1702, 255, - 1, 0, 0, 0, 1703, 1713, 3, 606, 303, 0, 1704, 1710, 3, 354, 177, 0, 1705, - 1706, 3, 618, 309, 0, 1706, 1707, 3, 354, 177, 0, 1707, 1709, 1, 0, 0, - 0, 1708, 1705, 1, 0, 0, 0, 1709, 1712, 1, 0, 0, 0, 1710, 1708, 1, 0, 0, - 0, 1710, 1711, 1, 0, 0, 0, 1711, 1714, 1, 0, 0, 0, 1712, 1710, 1, 0, 0, - 0, 1713, 1704, 1, 0, 0, 0, 1713, 1714, 1, 0, 0, 0, 1714, 1715, 1, 0, 0, - 0, 1715, 1716, 3, 608, 304, 0, 1716, 257, 1, 0, 0, 0, 1717, 1718, 3, 606, - 303, 0, 1718, 1719, 3, 354, 177, 0, 1719, 1720, 3, 620, 310, 0, 1720, 1721, - 3, 354, 177, 0, 1721, 1729, 1, 0, 0, 0, 1722, 1723, 3, 618, 309, 0, 1723, - 1724, 3, 354, 177, 0, 1724, 1725, 3, 620, 310, 0, 1725, 1726, 3, 354, 177, - 0, 1726, 1728, 1, 0, 0, 0, 1727, 1722, 1, 0, 0, 0, 1728, 1731, 1, 0, 0, - 0, 1729, 1727, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, - 0, 1731, 1729, 1, 0, 0, 0, 1732, 1733, 3, 608, 304, 0, 1733, 259, 1, 0, - 0, 0, 1734, 1744, 3, 614, 307, 0, 1735, 1741, 3, 354, 177, 0, 1736, 1737, - 3, 618, 309, 0, 1737, 1738, 3, 354, 177, 0, 1738, 1740, 1, 0, 0, 0, 1739, - 1736, 1, 0, 0, 0, 1740, 1743, 1, 0, 0, 0, 1741, 1739, 1, 0, 0, 0, 1741, - 1742, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1744, - 1735, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, - 1747, 3, 616, 308, 0, 1747, 261, 1, 0, 0, 0, 1748, 1749, 7, 1, 0, 0, 1749, - 263, 1, 0, 0, 0, 1750, 1751, 3, 602, 301, 0, 1751, 1757, 3, 288, 144, 0, - 1752, 1753, 3, 618, 309, 0, 1753, 1754, 3, 288, 144, 0, 1754, 1756, 1, - 0, 0, 0, 1755, 1752, 1, 0, 0, 0, 1756, 1759, 1, 0, 0, 0, 1757, 1755, 1, - 0, 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 1760, 1, 0, 0, 0, 1759, 1757, 1, - 0, 0, 0, 1760, 1761, 3, 604, 302, 0, 1761, 265, 1, 0, 0, 0, 1762, 1764, - 3, 200, 100, 0, 1763, 1762, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, 0, 1764, 1765, - 1, 0, 0, 0, 1765, 1766, 3, 488, 244, 0, 1766, 1767, 3, 490, 245, 0, 1767, - 1769, 3, 298, 149, 0, 1768, 1770, 3, 282, 141, 0, 1769, 1768, 1, 0, 0, - 0, 1769, 1770, 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 1773, 3, 280, - 140, 0, 1772, 1774, 3, 276, 138, 0, 1773, 1772, 1, 0, 0, 0, 1773, 1774, - 1, 0, 0, 0, 1774, 1776, 1, 0, 0, 0, 1775, 1777, 3, 268, 134, 0, 1776, 1775, - 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1779, 1, 0, 0, 0, 1778, 1780, - 3, 4, 2, 0, 1779, 1778, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 267, - 1, 0, 0, 0, 1781, 1782, 3, 588, 294, 0, 1782, 1783, 3, 272, 136, 0, 1783, - 1798, 1, 0, 0, 0, 1784, 1785, 3, 588, 294, 0, 1785, 1786, 3, 272, 136, - 0, 1786, 1787, 3, 418, 209, 0, 1787, 1788, 3, 270, 135, 0, 1788, 1798, - 1, 0, 0, 0, 1789, 1790, 3, 588, 294, 0, 1790, 1791, 3, 270, 135, 0, 1791, - 1798, 1, 0, 0, 0, 1792, 1793, 3, 588, 294, 0, 1793, 1794, 3, 270, 135, - 0, 1794, 1795, 3, 418, 209, 0, 1795, 1796, 3, 272, 136, 0, 1796, 1798, - 1, 0, 0, 0, 1797, 1781, 1, 0, 0, 0, 1797, 1784, 1, 0, 0, 0, 1797, 1789, - 1, 0, 0, 0, 1797, 1792, 1, 0, 0, 0, 1798, 269, 1, 0, 0, 0, 1799, 1802, - 3, 568, 284, 0, 1800, 1803, 3, 338, 169, 0, 1801, 1803, 3, 356, 178, 0, - 1802, 1800, 1, 0, 0, 0, 1802, 1801, 1, 0, 0, 0, 1803, 271, 1, 0, 0, 0, - 1804, 1805, 3, 576, 288, 0, 1805, 1806, 3, 356, 178, 0, 1806, 273, 1, 0, - 0, 0, 1807, 1808, 3, 588, 294, 0, 1808, 1809, 3, 270, 135, 0, 1809, 275, - 1, 0, 0, 0, 1810, 1811, 3, 478, 239, 0, 1811, 1812, 3, 522, 261, 0, 1812, - 1813, 3, 462, 231, 0, 1813, 277, 1, 0, 0, 0, 1814, 1815, 3, 478, 239, 0, - 1815, 1816, 3, 462, 231, 0, 1816, 279, 1, 0, 0, 0, 1817, 1818, 3, 590, - 295, 0, 1818, 1819, 5, 1, 0, 0, 1819, 1820, 3, 286, 143, 0, 1820, 1821, - 5, 2, 0, 0, 1821, 1826, 1, 0, 0, 0, 1822, 1823, 3, 494, 247, 0, 1823, 1824, - 3, 354, 177, 0, 1824, 1826, 1, 0, 0, 0, 1825, 1817, 1, 0, 0, 0, 1825, 1822, - 1, 0, 0, 0, 1826, 281, 1, 0, 0, 0, 1827, 1828, 5, 1, 0, 0, 1828, 1829, - 3, 284, 142, 0, 1829, 1830, 5, 2, 0, 0, 1830, 283, 1, 0, 0, 0, 1831, 1837, - 3, 370, 185, 0, 1832, 1833, 3, 618, 309, 0, 1833, 1834, 3, 370, 185, 0, - 1834, 1836, 1, 0, 0, 0, 1835, 1832, 1, 0, 0, 0, 1836, 1839, 1, 0, 0, 0, - 1837, 1835, 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838, 285, 1, 0, 0, 0, - 1839, 1837, 1, 0, 0, 0, 1840, 1846, 3, 352, 176, 0, 1841, 1842, 3, 618, - 309, 0, 1842, 1843, 3, 352, 176, 0, 1843, 1845, 1, 0, 0, 0, 1844, 1841, - 1, 0, 0, 0, 1845, 1848, 1, 0, 0, 0, 1846, 1844, 1, 0, 0, 0, 1846, 1847, - 1, 0, 0, 0, 1847, 287, 1, 0, 0, 0, 1848, 1846, 1, 0, 0, 0, 1849, 1856, - 3, 354, 177, 0, 1850, 1856, 3, 348, 174, 0, 1851, 1856, 3, 258, 129, 0, - 1852, 1856, 3, 256, 128, 0, 1853, 1856, 3, 260, 130, 0, 1854, 1856, 3, - 264, 132, 0, 1855, 1849, 1, 0, 0, 0, 1855, 1850, 1, 0, 0, 0, 1855, 1851, - 1, 0, 0, 0, 1855, 1852, 1, 0, 0, 0, 1855, 1853, 1, 0, 0, 0, 1855, 1854, - 1, 0, 0, 0, 1856, 289, 1, 0, 0, 0, 1857, 1859, 3, 552, 276, 0, 1858, 1860, - 3, 308, 154, 0, 1859, 1858, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1862, - 1, 0, 0, 0, 1861, 1863, 3, 494, 247, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, - 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 3, 310, 155, 0, 1865, 1867, - 3, 300, 150, 0, 1866, 1868, 3, 306, 153, 0, 1867, 1866, 1, 0, 0, 0, 1867, - 1868, 1, 0, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1871, 3, 622, 311, 0, 1870, - 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1873, 1, 0, 0, 0, 1872, - 1874, 3, 302, 151, 0, 1873, 1872, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, - 1876, 1, 0, 0, 0, 1875, 1877, 3, 294, 147, 0, 1876, 1875, 1, 0, 0, 0, 1876, - 1877, 1, 0, 0, 0, 1877, 1879, 1, 0, 0, 0, 1878, 1880, 3, 292, 146, 0, 1879, - 1878, 1, 0, 0, 0, 1879, 1880, 1, 0, 0, 0, 1880, 1882, 1, 0, 0, 0, 1881, - 1883, 3, 4, 2, 0, 1882, 1881, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, - 291, 1, 0, 0, 0, 1884, 1885, 3, 414, 207, 0, 1885, 1886, 3, 464, 232, 0, - 1886, 293, 1, 0, 0, 0, 1887, 1890, 3, 506, 253, 0, 1888, 1891, 3, 338, - 169, 0, 1889, 1891, 3, 356, 178, 0, 1890, 1888, 1, 0, 0, 0, 1890, 1889, - 1, 0, 0, 0, 1891, 295, 1, 0, 0, 0, 1892, 1893, 5, 83, 0, 0, 1893, 297, - 1, 0, 0, 0, 1894, 1895, 3, 366, 183, 0, 1895, 1896, 5, 10, 0, 0, 1896, - 1898, 1, 0, 0, 0, 1897, 1894, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, - 1899, 1, 0, 0, 0, 1899, 1900, 3, 368, 184, 0, 1900, 299, 1, 0, 0, 0, 1901, - 1902, 3, 468, 234, 0, 1902, 1903, 3, 298, 149, 0, 1903, 301, 1, 0, 0, 0, - 1904, 1905, 3, 534, 267, 0, 1905, 1906, 3, 434, 217, 0, 1906, 1912, 3, - 304, 152, 0, 1907, 1908, 3, 618, 309, 0, 1908, 1909, 3, 304, 152, 0, 1909, - 1911, 1, 0, 0, 0, 1910, 1907, 1, 0, 0, 0, 1911, 1914, 1, 0, 0, 0, 1912, - 1910, 1, 0, 0, 0, 1912, 1913, 1, 0, 0, 0, 1913, 303, 1, 0, 0, 0, 1914, - 1912, 1, 0, 0, 0, 1915, 1918, 5, 174, 0, 0, 1916, 1919, 3, 424, 212, 0, - 1917, 1919, 3, 448, 224, 0, 1918, 1916, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, - 0, 1918, 1919, 1, 0, 0, 0, 1919, 305, 1, 0, 0, 0, 1920, 1921, 3, 594, 297, - 0, 1921, 1922, 3, 322, 161, 0, 1922, 307, 1, 0, 0, 0, 1923, 1924, 3, 452, - 226, 0, 1924, 309, 1, 0, 0, 0, 1925, 1928, 5, 11, 0, 0, 1926, 1928, 3, - 312, 156, 0, 1927, 1925, 1, 0, 0, 0, 1927, 1926, 1, 0, 0, 0, 1928, 1934, - 1, 0, 0, 0, 1929, 1930, 3, 618, 309, 0, 1930, 1931, 3, 312, 156, 0, 1931, - 1933, 1, 0, 0, 0, 1932, 1929, 1, 0, 0, 0, 1933, 1936, 1, 0, 0, 0, 1934, - 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 311, 1, 0, 0, 0, 1936, - 1934, 1, 0, 0, 0, 1937, 1939, 3, 314, 157, 0, 1938, 1940, 3, 320, 160, - 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1950, 1, 0, 0, - 0, 1941, 1943, 3, 316, 158, 0, 1942, 1944, 3, 320, 160, 0, 1943, 1942, - 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 1950, 1, 0, 0, 0, 1945, 1947, - 3, 318, 159, 0, 1946, 1948, 3, 320, 160, 0, 1947, 1946, 1, 0, 0, 0, 1947, - 1948, 1, 0, 0, 0, 1948, 1950, 1, 0, 0, 0, 1949, 1937, 1, 0, 0, 0, 1949, - 1941, 1, 0, 0, 0, 1949, 1945, 1, 0, 0, 0, 1950, 313, 1, 0, 0, 0, 1951, - 1952, 3, 370, 185, 0, 1952, 315, 1, 0, 0, 0, 1953, 1954, 3, 348, 174, 0, - 1954, 317, 1, 0, 0, 0, 1955, 1956, 3, 370, 185, 0, 1956, 1957, 3, 614, - 307, 0, 1957, 1958, 3, 354, 177, 0, 1958, 1959, 3, 616, 308, 0, 1959, 319, - 1, 0, 0, 0, 1960, 1961, 3, 422, 211, 0, 1961, 1962, 5, 174, 0, 0, 1962, - 321, 1, 0, 0, 0, 1963, 1969, 3, 324, 162, 0, 1964, 1965, 3, 418, 209, 0, - 1965, 1966, 3, 324, 162, 0, 1966, 1968, 1, 0, 0, 0, 1967, 1964, 1, 0, 0, - 0, 1968, 1971, 1, 0, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, - 0, 1970, 323, 1, 0, 0, 0, 1971, 1969, 1, 0, 0, 0, 1972, 2040, 3, 334, 167, - 0, 1973, 2040, 3, 336, 168, 0, 1974, 2040, 3, 332, 166, 0, 1975, 2040, - 3, 328, 164, 0, 1976, 2040, 3, 330, 165, 0, 1977, 2040, 3, 346, 173, 0, - 1978, 2040, 3, 344, 172, 0, 1979, 2040, 3, 342, 171, 0, 1980, 1981, 5, - 174, 0, 0, 1981, 1982, 5, 10, 0, 0, 1982, 1983, 5, 174, 0, 0, 1983, 1984, - 3, 296, 148, 0, 1984, 1985, 3, 354, 177, 0, 1985, 2040, 1, 0, 0, 0, 1986, - 1987, 5, 174, 0, 0, 1987, 1988, 5, 10, 0, 0, 1988, 1989, 5, 174, 0, 0, - 1989, 1990, 3, 430, 215, 0, 1990, 1991, 3, 354, 177, 0, 1991, 1992, 3, - 418, 209, 0, 1992, 1993, 3, 354, 177, 0, 1993, 2040, 1, 0, 0, 0, 1994, - 1995, 5, 1, 0, 0, 1995, 2001, 5, 174, 0, 0, 1996, 1997, 3, 618, 309, 0, - 1997, 1998, 5, 174, 0, 0, 1998, 2000, 1, 0, 0, 0, 1999, 1996, 1, 0, 0, - 0, 2000, 2003, 1, 0, 0, 0, 2001, 1999, 1, 0, 0, 0, 2001, 2002, 1, 0, 0, - 0, 2002, 2004, 1, 0, 0, 0, 2003, 2001, 1, 0, 0, 0, 2004, 2005, 5, 2, 0, - 0, 2005, 2006, 3, 480, 240, 0, 2006, 2007, 5, 1, 0, 0, 2007, 2013, 3, 264, - 132, 0, 2008, 2009, 3, 618, 309, 0, 2009, 2010, 3, 264, 132, 0, 2010, 2012, - 1, 0, 0, 0, 2011, 2008, 1, 0, 0, 0, 2012, 2015, 1, 0, 0, 0, 2013, 2011, - 1, 0, 0, 0, 2013, 2014, 1, 0, 0, 0, 2014, 2016, 1, 0, 0, 0, 2015, 2013, - 1, 0, 0, 0, 2016, 2017, 5, 2, 0, 0, 2017, 2040, 1, 0, 0, 0, 2018, 2019, - 5, 1, 0, 0, 2019, 2025, 5, 174, 0, 0, 2020, 2021, 3, 618, 309, 0, 2021, - 2022, 5, 174, 0, 0, 2022, 2024, 1, 0, 0, 0, 2023, 2020, 1, 0, 0, 0, 2024, - 2027, 1, 0, 0, 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, - 2028, 1, 0, 0, 0, 2027, 2025, 1, 0, 0, 0, 2028, 2029, 5, 2, 0, 0, 2029, - 2030, 3, 326, 163, 0, 2030, 2036, 3, 264, 132, 0, 2031, 2032, 3, 618, 309, - 0, 2032, 2033, 3, 264, 132, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2031, 1, 0, - 0, 0, 2035, 2038, 1, 0, 0, 0, 2036, 2034, 1, 0, 0, 0, 2036, 2037, 1, 0, - 0, 0, 2037, 2040, 1, 0, 0, 0, 2038, 2036, 1, 0, 0, 0, 2039, 1972, 1, 0, - 0, 0, 2039, 1973, 1, 0, 0, 0, 2039, 1974, 1, 0, 0, 0, 2039, 1975, 1, 0, - 0, 0, 2039, 1976, 1, 0, 0, 0, 2039, 1977, 1, 0, 0, 0, 2039, 1978, 1, 0, - 0, 0, 2039, 1979, 1, 0, 0, 0, 2039, 1980, 1, 0, 0, 0, 2039, 1986, 1, 0, - 0, 0, 2039, 1994, 1, 0, 0, 0, 2039, 2018, 1, 0, 0, 0, 2040, 325, 1, 0, - 0, 0, 2041, 2042, 7, 2, 0, 0, 2042, 327, 1, 0, 0, 0, 2043, 2044, 3, 348, - 174, 0, 2044, 2045, 3, 326, 163, 0, 2045, 2046, 3, 354, 177, 0, 2046, 329, - 1, 0, 0, 0, 2047, 2048, 3, 348, 174, 0, 2048, 2049, 3, 326, 163, 0, 2049, - 2050, 3, 348, 174, 0, 2050, 331, 1, 0, 0, 0, 2051, 2052, 3, 370, 185, 0, - 2052, 2053, 3, 430, 215, 0, 2053, 2054, 3, 354, 177, 0, 2054, 2055, 3, - 418, 209, 0, 2055, 2056, 3, 354, 177, 0, 2056, 333, 1, 0, 0, 0, 2057, 2058, - 3, 370, 185, 0, 2058, 2059, 3, 326, 163, 0, 2059, 2060, 3, 354, 177, 0, - 2060, 335, 1, 0, 0, 0, 2061, 2062, 3, 370, 185, 0, 2062, 2063, 3, 296, - 148, 0, 2063, 2064, 3, 354, 177, 0, 2064, 337, 1, 0, 0, 0, 2065, 2066, - 7, 3, 0, 0, 2066, 339, 1, 0, 0, 0, 2067, 2073, 3, 338, 169, 0, 2068, 2069, - 5, 1, 0, 0, 2069, 2070, 3, 350, 175, 0, 2070, 2071, 5, 2, 0, 0, 2071, 2073, - 1, 0, 0, 0, 2072, 2067, 1, 0, 0, 0, 2072, 2068, 1, 0, 0, 0, 2073, 341, - 1, 0, 0, 0, 2074, 2075, 3, 370, 185, 0, 2075, 2076, 3, 480, 240, 0, 2076, - 2077, 3, 340, 170, 0, 2077, 343, 1, 0, 0, 0, 2078, 2079, 3, 370, 185, 0, - 2079, 2080, 3, 442, 221, 0, 2080, 2081, 3, 354, 177, 0, 2081, 345, 1, 0, - 0, 0, 2082, 2083, 3, 370, 185, 0, 2083, 2084, 3, 442, 221, 0, 2084, 2085, - 3, 496, 248, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2087, 3, 354, 177, 0, 2087, - 347, 1, 0, 0, 0, 2088, 2089, 5, 174, 0, 0, 2089, 2090, 5, 1, 0, 0, 2090, - 2091, 5, 11, 0, 0, 2091, 2108, 5, 2, 0, 0, 2092, 2093, 5, 174, 0, 0, 2093, - 2095, 5, 1, 0, 0, 2094, 2096, 3, 350, 175, 0, 2095, 2094, 1, 0, 0, 0, 2095, - 2096, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2108, 5, 2, 0, 0, 2098, - 2099, 5, 141, 0, 0, 2099, 2100, 5, 1, 0, 0, 2100, 2108, 5, 2, 0, 0, 2101, - 2102, 5, 146, 0, 0, 2102, 2104, 5, 1, 0, 0, 2103, 2105, 3, 350, 175, 0, - 2104, 2103, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, - 2106, 2108, 5, 2, 0, 0, 2107, 2088, 1, 0, 0, 0, 2107, 2092, 1, 0, 0, 0, - 2107, 2098, 1, 0, 0, 0, 2107, 2101, 1, 0, 0, 0, 2108, 349, 1, 0, 0, 0, - 2109, 2113, 3, 354, 177, 0, 2110, 2113, 5, 174, 0, 0, 2111, 2113, 3, 348, - 174, 0, 2112, 2109, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2112, 2111, 1, - 0, 0, 0, 2113, 2122, 1, 0, 0, 0, 2114, 2118, 3, 618, 309, 0, 2115, 2119, - 3, 354, 177, 0, 2116, 2119, 5, 174, 0, 0, 2117, 2119, 3, 348, 174, 0, 2118, - 2115, 1, 0, 0, 0, 2118, 2116, 1, 0, 0, 0, 2118, 2117, 1, 0, 0, 0, 2119, - 2121, 1, 0, 0, 0, 2120, 2114, 1, 0, 0, 0, 2121, 2124, 1, 0, 0, 0, 2122, - 2120, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 351, 1, 0, 0, 0, 2124, - 2122, 1, 0, 0, 0, 2125, 2133, 3, 338, 169, 0, 2126, 2133, 3, 354, 177, - 0, 2127, 2133, 3, 348, 174, 0, 2128, 2133, 3, 258, 129, 0, 2129, 2133, - 3, 256, 128, 0, 2130, 2133, 3, 260, 130, 0, 2131, 2133, 3, 264, 132, 0, - 2132, 2125, 1, 0, 0, 0, 2132, 2126, 1, 0, 0, 0, 2132, 2127, 1, 0, 0, 0, - 2132, 2128, 1, 0, 0, 0, 2132, 2129, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, - 2132, 2131, 1, 0, 0, 0, 2133, 353, 1, 0, 0, 0, 2134, 2144, 3, 338, 169, - 0, 2135, 2144, 3, 524, 262, 0, 2136, 2144, 5, 175, 0, 0, 2137, 2144, 3, - 360, 180, 0, 2138, 2144, 3, 356, 178, 0, 2139, 2144, 3, 358, 179, 0, 2140, - 2144, 3, 364, 182, 0, 2141, 2144, 3, 362, 181, 0, 2142, 2144, 3, 58, 29, - 0, 2143, 2134, 1, 0, 0, 0, 2143, 2135, 1, 0, 0, 0, 2143, 2136, 1, 0, 0, - 0, 2143, 2137, 1, 0, 0, 0, 2143, 2138, 1, 0, 0, 0, 2143, 2139, 1, 0, 0, - 0, 2143, 2140, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2143, 2142, 1, 0, 0, - 0, 2144, 355, 1, 0, 0, 0, 2145, 2146, 5, 170, 0, 0, 2146, 357, 1, 0, 0, - 0, 2147, 2148, 7, 4, 0, 0, 2148, 359, 1, 0, 0, 0, 2149, 2150, 5, 169, 0, - 0, 2150, 361, 1, 0, 0, 0, 2151, 2152, 7, 5, 0, 0, 2152, 363, 1, 0, 0, 0, - 2153, 2154, 5, 172, 0, 0, 2154, 365, 1, 0, 0, 0, 2155, 2160, 5, 174, 0, - 0, 2156, 2157, 5, 17, 0, 0, 2157, 2158, 5, 174, 0, 0, 2158, 2160, 5, 17, - 0, 0, 2159, 2155, 1, 0, 0, 0, 2159, 2156, 1, 0, 0, 0, 2160, 367, 1, 0, - 0, 0, 2161, 2169, 5, 174, 0, 0, 2162, 2169, 5, 79, 0, 0, 2163, 2169, 5, - 125, 0, 0, 2164, 2169, 5, 63, 0, 0, 2165, 2166, 5, 17, 0, 0, 2166, 2167, - 5, 174, 0, 0, 2167, 2169, 5, 17, 0, 0, 2168, 2161, 1, 0, 0, 0, 2168, 2162, - 1, 0, 0, 0, 2168, 2163, 1, 0, 0, 0, 2168, 2164, 1, 0, 0, 0, 2168, 2165, - 1, 0, 0, 0, 2169, 369, 1, 0, 0, 0, 2170, 2177, 5, 174, 0, 0, 2171, 2177, - 3, 578, 289, 0, 2172, 2177, 5, 76, 0, 0, 2173, 2174, 5, 17, 0, 0, 2174, - 2175, 5, 174, 0, 0, 2175, 2177, 5, 17, 0, 0, 2176, 2170, 1, 0, 0, 0, 2176, - 2171, 1, 0, 0, 0, 2176, 2172, 1, 0, 0, 0, 2176, 2173, 1, 0, 0, 0, 2177, - 371, 1, 0, 0, 0, 2178, 2180, 3, 374, 187, 0, 2179, 2181, 3, 376, 188, 0, - 2180, 2179, 1, 0, 0, 0, 2180, 2181, 1, 0, 0, 0, 2181, 373, 1, 0, 0, 0, - 2182, 2183, 7, 6, 0, 0, 2183, 375, 1, 0, 0, 0, 2184, 2185, 3, 610, 305, - 0, 2185, 2191, 3, 372, 186, 0, 2186, 2187, 3, 618, 309, 0, 2187, 2188, - 3, 372, 186, 0, 2188, 2190, 1, 0, 0, 0, 2189, 2186, 1, 0, 0, 0, 2190, 2193, - 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2191, 2192, 1, 0, 0, 0, 2192, 2194, - 1, 0, 0, 0, 2193, 2191, 1, 0, 0, 0, 2194, 2195, 3, 612, 306, 0, 2195, 377, - 1, 0, 0, 0, 2196, 2199, 3, 424, 212, 0, 2197, 2199, 3, 448, 224, 0, 2198, - 2196, 1, 0, 0, 0, 2198, 2197, 1, 0, 0, 0, 2199, 379, 1, 0, 0, 0, 2200, - 2201, 5, 174, 0, 0, 2201, 381, 1, 0, 0, 0, 2202, 2203, 5, 174, 0, 0, 2203, - 383, 1, 0, 0, 0, 2204, 2205, 3, 360, 180, 0, 2205, 385, 1, 0, 0, 0, 2206, - 2207, 5, 174, 0, 0, 2207, 387, 1, 0, 0, 0, 2208, 2209, 5, 174, 0, 0, 2209, - 389, 1, 0, 0, 0, 2210, 2211, 5, 174, 0, 0, 2211, 391, 1, 0, 0, 0, 2212, - 2213, 5, 174, 0, 0, 2213, 393, 1, 0, 0, 0, 2214, 2215, 5, 174, 0, 0, 2215, - 395, 1, 0, 0, 0, 2216, 2217, 5, 174, 0, 0, 2217, 397, 1, 0, 0, 0, 2218, - 2219, 3, 360, 180, 0, 2219, 399, 1, 0, 0, 0, 2220, 2221, 5, 174, 0, 0, - 2221, 401, 1, 0, 0, 0, 2222, 2223, 3, 404, 202, 0, 2223, 2224, 3, 372, - 186, 0, 2224, 403, 1, 0, 0, 0, 2225, 2226, 7, 7, 0, 0, 2226, 405, 1, 0, - 0, 0, 2227, 2228, 5, 24, 0, 0, 2228, 407, 1, 0, 0, 0, 2229, 2230, 5, 25, - 0, 0, 2230, 409, 1, 0, 0, 0, 2231, 2232, 5, 26, 0, 0, 2232, 411, 1, 0, - 0, 0, 2233, 2234, 5, 26, 0, 0, 2234, 2235, 5, 106, 0, 0, 2235, 413, 1, - 0, 0, 0, 2236, 2237, 5, 27, 0, 0, 2237, 415, 1, 0, 0, 0, 2238, 2239, 5, - 28, 0, 0, 2239, 417, 1, 0, 0, 0, 2240, 2241, 5, 29, 0, 0, 2241, 419, 1, - 0, 0, 0, 2242, 2243, 5, 31, 0, 0, 2243, 421, 1, 0, 0, 0, 2244, 2245, 5, - 32, 0, 0, 2245, 423, 1, 0, 0, 0, 2246, 2247, 5, 33, 0, 0, 2247, 425, 1, - 0, 0, 0, 2248, 2249, 5, 34, 0, 0, 2249, 427, 1, 0, 0, 0, 2250, 2251, 5, - 35, 0, 0, 2251, 429, 1, 0, 0, 0, 2252, 2253, 5, 37, 0, 0, 2253, 431, 1, - 0, 0, 0, 2254, 2255, 5, 36, 0, 0, 2255, 433, 1, 0, 0, 0, 2256, 2257, 5, - 38, 0, 0, 2257, 435, 1, 0, 0, 0, 2258, 2259, 5, 39, 0, 0, 2259, 437, 1, - 0, 0, 0, 2260, 2261, 5, 40, 0, 0, 2261, 439, 1, 0, 0, 0, 2262, 2263, 5, - 42, 0, 0, 2263, 441, 1, 0, 0, 0, 2264, 2265, 5, 44, 0, 0, 2265, 443, 1, - 0, 0, 0, 2266, 2267, 5, 45, 0, 0, 2267, 445, 1, 0, 0, 0, 2268, 2269, 5, - 47, 0, 0, 2269, 447, 1, 0, 0, 0, 2270, 2271, 5, 48, 0, 0, 2271, 449, 1, - 0, 0, 0, 2272, 2273, 5, 49, 0, 0, 2273, 451, 1, 0, 0, 0, 2274, 2275, 5, - 50, 0, 0, 2275, 453, 1, 0, 0, 0, 2276, 2277, 5, 51, 0, 0, 2277, 455, 1, - 0, 0, 0, 2278, 2279, 5, 52, 0, 0, 2279, 457, 1, 0, 0, 0, 2280, 2281, 5, - 54, 0, 0, 2281, 459, 1, 0, 0, 0, 2282, 2283, 5, 55, 0, 0, 2283, 461, 1, - 0, 0, 0, 2284, 2285, 5, 56, 0, 0, 2285, 463, 1, 0, 0, 0, 2286, 2287, 5, - 58, 0, 0, 2287, 465, 1, 0, 0, 0, 2288, 2289, 5, 59, 0, 0, 2289, 467, 1, - 0, 0, 0, 2290, 2291, 5, 60, 0, 0, 2291, 469, 1, 0, 0, 0, 2292, 2293, 5, - 61, 0, 0, 2293, 471, 1, 0, 0, 0, 2294, 2295, 5, 62, 0, 0, 2295, 473, 1, - 0, 0, 0, 2296, 2297, 5, 63, 0, 0, 2297, 475, 1, 0, 0, 0, 2298, 2299, 5, - 64, 0, 0, 2299, 477, 1, 0, 0, 0, 2300, 2301, 5, 66, 0, 0, 2301, 479, 1, - 0, 0, 0, 2302, 2303, 5, 67, 0, 0, 2303, 481, 1, 0, 0, 0, 2304, 2305, 5, - 68, 0, 0, 2305, 483, 1, 0, 0, 0, 2306, 2307, 5, 70, 0, 0, 2307, 485, 1, - 0, 0, 0, 2308, 2309, 5, 71, 0, 0, 2309, 487, 1, 0, 0, 0, 2310, 2311, 5, - 72, 0, 0, 2311, 489, 1, 0, 0, 0, 2312, 2313, 5, 73, 0, 0, 2313, 491, 1, - 0, 0, 0, 2314, 2315, 5, 74, 0, 0, 2315, 493, 1, 0, 0, 0, 2316, 2317, 5, - 75, 0, 0, 2317, 495, 1, 0, 0, 0, 2318, 2319, 5, 76, 0, 0, 2319, 497, 1, - 0, 0, 0, 2320, 2321, 5, 77, 0, 0, 2321, 499, 1, 0, 0, 0, 2322, 2323, 5, - 78, 0, 0, 2323, 501, 1, 0, 0, 0, 2324, 2325, 5, 79, 0, 0, 2325, 503, 1, - 0, 0, 0, 2326, 2327, 5, 80, 0, 0, 2327, 505, 1, 0, 0, 0, 2328, 2329, 5, - 82, 0, 0, 2329, 507, 1, 0, 0, 0, 2330, 2331, 5, 84, 0, 0, 2331, 509, 1, - 0, 0, 0, 2332, 2333, 5, 87, 0, 0, 2333, 511, 1, 0, 0, 0, 2334, 2335, 5, - 88, 0, 0, 2335, 513, 1, 0, 0, 0, 2336, 2337, 5, 89, 0, 0, 2337, 515, 1, - 0, 0, 0, 2338, 2339, 5, 90, 0, 0, 2339, 517, 1, 0, 0, 0, 2340, 2341, 5, - 93, 0, 0, 2341, 519, 1, 0, 0, 0, 2342, 2343, 5, 92, 0, 0, 2343, 521, 1, - 0, 0, 0, 2344, 2345, 5, 94, 0, 0, 2345, 523, 1, 0, 0, 0, 2346, 2347, 5, - 95, 0, 0, 2347, 525, 1, 0, 0, 0, 2348, 2349, 5, 96, 0, 0, 2349, 527, 1, - 0, 0, 0, 2350, 2351, 5, 97, 0, 0, 2351, 529, 1, 0, 0, 0, 2352, 2353, 5, - 99, 0, 0, 2353, 531, 1, 0, 0, 0, 2354, 2355, 5, 100, 0, 0, 2355, 533, 1, - 0, 0, 0, 2356, 2357, 5, 101, 0, 0, 2357, 535, 1, 0, 0, 0, 2358, 2359, 5, - 103, 0, 0, 2359, 537, 1, 0, 0, 0, 2360, 2361, 5, 107, 0, 0, 2361, 539, - 1, 0, 0, 0, 2362, 2363, 5, 109, 0, 0, 2363, 541, 1, 0, 0, 0, 2364, 2365, - 5, 110, 0, 0, 2365, 543, 1, 0, 0, 0, 2366, 2367, 5, 111, 0, 0, 2367, 545, - 1, 0, 0, 0, 2368, 2369, 5, 112, 0, 0, 2369, 547, 1, 0, 0, 0, 2370, 2371, - 5, 114, 0, 0, 2371, 549, 1, 0, 0, 0, 2372, 2373, 5, 115, 0, 0, 2373, 551, - 1, 0, 0, 0, 2374, 2375, 5, 117, 0, 0, 2375, 553, 1, 0, 0, 0, 2376, 2377, - 5, 118, 0, 0, 2377, 555, 1, 0, 0, 0, 2378, 2379, 5, 119, 0, 0, 2379, 557, - 1, 0, 0, 0, 2380, 2381, 5, 121, 0, 0, 2381, 559, 1, 0, 0, 0, 2382, 2383, - 5, 122, 0, 0, 2383, 561, 1, 0, 0, 0, 2384, 2385, 5, 123, 0, 0, 2385, 563, - 1, 0, 0, 0, 2386, 2387, 5, 124, 0, 0, 2387, 565, 1, 0, 0, 0, 2388, 2389, - 5, 125, 0, 0, 2389, 567, 1, 0, 0, 0, 2390, 2391, 5, 127, 0, 0, 2391, 569, - 1, 0, 0, 0, 2392, 2393, 5, 128, 0, 0, 2393, 571, 1, 0, 0, 0, 2394, 2395, - 5, 130, 0, 0, 2395, 573, 1, 0, 0, 0, 2396, 2397, 5, 132, 0, 0, 2397, 575, - 1, 0, 0, 0, 2398, 2399, 5, 133, 0, 0, 2399, 577, 1, 0, 0, 0, 2400, 2401, - 5, 135, 0, 0, 2401, 579, 1, 0, 0, 0, 2402, 2403, 5, 136, 0, 0, 2403, 581, - 1, 0, 0, 0, 2404, 2405, 5, 137, 0, 0, 2405, 583, 1, 0, 0, 0, 2406, 2407, - 5, 138, 0, 0, 2407, 585, 1, 0, 0, 0, 2408, 2409, 5, 139, 0, 0, 2409, 587, - 1, 0, 0, 0, 2410, 2411, 5, 140, 0, 0, 2411, 589, 1, 0, 0, 0, 2412, 2413, - 5, 142, 0, 0, 2413, 591, 1, 0, 0, 0, 2414, 2415, 5, 143, 0, 0, 2415, 593, - 1, 0, 0, 0, 2416, 2417, 5, 144, 0, 0, 2417, 595, 1, 0, 0, 0, 2418, 2419, - 5, 145, 0, 0, 2419, 597, 1, 0, 0, 0, 2420, 2421, 5, 113, 0, 0, 2421, 599, - 1, 0, 0, 0, 2422, 2423, 5, 65, 0, 0, 2423, 601, 1, 0, 0, 0, 2424, 2425, - 5, 1, 0, 0, 2425, 603, 1, 0, 0, 0, 2426, 2427, 5, 2, 0, 0, 2427, 605, 1, - 0, 0, 0, 2428, 2429, 5, 3, 0, 0, 2429, 607, 1, 0, 0, 0, 2430, 2431, 5, - 4, 0, 0, 2431, 609, 1, 0, 0, 0, 2432, 2433, 5, 20, 0, 0, 2433, 611, 1, - 0, 0, 0, 2434, 2435, 5, 21, 0, 0, 2435, 613, 1, 0, 0, 0, 2436, 2437, 5, - 5, 0, 0, 2437, 615, 1, 0, 0, 0, 2438, 2439, 5, 6, 0, 0, 2439, 617, 1, 0, - 0, 0, 2440, 2441, 5, 7, 0, 0, 2441, 619, 1, 0, 0, 0, 2442, 2443, 5, 9, - 0, 0, 2443, 621, 1, 0, 0, 0, 2444, 2445, 3, 600, 300, 0, 2445, 2446, 3, - 434, 217, 0, 2446, 2452, 3, 624, 312, 0, 2447, 2448, 3, 618, 309, 0, 2448, - 2449, 3, 624, 312, 0, 2449, 2451, 1, 0, 0, 0, 2450, 2447, 1, 0, 0, 0, 2451, - 2454, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2452, 2453, 1, 0, 0, 0, 2453, - 623, 1, 0, 0, 0, 2454, 2452, 1, 0, 0, 0, 2455, 2456, 5, 174, 0, 0, 2456, - 625, 1, 0, 0, 0, 183, 629, 632, 638, 643, 645, 650, 653, 656, 700, 704, - 712, 719, 724, 740, 743, 750, 755, 766, 776, 791, 802, 811, 816, 824, 829, - 833, 838, 843, 858, 864, 869, 879, 884, 901, 908, 916, 930, 935, 947, 951, - 955, 960, 965, 984, 991, 999, 1003, 1008, 1027, 1036, 1051, 1053, 1065, - 1079, 1086, 1093, 1101, 1112, 1128, 1147, 1170, 1182, 1198, 1208, 1217, - 1236, 1244, 1250, 1255, 1262, 1267, 1275, 1280, 1287, 1292, 1299, 1304, - 1311, 1320, 1327, 1334, 1341, 1346, 1353, 1360, 1364, 1367, 1375, 1385, - 1396, 1402, 1411, 1424, 1432, 1438, 1443, 1457, 1477, 1486, 1498, 1502, - 1506, 1520, 1528, 1537, 1548, 1555, 1558, 1568, 1574, 1592, 1596, 1600, - 1605, 1608, 1616, 1621, 1625, 1627, 1630, 1635, 1642, 1645, 1656, 1669, - 1676, 1710, 1713, 1729, 1741, 1744, 1757, 1763, 1769, 1773, 1776, 1779, - 1797, 1802, 1825, 1837, 1846, 1855, 1859, 1862, 1867, 1870, 1873, 1876, - 1879, 1882, 1890, 1897, 1912, 1918, 1927, 1934, 1939, 1943, 1947, 1949, - 1969, 2001, 2013, 2025, 2036, 2039, 2072, 2095, 2104, 2107, 2112, 2118, - 2122, 2132, 2143, 2159, 2168, 2176, 2180, 2191, 2198, 2452, + 1, 162, 5, 162, 2010, 8, 162, 10, 162, 12, 162, 2013, 9, 162, 1, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2022, 8, 162, 10, + 162, 12, 162, 2025, 9, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, + 162, 1, 162, 5, 162, 2034, 8, 162, 10, 162, 12, 162, 2037, 9, 162, 1, 162, + 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 2045, 8, 162, 10, 162, + 12, 162, 2048, 9, 162, 3, 162, 2050, 8, 162, 1, 163, 1, 163, 1, 164, 1, + 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, + 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, + 170, 1, 170, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, + 172, 2091, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, + 1, 176, 3, 176, 2110, 8, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, + 178, 1, 178, 1, 178, 5, 178, 2120, 8, 178, 10, 178, 12, 178, 2123, 9, 178, + 1, 179, 1, 179, 1, 179, 3, 179, 2128, 8, 179, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 1, 180, 3, 180, 2137, 8, 180, 1, 181, 1, 181, 1, 181, + 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2148, 8, 181, 1, + 182, 1, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, 185, 1, 185, 1, 186, 1, + 186, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2164, 8, 187, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 2173, 8, 188, 1, 189, 1, + 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 2181, 8, 189, 1, 190, 1, 190, + 3, 190, 2185, 8, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, + 192, 5, 192, 2194, 8, 192, 10, 192, 12, 192, 2197, 9, 192, 1, 192, 1, 192, + 1, 193, 1, 193, 3, 193, 2203, 8, 193, 1, 194, 1, 194, 1, 195, 1, 195, 1, + 196, 1, 196, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, + 200, 1, 201, 1, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, + 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 207, 1, 207, 1, 208, 1, 208, 1, + 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 212, 1, 212, 1, + 213, 1, 213, 1, 214, 1, 214, 1, 215, 1, 215, 1, 216, 1, 216, 1, 217, 1, + 217, 1, 218, 1, 218, 1, 219, 1, 219, 1, 220, 1, 220, 1, 221, 1, 221, 1, + 222, 1, 222, 1, 223, 1, 223, 1, 224, 1, 224, 1, 225, 1, 225, 1, 226, 1, + 226, 1, 227, 1, 227, 1, 228, 1, 228, 1, 229, 1, 229, 1, 230, 1, 230, 1, + 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 1, 234, 1, 234, 1, 235, 1, + 235, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, 1, 238, 1, 239, 1, 239, 1, + 240, 1, 240, 1, 241, 1, 241, 1, 242, 1, 242, 1, 243, 1, 243, 1, 244, 1, + 244, 1, 245, 1, 245, 1, 246, 1, 246, 1, 247, 1, 247, 1, 248, 1, 248, 1, + 249, 1, 249, 1, 250, 1, 250, 1, 251, 1, 251, 1, 252, 1, 252, 1, 253, 1, + 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 257, 1, 257, 1, + 258, 1, 258, 1, 259, 1, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 262, 1, + 262, 1, 263, 1, 263, 1, 264, 1, 264, 1, 265, 1, 265, 1, 266, 1, 266, 1, + 267, 1, 267, 1, 268, 1, 268, 1, 269, 1, 269, 1, 270, 1, 270, 1, 271, 1, + 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, 274, 1, 274, 1, 275, 1, 275, 1, + 276, 1, 276, 1, 277, 1, 277, 1, 278, 1, 278, 1, 279, 1, 279, 1, 280, 1, + 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 283, 1, 283, 1, 284, 1, 284, 1, + 285, 1, 285, 1, 286, 1, 286, 1, 287, 1, 287, 1, 288, 1, 288, 1, 289, 1, + 289, 1, 290, 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 293, 1, 293, 1, + 294, 1, 294, 1, 295, 1, 295, 1, 296, 1, 296, 1, 297, 1, 297, 1, 298, 1, + 298, 1, 299, 1, 299, 1, 300, 1, 300, 1, 301, 1, 301, 1, 302, 1, 302, 1, + 303, 1, 303, 1, 304, 1, 304, 1, 305, 1, 305, 1, 306, 1, 306, 1, 307, 1, + 307, 1, 308, 1, 308, 1, 309, 1, 309, 1, 310, 1, 310, 1, 311, 1, 311, 1, + 312, 1, 312, 1, 313, 1, 313, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 5, 315, 2455, 8, 315, 10, 315, 12, 315, 2458, 9, 315, + 1, 316, 1, 316, 1, 316, 0, 0, 317, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, + 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, + 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, + 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, + 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, + 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, + 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, + 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, + 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, + 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, + 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, + 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, + 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, + 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, + 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, + 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, + 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, + 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, + 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, + 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, + 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, + 0, 9, 1, 0, 168, 169, 2, 0, 14, 14, 16, 16, 1, 0, 19, 23, 1, 0, 176, 177, + 3, 0, 141, 141, 146, 146, 174, 174, 1, 0, 170, 171, 2, 0, 57, 57, 131, + 131, 6, 0, 84, 84, 118, 118, 127, 127, 141, 141, 147, 167, 174, 174, 2, + 0, 71, 71, 174, 174, 2431, 0, 635, 1, 0, 0, 0, 2, 653, 1, 0, 0, 0, 4, 666, + 1, 0, 0, 0, 6, 668, 1, 0, 0, 0, 8, 708, 1, 0, 0, 0, 10, 712, 1, 0, 0, 0, + 12, 720, 1, 0, 0, 0, 14, 722, 1, 0, 0, 0, 16, 724, 1, 0, 0, 0, 18, 727, + 1, 0, 0, 0, 20, 732, 1, 0, 0, 0, 22, 736, 1, 0, 0, 0, 24, 743, 1, 0, 0, + 0, 26, 753, 1, 0, 0, 0, 28, 765, 1, 0, 0, 0, 30, 784, 1, 0, 0, 0, 32, 819, + 1, 0, 0, 0, 34, 821, 1, 0, 0, 0, 36, 834, 1, 0, 0, 0, 38, 843, 1, 0, 0, + 0, 40, 858, 1, 0, 0, 0, 42, 869, 1, 0, 0, 0, 44, 883, 1, 0, 0, 0, 46, 911, + 1, 0, 0, 0, 48, 918, 1, 0, 0, 0, 50, 927, 1, 0, 0, 0, 52, 938, 1, 0, 0, + 0, 54, 940, 1, 0, 0, 0, 56, 957, 1, 0, 0, 0, 58, 984, 1, 0, 0, 0, 60, 986, + 1, 0, 0, 0, 62, 999, 1, 0, 0, 0, 64, 1005, 1, 0, 0, 0, 66, 1035, 1, 0, + 0, 0, 68, 1037, 1, 0, 0, 0, 70, 1049, 1, 0, 0, 0, 72, 1053, 1, 0, 0, 0, + 74, 1066, 1, 0, 0, 0, 76, 1078, 1, 0, 0, 0, 78, 1081, 1, 0, 0, 0, 80, 1089, + 1, 0, 0, 0, 82, 1094, 1, 0, 0, 0, 84, 1096, 1, 0, 0, 0, 86, 1109, 1, 0, + 0, 0, 88, 1111, 1, 0, 0, 0, 90, 1114, 1, 0, 0, 0, 92, 1123, 1, 0, 0, 0, + 94, 1127, 1, 0, 0, 0, 96, 1139, 1, 0, 0, 0, 98, 1144, 1, 0, 0, 0, 100, + 1155, 1, 0, 0, 0, 102, 1157, 1, 0, 0, 0, 104, 1160, 1, 0, 0, 0, 106, 1165, + 1, 0, 0, 0, 108, 1169, 1, 0, 0, 0, 110, 1172, 1, 0, 0, 0, 112, 1181, 1, + 0, 0, 0, 114, 1184, 1, 0, 0, 0, 116, 1193, 1, 0, 0, 0, 118, 1197, 1, 0, + 0, 0, 120, 1200, 1, 0, 0, 0, 122, 1209, 1, 0, 0, 0, 124, 1212, 1, 0, 0, + 0, 126, 1218, 1, 0, 0, 0, 128, 1244, 1, 0, 0, 0, 130, 1246, 1, 0, 0, 0, + 132, 1260, 1, 0, 0, 0, 134, 1267, 1, 0, 0, 0, 136, 1279, 1, 0, 0, 0, 138, + 1292, 1, 0, 0, 0, 140, 1304, 1, 0, 0, 0, 142, 1316, 1, 0, 0, 0, 144, 1325, + 1, 0, 0, 0, 146, 1332, 1, 0, 0, 0, 148, 1339, 1, 0, 0, 0, 150, 1346, 1, + 0, 0, 0, 152, 1358, 1, 0, 0, 0, 154, 1370, 1, 0, 0, 0, 156, 1377, 1, 0, + 0, 0, 158, 1387, 1, 0, 0, 0, 160, 1404, 1, 0, 0, 0, 162, 1406, 1, 0, 0, + 0, 164, 1410, 1, 0, 0, 0, 166, 1412, 1, 0, 0, 0, 168, 1424, 1, 0, 0, 0, + 170, 1428, 1, 0, 0, 0, 172, 1432, 1, 0, 0, 0, 174, 1434, 1, 0, 0, 0, 176, + 1448, 1, 0, 0, 0, 178, 1453, 1, 0, 0, 0, 180, 1456, 1, 0, 0, 0, 182, 1465, + 1, 0, 0, 0, 184, 1467, 1, 0, 0, 0, 186, 1469, 1, 0, 0, 0, 188, 1473, 1, + 0, 0, 0, 190, 1479, 1, 0, 0, 0, 192, 1488, 1, 0, 0, 0, 194, 1497, 1, 0, + 0, 0, 196, 1499, 1, 0, 0, 0, 198, 1501, 1, 0, 0, 0, 200, 1504, 1, 0, 0, + 0, 202, 1514, 1, 0, 0, 0, 204, 1516, 1, 0, 0, 0, 206, 1530, 1, 0, 0, 0, + 208, 1545, 1, 0, 0, 0, 210, 1547, 1, 0, 0, 0, 212, 1551, 1, 0, 0, 0, 214, + 1554, 1, 0, 0, 0, 216, 1560, 1, 0, 0, 0, 218, 1576, 1, 0, 0, 0, 220, 1582, + 1, 0, 0, 0, 222, 1584, 1, 0, 0, 0, 224, 1589, 1, 0, 0, 0, 226, 1594, 1, + 0, 0, 0, 228, 1600, 1, 0, 0, 0, 230, 1618, 1, 0, 0, 0, 232, 1635, 1, 0, + 0, 0, 234, 1638, 1, 0, 0, 0, 236, 1655, 1, 0, 0, 0, 238, 1658, 1, 0, 0, + 0, 240, 1667, 1, 0, 0, 0, 242, 1671, 1, 0, 0, 0, 244, 1684, 1, 0, 0, 0, + 246, 1686, 1, 0, 0, 0, 248, 1690, 1, 0, 0, 0, 250, 1696, 1, 0, 0, 0, 252, + 1702, 1, 0, 0, 0, 254, 1706, 1, 0, 0, 0, 256, 1711, 1, 0, 0, 0, 258, 1725, + 1, 0, 0, 0, 260, 1742, 1, 0, 0, 0, 262, 1756, 1, 0, 0, 0, 264, 1758, 1, + 0, 0, 0, 266, 1771, 1, 0, 0, 0, 268, 1805, 1, 0, 0, 0, 270, 1807, 1, 0, + 0, 0, 272, 1812, 1, 0, 0, 0, 274, 1815, 1, 0, 0, 0, 276, 1818, 1, 0, 0, + 0, 278, 1822, 1, 0, 0, 0, 280, 1833, 1, 0, 0, 0, 282, 1835, 1, 0, 0, 0, + 284, 1839, 1, 0, 0, 0, 286, 1848, 1, 0, 0, 0, 288, 1863, 1, 0, 0, 0, 290, + 1865, 1, 0, 0, 0, 292, 1892, 1, 0, 0, 0, 294, 1895, 1, 0, 0, 0, 296, 1900, + 1, 0, 0, 0, 298, 1905, 1, 0, 0, 0, 300, 1909, 1, 0, 0, 0, 302, 1912, 1, + 0, 0, 0, 304, 1923, 1, 0, 0, 0, 306, 1928, 1, 0, 0, 0, 308, 1931, 1, 0, + 0, 0, 310, 1935, 1, 0, 0, 0, 312, 1957, 1, 0, 0, 0, 314, 1959, 1, 0, 0, + 0, 316, 1961, 1, 0, 0, 0, 318, 1963, 1, 0, 0, 0, 320, 1968, 1, 0, 0, 0, + 322, 1971, 1, 0, 0, 0, 324, 2049, 1, 0, 0, 0, 326, 2051, 1, 0, 0, 0, 328, + 2053, 1, 0, 0, 0, 330, 2057, 1, 0, 0, 0, 332, 2061, 1, 0, 0, 0, 334, 2065, + 1, 0, 0, 0, 336, 2069, 1, 0, 0, 0, 338, 2075, 1, 0, 0, 0, 340, 2079, 1, + 0, 0, 0, 342, 2083, 1, 0, 0, 0, 344, 2090, 1, 0, 0, 0, 346, 2092, 1, 0, + 0, 0, 348, 2096, 1, 0, 0, 0, 350, 2100, 1, 0, 0, 0, 352, 2106, 1, 0, 0, + 0, 354, 2113, 1, 0, 0, 0, 356, 2115, 1, 0, 0, 0, 358, 2127, 1, 0, 0, 0, + 360, 2136, 1, 0, 0, 0, 362, 2147, 1, 0, 0, 0, 364, 2149, 1, 0, 0, 0, 366, + 2151, 1, 0, 0, 0, 368, 2153, 1, 0, 0, 0, 370, 2155, 1, 0, 0, 0, 372, 2157, + 1, 0, 0, 0, 374, 2163, 1, 0, 0, 0, 376, 2172, 1, 0, 0, 0, 378, 2180, 1, + 0, 0, 0, 380, 2182, 1, 0, 0, 0, 382, 2186, 1, 0, 0, 0, 384, 2188, 1, 0, + 0, 0, 386, 2202, 1, 0, 0, 0, 388, 2204, 1, 0, 0, 0, 390, 2206, 1, 0, 0, + 0, 392, 2208, 1, 0, 0, 0, 394, 2210, 1, 0, 0, 0, 396, 2212, 1, 0, 0, 0, + 398, 2214, 1, 0, 0, 0, 400, 2216, 1, 0, 0, 0, 402, 2218, 1, 0, 0, 0, 404, + 2220, 1, 0, 0, 0, 406, 2222, 1, 0, 0, 0, 408, 2224, 1, 0, 0, 0, 410, 2226, + 1, 0, 0, 0, 412, 2229, 1, 0, 0, 0, 414, 2231, 1, 0, 0, 0, 416, 2233, 1, + 0, 0, 0, 418, 2235, 1, 0, 0, 0, 420, 2237, 1, 0, 0, 0, 422, 2240, 1, 0, + 0, 0, 424, 2242, 1, 0, 0, 0, 426, 2244, 1, 0, 0, 0, 428, 2246, 1, 0, 0, + 0, 430, 2248, 1, 0, 0, 0, 432, 2250, 1, 0, 0, 0, 434, 2252, 1, 0, 0, 0, + 436, 2254, 1, 0, 0, 0, 438, 2256, 1, 0, 0, 0, 440, 2258, 1, 0, 0, 0, 442, + 2260, 1, 0, 0, 0, 444, 2262, 1, 0, 0, 0, 446, 2264, 1, 0, 0, 0, 448, 2266, + 1, 0, 0, 0, 450, 2268, 1, 0, 0, 0, 452, 2270, 1, 0, 0, 0, 454, 2272, 1, + 0, 0, 0, 456, 2274, 1, 0, 0, 0, 458, 2276, 1, 0, 0, 0, 460, 2278, 1, 0, + 0, 0, 462, 2280, 1, 0, 0, 0, 464, 2282, 1, 0, 0, 0, 466, 2284, 1, 0, 0, + 0, 468, 2286, 1, 0, 0, 0, 470, 2288, 1, 0, 0, 0, 472, 2290, 1, 0, 0, 0, + 474, 2292, 1, 0, 0, 0, 476, 2294, 1, 0, 0, 0, 478, 2296, 1, 0, 0, 0, 480, + 2298, 1, 0, 0, 0, 482, 2300, 1, 0, 0, 0, 484, 2302, 1, 0, 0, 0, 486, 2304, + 1, 0, 0, 0, 488, 2306, 1, 0, 0, 0, 490, 2308, 1, 0, 0, 0, 492, 2310, 1, + 0, 0, 0, 494, 2312, 1, 0, 0, 0, 496, 2314, 1, 0, 0, 0, 498, 2316, 1, 0, + 0, 0, 500, 2318, 1, 0, 0, 0, 502, 2320, 1, 0, 0, 0, 504, 2322, 1, 0, 0, + 0, 506, 2324, 1, 0, 0, 0, 508, 2326, 1, 0, 0, 0, 510, 2328, 1, 0, 0, 0, + 512, 2330, 1, 0, 0, 0, 514, 2332, 1, 0, 0, 0, 516, 2334, 1, 0, 0, 0, 518, + 2336, 1, 0, 0, 0, 520, 2338, 1, 0, 0, 0, 522, 2340, 1, 0, 0, 0, 524, 2342, + 1, 0, 0, 0, 526, 2344, 1, 0, 0, 0, 528, 2346, 1, 0, 0, 0, 530, 2348, 1, + 0, 0, 0, 532, 2350, 1, 0, 0, 0, 534, 2352, 1, 0, 0, 0, 536, 2354, 1, 0, + 0, 0, 538, 2356, 1, 0, 0, 0, 540, 2358, 1, 0, 0, 0, 542, 2360, 1, 0, 0, + 0, 544, 2362, 1, 0, 0, 0, 546, 2364, 1, 0, 0, 0, 548, 2366, 1, 0, 0, 0, + 550, 2368, 1, 0, 0, 0, 552, 2370, 1, 0, 0, 0, 554, 2372, 1, 0, 0, 0, 556, + 2374, 1, 0, 0, 0, 558, 2376, 1, 0, 0, 0, 560, 2378, 1, 0, 0, 0, 562, 2380, + 1, 0, 0, 0, 564, 2382, 1, 0, 0, 0, 566, 2384, 1, 0, 0, 0, 568, 2386, 1, + 0, 0, 0, 570, 2388, 1, 0, 0, 0, 572, 2390, 1, 0, 0, 0, 574, 2392, 1, 0, + 0, 0, 576, 2394, 1, 0, 0, 0, 578, 2396, 1, 0, 0, 0, 580, 2398, 1, 0, 0, + 0, 582, 2400, 1, 0, 0, 0, 584, 2402, 1, 0, 0, 0, 586, 2404, 1, 0, 0, 0, + 588, 2406, 1, 0, 0, 0, 590, 2408, 1, 0, 0, 0, 592, 2410, 1, 0, 0, 0, 594, + 2412, 1, 0, 0, 0, 596, 2414, 1, 0, 0, 0, 598, 2416, 1, 0, 0, 0, 600, 2418, + 1, 0, 0, 0, 602, 2420, 1, 0, 0, 0, 604, 2422, 1, 0, 0, 0, 606, 2424, 1, + 0, 0, 0, 608, 2426, 1, 0, 0, 0, 610, 2428, 1, 0, 0, 0, 612, 2430, 1, 0, + 0, 0, 614, 2432, 1, 0, 0, 0, 616, 2434, 1, 0, 0, 0, 618, 2436, 1, 0, 0, + 0, 620, 2438, 1, 0, 0, 0, 622, 2440, 1, 0, 0, 0, 624, 2442, 1, 0, 0, 0, + 626, 2444, 1, 0, 0, 0, 628, 2446, 1, 0, 0, 0, 630, 2448, 1, 0, 0, 0, 632, + 2459, 1, 0, 0, 0, 634, 636, 3, 2, 1, 0, 635, 634, 1, 0, 0, 0, 636, 637, + 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 640, 1, 0, + 0, 0, 639, 641, 5, 15, 0, 0, 640, 639, 1, 0, 0, 0, 640, 641, 1, 0, 0, 0, + 641, 642, 1, 0, 0, 0, 642, 643, 5, 0, 0, 1, 643, 1, 1, 0, 0, 0, 644, 646, + 3, 8, 4, 0, 645, 647, 5, 15, 0, 0, 646, 645, 1, 0, 0, 0, 646, 647, 1, 0, + 0, 0, 647, 648, 1, 0, 0, 0, 648, 649, 3, 4, 2, 0, 649, 652, 1, 0, 0, 0, + 650, 652, 3, 6, 3, 0, 651, 644, 1, 0, 0, 0, 651, 650, 1, 0, 0, 0, 652, + 655, 1, 0, 0, 0, 653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 664, + 1, 0, 0, 0, 655, 653, 1, 0, 0, 0, 656, 661, 3, 8, 4, 0, 657, 659, 5, 15, + 0, 0, 658, 657, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 660, 1, 0, 0, 0, + 660, 662, 3, 4, 2, 0, 661, 658, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, + 665, 1, 0, 0, 0, 663, 665, 3, 6, 3, 0, 664, 656, 1, 0, 0, 0, 664, 663, + 1, 0, 0, 0, 665, 3, 1, 0, 0, 0, 666, 667, 5, 8, 0, 0, 667, 5, 1, 0, 0, + 0, 668, 669, 3, 4, 2, 0, 669, 7, 1, 0, 0, 0, 670, 709, 3, 204, 102, 0, + 671, 709, 3, 130, 65, 0, 672, 709, 3, 124, 62, 0, 673, 709, 3, 98, 49, + 0, 674, 709, 3, 84, 42, 0, 675, 709, 3, 78, 39, 0, 676, 709, 3, 198, 99, + 0, 677, 709, 3, 64, 32, 0, 678, 709, 3, 56, 28, 0, 679, 709, 3, 216, 108, + 0, 680, 709, 3, 54, 27, 0, 681, 709, 3, 44, 22, 0, 682, 709, 3, 36, 18, + 0, 683, 709, 3, 152, 76, 0, 684, 709, 3, 42, 21, 0, 685, 709, 3, 38, 19, + 0, 686, 709, 3, 34, 17, 0, 687, 709, 3, 228, 114, 0, 688, 709, 3, 138, + 69, 0, 689, 709, 3, 140, 70, 0, 690, 709, 3, 150, 75, 0, 691, 709, 3, 148, + 74, 0, 692, 709, 3, 136, 68, 0, 693, 709, 3, 144, 72, 0, 694, 709, 3, 146, + 73, 0, 695, 709, 3, 142, 71, 0, 696, 709, 3, 134, 67, 0, 697, 709, 3, 132, + 66, 0, 698, 709, 3, 28, 14, 0, 699, 709, 3, 266, 133, 0, 700, 709, 3, 26, + 13, 0, 701, 709, 3, 24, 12, 0, 702, 709, 3, 22, 11, 0, 703, 709, 3, 290, + 145, 0, 704, 709, 3, 214, 107, 0, 705, 709, 3, 234, 117, 0, 706, 709, 3, + 212, 106, 0, 707, 709, 3, 10, 5, 0, 708, 670, 1, 0, 0, 0, 708, 671, 1, + 0, 0, 0, 708, 672, 1, 0, 0, 0, 708, 673, 1, 0, 0, 0, 708, 674, 1, 0, 0, + 0, 708, 675, 1, 0, 0, 0, 708, 676, 1, 0, 0, 0, 708, 677, 1, 0, 0, 0, 708, + 678, 1, 0, 0, 0, 708, 679, 1, 0, 0, 0, 708, 680, 1, 0, 0, 0, 708, 681, + 1, 0, 0, 0, 708, 682, 1, 0, 0, 0, 708, 683, 1, 0, 0, 0, 708, 684, 1, 0, + 0, 0, 708, 685, 1, 0, 0, 0, 708, 686, 1, 0, 0, 0, 708, 687, 1, 0, 0, 0, + 708, 688, 1, 0, 0, 0, 708, 689, 1, 0, 0, 0, 708, 690, 1, 0, 0, 0, 708, + 691, 1, 0, 0, 0, 708, 692, 1, 0, 0, 0, 708, 693, 1, 0, 0, 0, 708, 694, + 1, 0, 0, 0, 708, 695, 1, 0, 0, 0, 708, 696, 1, 0, 0, 0, 708, 697, 1, 0, + 0, 0, 708, 698, 1, 0, 0, 0, 708, 699, 1, 0, 0, 0, 708, 700, 1, 0, 0, 0, + 708, 701, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 703, 1, 0, 0, 0, 708, + 704, 1, 0, 0, 0, 708, 705, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 708, 707, + 1, 0, 0, 0, 709, 9, 1, 0, 0, 0, 710, 713, 3, 456, 228, 0, 711, 713, 3, + 458, 229, 0, 712, 710, 1, 0, 0, 0, 712, 711, 1, 0, 0, 0, 713, 714, 1, 0, + 0, 0, 714, 715, 3, 12, 6, 0, 715, 11, 1, 0, 0, 0, 716, 721, 3, 14, 7, 0, + 717, 721, 3, 16, 8, 0, 718, 721, 3, 18, 9, 0, 719, 721, 3, 20, 10, 0, 720, + 716, 1, 0, 0, 0, 720, 717, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 719, + 1, 0, 0, 0, 721, 13, 1, 0, 0, 0, 722, 723, 3, 510, 255, 0, 723, 15, 1, + 0, 0, 0, 724, 725, 3, 574, 287, 0, 725, 17, 1, 0, 0, 0, 726, 728, 3, 572, + 286, 0, 727, 726, 1, 0, 0, 0, 727, 728, 1, 0, 0, 0, 728, 729, 1, 0, 0, + 0, 729, 730, 3, 298, 149, 0, 730, 19, 1, 0, 0, 0, 731, 733, 3, 508, 254, + 0, 732, 731, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, + 735, 3, 374, 187, 0, 735, 21, 1, 0, 0, 0, 736, 737, 3, 606, 303, 0, 737, + 738, 3, 30, 15, 0, 738, 739, 3, 536, 268, 0, 739, 740, 3, 32, 16, 0, 740, + 741, 3, 476, 238, 0, 741, 742, 3, 388, 194, 0, 742, 23, 1, 0, 0, 0, 743, + 744, 3, 516, 258, 0, 744, 748, 3, 558, 279, 0, 745, 746, 3, 534, 267, 0, + 746, 747, 3, 388, 194, 0, 747, 749, 1, 0, 0, 0, 748, 745, 1, 0, 0, 0, 748, + 749, 1, 0, 0, 0, 749, 751, 1, 0, 0, 0, 750, 752, 3, 528, 264, 0, 751, 750, + 1, 0, 0, 0, 751, 752, 1, 0, 0, 0, 752, 25, 1, 0, 0, 0, 753, 754, 3, 516, + 258, 0, 754, 758, 3, 30, 15, 0, 755, 756, 3, 536, 268, 0, 756, 757, 3, + 32, 16, 0, 757, 759, 1, 0, 0, 0, 758, 755, 1, 0, 0, 0, 758, 759, 1, 0, + 0, 0, 759, 763, 1, 0, 0, 0, 760, 761, 3, 534, 267, 0, 761, 762, 3, 388, + 194, 0, 762, 764, 1, 0, 0, 0, 763, 760, 1, 0, 0, 0, 763, 764, 1, 0, 0, + 0, 764, 27, 1, 0, 0, 0, 765, 766, 3, 484, 242, 0, 766, 767, 3, 30, 15, + 0, 767, 768, 3, 536, 268, 0, 768, 769, 3, 32, 16, 0, 769, 770, 3, 578, + 289, 0, 770, 771, 3, 388, 194, 0, 771, 29, 1, 0, 0, 0, 772, 775, 3, 418, + 209, 0, 773, 775, 3, 420, 210, 0, 774, 772, 1, 0, 0, 0, 774, 773, 1, 0, + 0, 0, 775, 785, 1, 0, 0, 0, 776, 785, 3, 424, 212, 0, 777, 785, 3, 434, + 217, 0, 778, 785, 3, 458, 229, 0, 779, 785, 3, 468, 234, 0, 780, 785, 3, + 452, 226, 0, 781, 785, 3, 462, 231, 0, 782, 785, 3, 524, 262, 0, 783, 785, + 3, 560, 280, 0, 784, 774, 1, 0, 0, 0, 784, 776, 1, 0, 0, 0, 784, 777, 1, + 0, 0, 0, 784, 778, 1, 0, 0, 0, 784, 779, 1, 0, 0, 0, 784, 780, 1, 0, 0, + 0, 784, 781, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 784, 783, 1, 0, 0, 0, 785, + 31, 1, 0, 0, 0, 786, 787, 3, 418, 209, 0, 787, 788, 3, 482, 241, 0, 788, + 820, 1, 0, 0, 0, 789, 790, 3, 418, 209, 0, 790, 791, 3, 482, 241, 0, 791, + 792, 3, 488, 244, 0, 792, 793, 3, 508, 254, 0, 793, 794, 3, 374, 187, 0, + 794, 820, 1, 0, 0, 0, 795, 799, 3, 480, 240, 0, 796, 797, 3, 374, 187, + 0, 797, 798, 5, 10, 0, 0, 798, 800, 1, 0, 0, 0, 799, 796, 1, 0, 0, 0, 799, + 800, 1, 0, 0, 0, 800, 801, 1, 0, 0, 0, 801, 802, 3, 400, 200, 0, 802, 820, + 1, 0, 0, 0, 803, 804, 3, 418, 209, 0, 804, 805, 3, 510, 255, 0, 805, 820, + 1, 0, 0, 0, 806, 807, 3, 508, 254, 0, 807, 808, 3, 374, 187, 0, 808, 820, + 1, 0, 0, 0, 809, 811, 3, 572, 286, 0, 810, 809, 1, 0, 0, 0, 810, 811, 1, + 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 820, 3, 298, 149, 0, 813, 814, 3, 418, + 209, 0, 814, 815, 3, 558, 279, 0, 815, 820, 1, 0, 0, 0, 816, 817, 3, 556, + 278, 0, 817, 818, 3, 388, 194, 0, 818, 820, 1, 0, 0, 0, 819, 786, 1, 0, + 0, 0, 819, 789, 1, 0, 0, 0, 819, 795, 1, 0, 0, 0, 819, 803, 1, 0, 0, 0, + 819, 806, 1, 0, 0, 0, 819, 810, 1, 0, 0, 0, 819, 813, 1, 0, 0, 0, 819, + 816, 1, 0, 0, 0, 820, 33, 1, 0, 0, 0, 821, 822, 3, 452, 226, 0, 822, 824, + 3, 594, 297, 0, 823, 825, 3, 276, 138, 0, 824, 823, 1, 0, 0, 0, 824, 825, + 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 826, 827, 3, 404, 202, 0, 827, 828, 3, + 604, 302, 0, 828, 829, 3, 544, 272, 0, 829, 832, 3, 368, 184, 0, 830, 833, + 3, 570, 285, 0, 831, 833, 3, 526, 263, 0, 832, 830, 1, 0, 0, 0, 832, 831, + 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 35, 1, 0, 0, 0, 834, 835, 3, 452, + 226, 0, 835, 837, 3, 556, 278, 0, 836, 838, 3, 276, 138, 0, 837, 836, 1, + 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0, 839, 841, 3, 388, + 194, 0, 840, 842, 3, 126, 63, 0, 841, 840, 1, 0, 0, 0, 841, 842, 1, 0, + 0, 0, 842, 37, 1, 0, 0, 0, 843, 844, 3, 452, 226, 0, 844, 846, 3, 586, + 293, 0, 845, 847, 3, 276, 138, 0, 846, 845, 1, 0, 0, 0, 846, 847, 1, 0, + 0, 0, 847, 851, 1, 0, 0, 0, 848, 849, 3, 374, 187, 0, 849, 850, 5, 10, + 0, 0, 850, 852, 1, 0, 0, 0, 851, 848, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0, + 852, 853, 1, 0, 0, 0, 853, 854, 3, 396, 198, 0, 854, 855, 3, 610, 305, + 0, 855, 856, 3, 40, 20, 0, 856, 857, 3, 612, 306, 0, 857, 39, 1, 0, 0, + 0, 858, 859, 3, 378, 189, 0, 859, 866, 3, 380, 190, 0, 860, 861, 3, 626, + 313, 0, 861, 862, 3, 378, 189, 0, 862, 863, 3, 380, 190, 0, 863, 865, 1, + 0, 0, 0, 864, 860, 1, 0, 0, 0, 865, 868, 1, 0, 0, 0, 866, 864, 1, 0, 0, + 0, 866, 867, 1, 0, 0, 0, 867, 41, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0, 869, + 870, 3, 452, 226, 0, 870, 872, 3, 580, 290, 0, 871, 873, 3, 276, 138, 0, + 872, 871, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 877, 1, 0, 0, 0, 874, + 875, 3, 374, 187, 0, 875, 876, 5, 10, 0, 0, 876, 878, 1, 0, 0, 0, 877, + 874, 1, 0, 0, 0, 877, 878, 1, 0, 0, 0, 878, 879, 1, 0, 0, 0, 879, 880, + 3, 390, 195, 0, 880, 881, 3, 596, 298, 0, 881, 882, 3, 392, 196, 0, 882, + 43, 1, 0, 0, 0, 883, 884, 3, 452, 226, 0, 884, 885, 3, 522, 261, 0, 885, + 887, 3, 600, 300, 0, 886, 888, 3, 276, 138, 0, 887, 886, 1, 0, 0, 0, 887, + 888, 1, 0, 0, 0, 888, 892, 1, 0, 0, 0, 889, 890, 3, 374, 187, 0, 890, 891, + 5, 10, 0, 0, 891, 893, 1, 0, 0, 0, 892, 889, 1, 0, 0, 0, 892, 893, 1, 0, + 0, 0, 893, 894, 1, 0, 0, 0, 894, 895, 3, 394, 197, 0, 895, 896, 3, 430, + 215, 0, 896, 897, 3, 560, 280, 0, 897, 898, 3, 284, 142, 0, 898, 899, 3, + 476, 238, 0, 899, 900, 3, 298, 149, 0, 900, 901, 3, 46, 23, 0, 901, 902, + 3, 546, 273, 0, 902, 903, 3, 504, 252, 0, 903, 904, 3, 610, 305, 0, 904, + 905, 3, 284, 142, 0, 905, 909, 3, 612, 306, 0, 906, 907, 3, 604, 302, 0, + 907, 908, 3, 52, 26, 0, 908, 910, 1, 0, 0, 0, 909, 906, 1, 0, 0, 0, 909, + 910, 1, 0, 0, 0, 910, 45, 1, 0, 0, 0, 911, 912, 3, 602, 301, 0, 912, 916, + 3, 48, 24, 0, 913, 914, 3, 426, 213, 0, 914, 915, 3, 322, 161, 0, 915, + 917, 1, 0, 0, 0, 916, 913, 1, 0, 0, 0, 916, 917, 1, 0, 0, 0, 917, 47, 1, + 0, 0, 0, 918, 924, 3, 50, 25, 0, 919, 920, 3, 426, 213, 0, 920, 921, 3, + 50, 25, 0, 921, 923, 1, 0, 0, 0, 922, 919, 1, 0, 0, 0, 923, 926, 1, 0, + 0, 0, 924, 922, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 49, 1, 0, 0, 0, + 926, 924, 1, 0, 0, 0, 927, 928, 3, 378, 189, 0, 928, 929, 3, 500, 250, + 0, 929, 930, 3, 530, 265, 0, 930, 931, 3, 532, 266, 0, 931, 51, 1, 0, 0, + 0, 932, 939, 3, 158, 79, 0, 933, 934, 3, 158, 79, 0, 934, 935, 3, 426, + 213, 0, 935, 936, 3, 156, 78, 0, 936, 939, 1, 0, 0, 0, 937, 939, 3, 156, + 78, 0, 938, 932, 1, 0, 0, 0, 938, 933, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, + 939, 53, 1, 0, 0, 0, 940, 941, 3, 452, 226, 0, 941, 943, 3, 508, 254, 0, + 942, 944, 3, 276, 138, 0, 943, 942, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, 944, + 945, 1, 0, 0, 0, 945, 946, 3, 374, 187, 0, 946, 947, 3, 604, 302, 0, 947, + 948, 3, 552, 276, 0, 948, 949, 5, 19, 0, 0, 949, 950, 3, 614, 307, 0, 950, + 951, 3, 206, 103, 0, 951, 955, 3, 616, 308, 0, 952, 953, 3, 426, 213, 0, + 953, 954, 3, 210, 105, 0, 954, 956, 1, 0, 0, 0, 955, 952, 1, 0, 0, 0, 955, + 956, 1, 0, 0, 0, 956, 55, 1, 0, 0, 0, 957, 959, 3, 452, 226, 0, 958, 960, + 3, 76, 38, 0, 959, 958, 1, 0, 0, 0, 959, 960, 1, 0, 0, 0, 960, 961, 1, + 0, 0, 0, 961, 963, 3, 480, 240, 0, 962, 964, 3, 276, 138, 0, 963, 962, + 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 968, 1, 0, 0, 0, 965, 966, 3, 374, + 187, 0, 966, 967, 5, 10, 0, 0, 967, 969, 1, 0, 0, 0, 968, 965, 1, 0, 0, + 0, 968, 969, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 971, 3, 400, 200, 0, + 971, 973, 3, 610, 305, 0, 972, 974, 3, 60, 30, 0, 973, 972, 1, 0, 0, 0, + 973, 974, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 3, 612, 306, 0, 976, + 977, 3, 62, 31, 0, 977, 978, 3, 554, 277, 0, 978, 979, 3, 380, 190, 0, + 979, 980, 3, 512, 256, 0, 980, 981, 3, 402, 201, 0, 981, 982, 3, 430, 215, + 0, 982, 983, 3, 58, 29, 0, 983, 57, 1, 0, 0, 0, 984, 985, 7, 0, 0, 0, 985, + 59, 1, 0, 0, 0, 986, 992, 3, 410, 205, 0, 987, 988, 3, 626, 313, 0, 988, + 989, 3, 410, 205, 0, 989, 991, 1, 0, 0, 0, 990, 987, 1, 0, 0, 0, 991, 994, + 1, 0, 0, 0, 992, 990, 1, 0, 0, 0, 992, 993, 1, 0, 0, 0, 993, 61, 1, 0, + 0, 0, 994, 992, 1, 0, 0, 0, 995, 1000, 3, 444, 222, 0, 996, 997, 3, 554, + 277, 0, 997, 998, 3, 532, 266, 0, 998, 1000, 1, 0, 0, 0, 999, 995, 1, 0, + 0, 0, 999, 996, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 3, 536, + 268, 0, 1002, 1003, 3, 532, 266, 0, 1003, 1004, 3, 494, 247, 0, 1004, 63, + 1, 0, 0, 0, 1005, 1007, 3, 452, 226, 0, 1006, 1008, 3, 76, 38, 0, 1007, + 1006, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, + 1011, 3, 416, 208, 0, 1010, 1012, 3, 276, 138, 0, 1011, 1010, 1, 0, 0, + 0, 1011, 1012, 1, 0, 0, 0, 1012, 1016, 1, 0, 0, 0, 1013, 1014, 3, 374, + 187, 0, 1014, 1015, 5, 10, 0, 0, 1015, 1017, 1, 0, 0, 0, 1016, 1013, 1, + 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1019, 3, + 398, 199, 0, 1019, 1020, 3, 610, 305, 0, 1020, 1021, 3, 380, 190, 0, 1021, + 1022, 3, 612, 306, 0, 1022, 1023, 3, 564, 282, 0, 1023, 1024, 3, 400, 200, + 0, 1024, 1025, 3, 568, 284, 0, 1025, 1026, 3, 380, 190, 0, 1026, 1027, + 3, 474, 237, 0, 1027, 1028, 3, 400, 200, 0, 1028, 1029, 3, 492, 246, 0, + 1029, 1030, 3, 66, 33, 0, 1030, 65, 1, 0, 0, 0, 1031, 1036, 3, 362, 181, + 0, 1032, 1036, 3, 74, 37, 0, 1033, 1036, 3, 72, 36, 0, 1034, 1036, 3, 68, + 34, 0, 1035, 1031, 1, 0, 0, 0, 1035, 1032, 1, 0, 0, 0, 1035, 1033, 1, 0, + 0, 0, 1035, 1034, 1, 0, 0, 0, 1036, 67, 1, 0, 0, 0, 1037, 1038, 3, 614, + 307, 0, 1038, 1044, 3, 70, 35, 0, 1039, 1040, 3, 626, 313, 0, 1040, 1041, + 3, 70, 35, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1039, 1, 0, 0, 0, 1043, 1046, + 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1047, + 1, 0, 0, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1048, 3, 616, 308, 0, 1048, 69, + 1, 0, 0, 0, 1049, 1050, 3, 408, 204, 0, 1050, 1051, 5, 9, 0, 0, 1051, 1052, + 3, 66, 33, 0, 1052, 71, 1, 0, 0, 0, 1053, 1054, 3, 610, 305, 0, 1054, 1061, + 3, 74, 37, 0, 1055, 1056, 3, 626, 313, 0, 1056, 1057, 3, 362, 181, 0, 1057, + 1060, 1, 0, 0, 0, 1058, 1060, 3, 74, 37, 0, 1059, 1055, 1, 0, 0, 0, 1059, + 1058, 1, 0, 0, 0, 1060, 1063, 1, 0, 0, 0, 1061, 1059, 1, 0, 0, 0, 1061, + 1062, 1, 0, 0, 0, 1062, 1064, 1, 0, 0, 0, 1063, 1061, 1, 0, 0, 0, 1064, + 1065, 3, 612, 306, 0, 1065, 73, 1, 0, 0, 0, 1066, 1067, 3, 610, 305, 0, + 1067, 1073, 3, 362, 181, 0, 1068, 1069, 3, 626, 313, 0, 1069, 1070, 3, + 362, 181, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1068, 1, 0, 0, 0, 1072, 1075, + 1, 0, 0, 0, 1073, 1071, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1076, + 1, 0, 0, 0, 1075, 1073, 1, 0, 0, 0, 1076, 1077, 3, 612, 306, 0, 1077, 75, + 1, 0, 0, 0, 1078, 1079, 3, 540, 270, 0, 1079, 1080, 3, 550, 275, 0, 1080, + 77, 1, 0, 0, 0, 1081, 1082, 3, 424, 212, 0, 1082, 1083, 3, 594, 297, 0, + 1083, 1084, 3, 404, 202, 0, 1084, 1085, 3, 604, 302, 0, 1085, 1087, 3, + 80, 40, 0, 1086, 1088, 3, 82, 41, 0, 1087, 1086, 1, 0, 0, 0, 1087, 1088, + 1, 0, 0, 0, 1088, 79, 1, 0, 0, 0, 1089, 1090, 3, 544, 272, 0, 1090, 1091, + 3, 368, 184, 0, 1091, 81, 1, 0, 0, 0, 1092, 1095, 3, 570, 285, 0, 1093, + 1095, 3, 526, 263, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1093, 1, 0, 0, 0, 1095, + 83, 1, 0, 0, 0, 1096, 1097, 3, 424, 212, 0, 1097, 1101, 3, 586, 293, 0, + 1098, 1099, 3, 374, 187, 0, 1099, 1100, 5, 10, 0, 0, 1100, 1102, 1, 0, + 0, 0, 1101, 1098, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1102, 1103, 1, 0, + 0, 0, 1103, 1104, 3, 396, 198, 0, 1104, 1105, 3, 86, 43, 0, 1105, 85, 1, + 0, 0, 0, 1106, 1110, 3, 96, 48, 0, 1107, 1110, 3, 94, 47, 0, 1108, 1110, + 3, 88, 44, 0, 1109, 1106, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1109, 1108, + 1, 0, 0, 0, 1110, 87, 1, 0, 0, 0, 1111, 1112, 3, 548, 274, 0, 1112, 1113, + 3, 90, 45, 0, 1113, 89, 1, 0, 0, 0, 1114, 1120, 3, 92, 46, 0, 1115, 1116, + 3, 426, 213, 0, 1116, 1117, 3, 92, 46, 0, 1117, 1119, 1, 0, 0, 0, 1118, + 1115, 1, 0, 0, 0, 1119, 1122, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1120, + 1121, 1, 0, 0, 0, 1121, 91, 1, 0, 0, 0, 1122, 1120, 1, 0, 0, 0, 1123, 1124, + 3, 378, 189, 0, 1124, 1125, 3, 578, 289, 0, 1125, 1126, 3, 378, 189, 0, + 1126, 93, 1, 0, 0, 0, 1127, 1128, 3, 414, 207, 0, 1128, 1129, 3, 378, 189, + 0, 1129, 1136, 3, 380, 190, 0, 1130, 1131, 3, 626, 313, 0, 1131, 1132, + 3, 378, 189, 0, 1132, 1133, 3, 380, 190, 0, 1133, 1135, 1, 0, 0, 0, 1134, + 1130, 1, 0, 0, 0, 1135, 1138, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, + 1137, 1, 0, 0, 0, 1137, 95, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1139, 1140, + 3, 424, 212, 0, 1140, 1141, 3, 378, 189, 0, 1141, 1142, 3, 586, 293, 0, + 1142, 1143, 3, 380, 190, 0, 1143, 97, 1, 0, 0, 0, 1144, 1145, 3, 424, 212, + 0, 1145, 1146, 3, 572, 286, 0, 1146, 1147, 3, 298, 149, 0, 1147, 1148, + 3, 100, 50, 0, 1148, 99, 1, 0, 0, 0, 1149, 1156, 3, 118, 59, 0, 1150, 1156, + 3, 108, 54, 0, 1151, 1156, 3, 106, 53, 0, 1152, 1156, 3, 112, 56, 0, 1153, + 1156, 3, 104, 52, 0, 1154, 1156, 3, 102, 51, 0, 1155, 1149, 1, 0, 0, 0, + 1155, 1150, 1, 0, 0, 0, 1155, 1151, 1, 0, 0, 0, 1155, 1152, 1, 0, 0, 0, + 1155, 1153, 1, 0, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 101, 1, 0, 0, 0, + 1157, 1158, 3, 604, 302, 0, 1158, 1159, 3, 158, 79, 0, 1159, 103, 1, 0, + 0, 0, 1160, 1161, 3, 548, 274, 0, 1161, 1162, 3, 378, 189, 0, 1162, 1163, + 3, 578, 289, 0, 1163, 1164, 3, 378, 189, 0, 1164, 105, 1, 0, 0, 0, 1165, + 1166, 3, 462, 231, 0, 1166, 1167, 3, 448, 224, 0, 1167, 1168, 3, 566, 283, + 0, 1168, 107, 1, 0, 0, 0, 1169, 1170, 3, 462, 231, 0, 1170, 1171, 3, 110, + 55, 0, 1171, 109, 1, 0, 0, 0, 1172, 1178, 3, 378, 189, 0, 1173, 1174, 3, + 626, 313, 0, 1174, 1175, 3, 378, 189, 0, 1175, 1177, 1, 0, 0, 0, 1176, + 1173, 1, 0, 0, 0, 1177, 1180, 1, 0, 0, 0, 1178, 1176, 1, 0, 0, 0, 1178, + 1179, 1, 0, 0, 0, 1179, 111, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1181, + 1182, 3, 424, 212, 0, 1182, 1183, 3, 114, 57, 0, 1183, 113, 1, 0, 0, 0, + 1184, 1190, 3, 116, 58, 0, 1185, 1186, 3, 626, 313, 0, 1186, 1187, 3, 116, + 58, 0, 1187, 1189, 1, 0, 0, 0, 1188, 1185, 1, 0, 0, 0, 1189, 1192, 1, 0, + 0, 0, 1190, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 115, 1, 0, + 0, 0, 1192, 1190, 1, 0, 0, 0, 1193, 1194, 3, 378, 189, 0, 1194, 1195, 3, + 586, 293, 0, 1195, 1196, 3, 380, 190, 0, 1196, 117, 1, 0, 0, 0, 1197, 1198, + 3, 414, 207, 0, 1198, 1199, 3, 120, 60, 0, 1199, 119, 1, 0, 0, 0, 1200, + 1206, 3, 122, 61, 0, 1201, 1202, 3, 626, 313, 0, 1202, 1203, 3, 122, 61, + 0, 1203, 1205, 1, 0, 0, 0, 1204, 1201, 1, 0, 0, 0, 1205, 1208, 1, 0, 0, + 0, 1206, 1204, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 121, 1, 0, 0, + 0, 1208, 1206, 1, 0, 0, 0, 1209, 1210, 3, 378, 189, 0, 1210, 1211, 3, 380, + 190, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 424, 212, 0, 1213, 1214, + 3, 556, 278, 0, 1214, 1216, 3, 388, 194, 0, 1215, 1217, 3, 126, 63, 0, + 1216, 1215, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 125, 1, 0, 0, 0, + 1218, 1219, 3, 604, 302, 0, 1219, 1225, 3, 128, 64, 0, 1220, 1221, 3, 426, + 213, 0, 1221, 1222, 3, 128, 64, 0, 1222, 1224, 1, 0, 0, 0, 1223, 1220, + 1, 0, 0, 0, 1224, 1227, 1, 0, 0, 0, 1225, 1223, 1, 0, 0, 0, 1225, 1226, + 1, 0, 0, 0, 1226, 127, 1, 0, 0, 0, 1227, 1225, 1, 0, 0, 0, 1228, 1229, + 3, 544, 272, 0, 1229, 1230, 5, 19, 0, 0, 1230, 1231, 3, 368, 184, 0, 1231, + 1245, 1, 0, 0, 0, 1232, 1233, 3, 520, 260, 0, 1233, 1234, 5, 19, 0, 0, + 1234, 1235, 3, 370, 185, 0, 1235, 1245, 1, 0, 0, 0, 1236, 1237, 3, 570, + 285, 0, 1237, 1238, 5, 19, 0, 0, 1238, 1239, 3, 370, 185, 0, 1239, 1245, + 1, 0, 0, 0, 1240, 1241, 3, 538, 269, 0, 1241, 1242, 5, 19, 0, 0, 1242, + 1243, 3, 166, 83, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1228, 1, 0, 0, 0, 1244, + 1232, 1, 0, 0, 0, 1244, 1236, 1, 0, 0, 0, 1244, 1240, 1, 0, 0, 0, 1245, + 129, 1, 0, 0, 0, 1246, 1247, 3, 424, 212, 0, 1247, 1248, 3, 522, 261, 0, + 1248, 1252, 3, 600, 300, 0, 1249, 1250, 3, 374, 187, 0, 1250, 1251, 5, + 10, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, 1249, 1, 0, 0, 0, 1252, 1253, 1, + 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1258, 3, 394, 197, 0, 1255, 1256, + 3, 604, 302, 0, 1256, 1257, 3, 158, 79, 0, 1257, 1259, 1, 0, 0, 0, 1258, + 1255, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 131, 1, 0, 0, 0, 1260, + 1261, 3, 462, 231, 0, 1261, 1263, 3, 594, 297, 0, 1262, 1264, 3, 278, 139, + 0, 1263, 1262, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, + 0, 1265, 1266, 3, 404, 202, 0, 1266, 133, 1, 0, 0, 0, 1267, 1268, 3, 462, + 231, 0, 1268, 1270, 3, 586, 293, 0, 1269, 1271, 3, 278, 139, 0, 1270, 1269, + 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, 1275, 1, 0, 0, 0, 1272, 1273, + 3, 374, 187, 0, 1273, 1274, 5, 10, 0, 0, 1274, 1276, 1, 0, 0, 0, 1275, + 1272, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, + 1278, 3, 396, 198, 0, 1278, 135, 1, 0, 0, 0, 1279, 1280, 3, 462, 231, 0, + 1280, 1281, 3, 522, 261, 0, 1281, 1283, 3, 600, 300, 0, 1282, 1284, 3, + 278, 139, 0, 1283, 1282, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1288, + 1, 0, 0, 0, 1285, 1286, 3, 374, 187, 0, 1286, 1287, 5, 10, 0, 0, 1287, + 1289, 1, 0, 0, 0, 1288, 1285, 1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, + 1290, 1, 0, 0, 0, 1290, 1291, 3, 394, 197, 0, 1291, 137, 1, 0, 0, 0, 1292, + 1293, 3, 462, 231, 0, 1293, 1295, 3, 416, 208, 0, 1294, 1296, 3, 278, 139, + 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1300, 1, 0, 0, + 0, 1297, 1298, 3, 374, 187, 0, 1298, 1299, 5, 10, 0, 0, 1299, 1301, 1, + 0, 0, 0, 1300, 1297, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1302, 1, + 0, 0, 0, 1302, 1303, 3, 398, 199, 0, 1303, 139, 1, 0, 0, 0, 1304, 1305, + 3, 462, 231, 0, 1305, 1307, 3, 480, 240, 0, 1306, 1308, 3, 278, 139, 0, + 1307, 1306, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1312, 1, 0, 0, 0, + 1309, 1310, 3, 374, 187, 0, 1310, 1311, 5, 10, 0, 0, 1311, 1313, 1, 0, + 0, 0, 1312, 1309, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 1, 0, + 0, 0, 1314, 1315, 3, 400, 200, 0, 1315, 141, 1, 0, 0, 0, 1316, 1317, 3, + 462, 231, 0, 1317, 1319, 3, 580, 290, 0, 1318, 1320, 3, 278, 139, 0, 1319, + 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, + 1322, 3, 390, 195, 0, 1322, 1323, 3, 536, 268, 0, 1323, 1324, 3, 298, 149, + 0, 1324, 143, 1, 0, 0, 0, 1325, 1326, 3, 462, 231, 0, 1326, 1328, 3, 556, + 278, 0, 1327, 1329, 3, 278, 139, 0, 1328, 1327, 1, 0, 0, 0, 1328, 1329, + 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 1331, 3, 388, 194, 0, 1331, 145, + 1, 0, 0, 0, 1332, 1333, 3, 462, 231, 0, 1333, 1335, 3, 572, 286, 0, 1334, + 1336, 3, 278, 139, 0, 1335, 1334, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, + 1337, 1, 0, 0, 0, 1337, 1338, 3, 298, 149, 0, 1338, 147, 1, 0, 0, 0, 1339, + 1340, 3, 462, 231, 0, 1340, 1342, 3, 508, 254, 0, 1341, 1343, 3, 278, 139, + 0, 1342, 1341, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, + 0, 1344, 1345, 3, 374, 187, 0, 1345, 149, 1, 0, 0, 0, 1346, 1347, 3, 462, + 231, 0, 1347, 1349, 3, 490, 245, 0, 1348, 1350, 3, 278, 139, 0, 1349, 1348, + 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, 1354, 1, 0, 0, 0, 1351, 1352, + 3, 374, 187, 0, 1352, 1353, 5, 10, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, + 1351, 1, 0, 0, 0, 1354, 1355, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, + 1357, 3, 218, 109, 0, 1357, 151, 1, 0, 0, 0, 1358, 1359, 3, 452, 226, 0, + 1359, 1361, 3, 572, 286, 0, 1360, 1362, 3, 276, 138, 0, 1361, 1360, 1, + 0, 0, 0, 1361, 1362, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1364, 3, + 298, 149, 0, 1364, 1365, 3, 610, 305, 0, 1365, 1366, 3, 174, 87, 0, 1366, + 1368, 3, 612, 306, 0, 1367, 1369, 3, 154, 77, 0, 1368, 1367, 1, 0, 0, 0, + 1368, 1369, 1, 0, 0, 0, 1369, 153, 1, 0, 0, 0, 1370, 1372, 3, 604, 302, + 0, 1371, 1373, 3, 158, 79, 0, 1372, 1371, 1, 0, 0, 0, 1372, 1373, 1, 0, + 0, 0, 1373, 1375, 1, 0, 0, 0, 1374, 1376, 3, 156, 78, 0, 1375, 1374, 1, + 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 155, 1, 0, 0, 0, 1377, 1378, 3, + 446, 223, 0, 1378, 1379, 3, 542, 271, 0, 1379, 1380, 3, 442, 221, 0, 1380, + 1381, 3, 610, 305, 0, 1381, 1383, 3, 378, 189, 0, 1382, 1384, 3, 386, 193, + 0, 1383, 1382, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1385, 1, 0, 0, + 0, 1385, 1386, 3, 612, 306, 0, 1386, 157, 1, 0, 0, 0, 1387, 1393, 3, 160, + 80, 0, 1388, 1389, 3, 426, 213, 0, 1389, 1390, 3, 160, 80, 0, 1390, 1392, + 1, 0, 0, 0, 1391, 1388, 1, 0, 0, 0, 1392, 1395, 1, 0, 0, 0, 1393, 1391, + 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 159, 1, 0, 0, 0, 1395, 1393, + 1, 0, 0, 0, 1396, 1397, 3, 162, 81, 0, 1397, 1398, 5, 19, 0, 0, 1398, 1399, + 3, 164, 82, 0, 1399, 1405, 1, 0, 0, 0, 1400, 1401, 3, 162, 81, 0, 1401, + 1402, 5, 19, 0, 0, 1402, 1403, 3, 166, 83, 0, 1403, 1405, 1, 0, 0, 0, 1404, + 1396, 1, 0, 0, 0, 1404, 1400, 1, 0, 0, 0, 1405, 161, 1, 0, 0, 0, 1406, + 1407, 5, 174, 0, 0, 1407, 163, 1, 0, 0, 0, 1408, 1411, 3, 368, 184, 0, + 1409, 1411, 3, 366, 183, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, + 0, 1411, 165, 1, 0, 0, 0, 1412, 1413, 3, 614, 307, 0, 1413, 1419, 3, 168, + 84, 0, 1414, 1415, 3, 626, 313, 0, 1415, 1416, 3, 168, 84, 0, 1416, 1418, + 1, 0, 0, 0, 1417, 1414, 1, 0, 0, 0, 1418, 1421, 1, 0, 0, 0, 1419, 1417, + 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1422, 1, 0, 0, 0, 1421, 1419, + 1, 0, 0, 0, 1422, 1423, 3, 616, 308, 0, 1423, 167, 1, 0, 0, 0, 1424, 1425, + 3, 170, 85, 0, 1425, 1426, 5, 9, 0, 0, 1426, 1427, 3, 172, 86, 0, 1427, + 169, 1, 0, 0, 0, 1428, 1429, 3, 368, 184, 0, 1429, 171, 1, 0, 0, 0, 1430, + 1433, 3, 368, 184, 0, 1431, 1433, 3, 366, 183, 0, 1432, 1430, 1, 0, 0, + 0, 1432, 1431, 1, 0, 0, 0, 1433, 173, 1, 0, 0, 0, 1434, 1440, 3, 176, 88, + 0, 1435, 1436, 3, 626, 313, 0, 1436, 1437, 3, 176, 88, 0, 1437, 1439, 1, + 0, 0, 0, 1438, 1435, 1, 0, 0, 0, 1439, 1442, 1, 0, 0, 0, 1440, 1438, 1, + 0, 0, 0, 1440, 1441, 1, 0, 0, 0, 1441, 1446, 1, 0, 0, 0, 1442, 1440, 1, + 0, 0, 0, 1443, 1444, 3, 626, 313, 0, 1444, 1445, 3, 180, 90, 0, 1445, 1447, + 1, 0, 0, 0, 1446, 1443, 1, 0, 0, 0, 1446, 1447, 1, 0, 0, 0, 1447, 175, + 1, 0, 0, 0, 1448, 1449, 3, 378, 189, 0, 1449, 1451, 3, 380, 190, 0, 1450, + 1452, 3, 178, 89, 0, 1451, 1450, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, + 177, 1, 0, 0, 0, 1453, 1454, 3, 546, 273, 0, 1454, 1455, 3, 504, 252, 0, + 1455, 179, 1, 0, 0, 0, 1456, 1457, 3, 546, 273, 0, 1457, 1458, 3, 504, + 252, 0, 1458, 1459, 3, 610, 305, 0, 1459, 1460, 3, 182, 91, 0, 1460, 1461, + 3, 612, 306, 0, 1461, 181, 1, 0, 0, 0, 1462, 1466, 3, 184, 92, 0, 1463, + 1466, 3, 186, 93, 0, 1464, 1466, 3, 188, 94, 0, 1465, 1462, 1, 0, 0, 0, + 1465, 1463, 1, 0, 0, 0, 1465, 1464, 1, 0, 0, 0, 1466, 183, 1, 0, 0, 0, + 1467, 1468, 3, 378, 189, 0, 1468, 185, 1, 0, 0, 0, 1469, 1470, 3, 194, + 97, 0, 1470, 1471, 3, 626, 313, 0, 1471, 1472, 3, 192, 96, 0, 1472, 187, + 1, 0, 0, 0, 1473, 1474, 3, 610, 305, 0, 1474, 1475, 3, 190, 95, 0, 1475, + 1476, 3, 612, 306, 0, 1476, 1477, 3, 626, 313, 0, 1477, 1478, 3, 192, 96, + 0, 1478, 189, 1, 0, 0, 0, 1479, 1485, 3, 194, 97, 0, 1480, 1481, 3, 626, + 313, 0, 1481, 1482, 3, 194, 97, 0, 1482, 1484, 1, 0, 0, 0, 1483, 1480, + 1, 0, 0, 0, 1484, 1487, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, + 1, 0, 0, 0, 1486, 191, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1488, 1494, + 3, 196, 98, 0, 1489, 1490, 3, 626, 313, 0, 1490, 1491, 3, 196, 98, 0, 1491, + 1493, 1, 0, 0, 0, 1492, 1489, 1, 0, 0, 0, 1493, 1496, 1, 0, 0, 0, 1494, + 1492, 1, 0, 0, 0, 1494, 1495, 1, 0, 0, 0, 1495, 193, 1, 0, 0, 0, 1496, + 1494, 1, 0, 0, 0, 1497, 1498, 3, 378, 189, 0, 1498, 195, 1, 0, 0, 0, 1499, + 1500, 3, 378, 189, 0, 1500, 197, 1, 0, 0, 0, 1501, 1502, 3, 428, 214, 0, + 1502, 1503, 3, 436, 218, 0, 1503, 199, 1, 0, 0, 0, 1504, 1506, 3, 440, + 220, 0, 1505, 1507, 3, 202, 101, 0, 1506, 1505, 1, 0, 0, 0, 1506, 1507, + 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 1510, 3, 436, 218, 0, 1509, 1511, + 3, 274, 137, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 201, + 1, 0, 0, 0, 1512, 1515, 3, 518, 259, 0, 1513, 1515, 3, 588, 294, 0, 1514, + 1512, 1, 0, 0, 0, 1514, 1513, 1, 0, 0, 0, 1515, 203, 1, 0, 0, 0, 1516, + 1517, 3, 424, 212, 0, 1517, 1518, 3, 508, 254, 0, 1518, 1519, 3, 374, 187, + 0, 1519, 1520, 3, 604, 302, 0, 1520, 1521, 3, 552, 276, 0, 1521, 1522, + 5, 19, 0, 0, 1522, 1523, 3, 614, 307, 0, 1523, 1524, 3, 206, 103, 0, 1524, + 1528, 3, 616, 308, 0, 1525, 1526, 3, 426, 213, 0, 1526, 1527, 3, 210, 105, + 0, 1527, 1529, 1, 0, 0, 0, 1528, 1525, 1, 0, 0, 0, 1528, 1529, 1, 0, 0, + 0, 1529, 205, 1, 0, 0, 0, 1530, 1536, 3, 208, 104, 0, 1531, 1532, 3, 626, + 313, 0, 1532, 1533, 3, 208, 104, 0, 1533, 1535, 1, 0, 0, 0, 1534, 1531, + 1, 0, 0, 0, 1535, 1538, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1537, + 1, 0, 0, 0, 1537, 207, 1, 0, 0, 0, 1538, 1536, 1, 0, 0, 0, 1539, 1540, + 5, 169, 0, 0, 1540, 1541, 5, 9, 0, 0, 1541, 1546, 5, 169, 0, 0, 1542, 1543, + 5, 169, 0, 0, 1543, 1544, 5, 9, 0, 0, 1544, 1546, 5, 170, 0, 0, 1545, 1539, + 1, 0, 0, 0, 1545, 1542, 1, 0, 0, 0, 1546, 209, 1, 0, 0, 0, 1547, 1548, + 3, 464, 232, 0, 1548, 1549, 5, 19, 0, 0, 1549, 1550, 3, 370, 185, 0, 1550, + 211, 1, 0, 0, 0, 1551, 1552, 3, 592, 296, 0, 1552, 1553, 3, 374, 187, 0, + 1553, 213, 1, 0, 0, 0, 1554, 1556, 3, 582, 291, 0, 1555, 1557, 3, 572, + 286, 0, 1556, 1555, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 1558, 1, + 0, 0, 0, 1558, 1559, 3, 298, 149, 0, 1559, 215, 1, 0, 0, 0, 1560, 1561, + 3, 452, 226, 0, 1561, 1563, 3, 490, 245, 0, 1562, 1564, 3, 276, 138, 0, + 1563, 1562, 1, 0, 0, 0, 1563, 1564, 1, 0, 0, 0, 1564, 1566, 1, 0, 0, 0, + 1565, 1567, 3, 218, 109, 0, 1566, 1565, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, + 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 3, 536, 268, 0, 1569, 1570, 3, 298, + 149, 0, 1570, 1571, 3, 610, 305, 0, 1571, 1572, 3, 220, 110, 0, 1572, 1573, + 3, 612, 306, 0, 1573, 217, 1, 0, 0, 0, 1574, 1577, 5, 174, 0, 0, 1575, + 1577, 3, 368, 184, 0, 1576, 1574, 1, 0, 0, 0, 1576, 1575, 1, 0, 0, 0, 1577, + 219, 1, 0, 0, 0, 1578, 1583, 3, 378, 189, 0, 1579, 1583, 3, 222, 111, 0, + 1580, 1583, 3, 224, 112, 0, 1581, 1583, 3, 226, 113, 0, 1582, 1578, 1, + 0, 0, 0, 1582, 1579, 1, 0, 0, 0, 1582, 1580, 1, 0, 0, 0, 1582, 1581, 1, + 0, 0, 0, 1583, 221, 1, 0, 0, 0, 1584, 1585, 3, 506, 253, 0, 1585, 1586, + 3, 610, 305, 0, 1586, 1587, 5, 174, 0, 0, 1587, 1588, 3, 612, 306, 0, 1588, + 223, 1, 0, 0, 0, 1589, 1590, 3, 466, 233, 0, 1590, 1591, 3, 610, 305, 0, + 1591, 1592, 5, 174, 0, 0, 1592, 1593, 3, 612, 306, 0, 1593, 225, 1, 0, + 0, 0, 1594, 1595, 3, 478, 239, 0, 1595, 1596, 3, 610, 305, 0, 1596, 1597, + 5, 174, 0, 0, 1597, 1598, 3, 612, 306, 0, 1598, 227, 1, 0, 0, 0, 1599, + 1601, 3, 200, 100, 0, 1600, 1599, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, + 1602, 1, 0, 0, 0, 1602, 1604, 3, 454, 227, 0, 1603, 1605, 3, 230, 115, + 0, 1604, 1603, 1, 0, 0, 0, 1604, 1605, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, + 0, 1606, 1608, 3, 300, 150, 0, 1607, 1609, 3, 274, 137, 0, 1608, 1607, + 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1613, + 3, 306, 153, 0, 1611, 1614, 3, 278, 139, 0, 1612, 1614, 3, 236, 118, 0, + 1613, 1611, 1, 0, 0, 0, 1613, 1612, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, + 1614, 1616, 1, 0, 0, 0, 1615, 1617, 3, 4, 2, 0, 1616, 1615, 1, 0, 0, 0, + 1616, 1617, 1, 0, 0, 0, 1617, 229, 1, 0, 0, 0, 1618, 1624, 3, 232, 116, + 0, 1619, 1620, 3, 626, 313, 0, 1620, 1621, 3, 232, 116, 0, 1621, 1623, + 1, 0, 0, 0, 1622, 1619, 1, 0, 0, 0, 1623, 1626, 1, 0, 0, 0, 1624, 1622, + 1, 0, 0, 0, 1624, 1625, 1, 0, 0, 0, 1625, 231, 1, 0, 0, 0, 1626, 1624, + 1, 0, 0, 0, 1627, 1629, 3, 314, 157, 0, 1628, 1630, 3, 320, 160, 0, 1629, + 1628, 1, 0, 0, 0, 1629, 1630, 1, 0, 0, 0, 1630, 1636, 1, 0, 0, 0, 1631, + 1633, 3, 318, 159, 0, 1632, 1634, 3, 320, 160, 0, 1633, 1632, 1, 0, 0, + 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1627, 1, 0, 0, + 0, 1635, 1631, 1, 0, 0, 0, 1636, 233, 1, 0, 0, 0, 1637, 1639, 3, 200, 100, + 0, 1638, 1637, 1, 0, 0, 0, 1638, 1639, 1, 0, 0, 0, 1639, 1640, 1, 0, 0, + 0, 1640, 1641, 3, 590, 295, 0, 1641, 1643, 3, 298, 149, 0, 1642, 1644, + 3, 268, 134, 0, 1643, 1642, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, + 1, 0, 0, 0, 1645, 1646, 3, 562, 281, 0, 1646, 1647, 3, 242, 121, 0, 1647, + 1650, 3, 306, 153, 0, 1648, 1651, 3, 278, 139, 0, 1649, 1651, 3, 236, 118, + 0, 1650, 1648, 1, 0, 0, 0, 1650, 1649, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, + 0, 1651, 1653, 1, 0, 0, 0, 1652, 1654, 3, 4, 2, 0, 1653, 1652, 1, 0, 0, + 0, 1653, 1654, 1, 0, 0, 0, 1654, 235, 1, 0, 0, 0, 1655, 1656, 3, 486, 243, + 0, 1656, 1657, 3, 238, 119, 0, 1657, 237, 1, 0, 0, 0, 1658, 1664, 3, 240, + 120, 0, 1659, 1660, 3, 426, 213, 0, 1660, 1661, 3, 240, 120, 0, 1661, 1663, + 1, 0, 0, 0, 1662, 1659, 1, 0, 0, 0, 1663, 1666, 1, 0, 0, 0, 1664, 1662, + 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 239, 1, 0, 0, 0, 1666, 1664, + 1, 0, 0, 0, 1667, 1668, 5, 174, 0, 0, 1668, 1669, 5, 19, 0, 0, 1669, 1670, + 3, 362, 181, 0, 1670, 241, 1, 0, 0, 0, 1671, 1677, 3, 244, 122, 0, 1672, + 1673, 3, 626, 313, 0, 1673, 1674, 3, 244, 122, 0, 1674, 1676, 1, 0, 0, + 0, 1675, 1672, 1, 0, 0, 0, 1676, 1679, 1, 0, 0, 0, 1677, 1675, 1, 0, 0, + 0, 1677, 1678, 1, 0, 0, 0, 1678, 243, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, + 0, 1680, 1685, 3, 250, 125, 0, 1681, 1685, 3, 248, 124, 0, 1682, 1685, + 3, 246, 123, 0, 1683, 1685, 3, 254, 127, 0, 1684, 1680, 1, 0, 0, 0, 1684, + 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, + 245, 1, 0, 0, 0, 1686, 1687, 3, 378, 189, 0, 1687, 1688, 5, 19, 0, 0, 1688, + 1689, 3, 360, 180, 0, 1689, 247, 1, 0, 0, 0, 1690, 1691, 3, 378, 189, 0, + 1691, 1692, 5, 19, 0, 0, 1692, 1693, 3, 360, 180, 0, 1693, 1694, 3, 262, + 131, 0, 1694, 1695, 5, 174, 0, 0, 1695, 249, 1, 0, 0, 0, 1696, 1697, 3, + 378, 189, 0, 1697, 1698, 5, 19, 0, 0, 1698, 1699, 5, 174, 0, 0, 1699, 1700, + 3, 262, 131, 0, 1700, 1701, 3, 360, 180, 0, 1701, 251, 1, 0, 0, 0, 1702, + 1703, 3, 622, 311, 0, 1703, 1704, 3, 362, 181, 0, 1704, 1705, 3, 624, 312, + 0, 1705, 253, 1, 0, 0, 0, 1706, 1707, 3, 378, 189, 0, 1707, 1708, 3, 252, + 126, 0, 1708, 1709, 5, 19, 0, 0, 1709, 1710, 3, 362, 181, 0, 1710, 255, + 1, 0, 0, 0, 1711, 1721, 3, 614, 307, 0, 1712, 1718, 3, 362, 181, 0, 1713, + 1714, 3, 626, 313, 0, 1714, 1715, 3, 362, 181, 0, 1715, 1717, 1, 0, 0, + 0, 1716, 1713, 1, 0, 0, 0, 1717, 1720, 1, 0, 0, 0, 1718, 1716, 1, 0, 0, + 0, 1718, 1719, 1, 0, 0, 0, 1719, 1722, 1, 0, 0, 0, 1720, 1718, 1, 0, 0, + 0, 1721, 1712, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, + 0, 1723, 1724, 3, 616, 308, 0, 1724, 257, 1, 0, 0, 0, 1725, 1726, 3, 614, + 307, 0, 1726, 1727, 3, 362, 181, 0, 1727, 1728, 3, 628, 314, 0, 1728, 1729, + 3, 362, 181, 0, 1729, 1737, 1, 0, 0, 0, 1730, 1731, 3, 626, 313, 0, 1731, + 1732, 3, 362, 181, 0, 1732, 1733, 3, 628, 314, 0, 1733, 1734, 3, 362, 181, + 0, 1734, 1736, 1, 0, 0, 0, 1735, 1730, 1, 0, 0, 0, 1736, 1739, 1, 0, 0, + 0, 1737, 1735, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1740, 1, 0, 0, + 0, 1739, 1737, 1, 0, 0, 0, 1740, 1741, 3, 616, 308, 0, 1741, 259, 1, 0, + 0, 0, 1742, 1752, 3, 622, 311, 0, 1743, 1749, 3, 362, 181, 0, 1744, 1745, + 3, 626, 313, 0, 1745, 1746, 3, 362, 181, 0, 1746, 1748, 1, 0, 0, 0, 1747, + 1744, 1, 0, 0, 0, 1748, 1751, 1, 0, 0, 0, 1749, 1747, 1, 0, 0, 0, 1749, + 1750, 1, 0, 0, 0, 1750, 1753, 1, 0, 0, 0, 1751, 1749, 1, 0, 0, 0, 1752, + 1743, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1754, 1, 0, 0, 0, 1754, + 1755, 3, 624, 312, 0, 1755, 261, 1, 0, 0, 0, 1756, 1757, 7, 1, 0, 0, 1757, + 263, 1, 0, 0, 0, 1758, 1759, 3, 610, 305, 0, 1759, 1765, 3, 288, 144, 0, + 1760, 1761, 3, 626, 313, 0, 1761, 1762, 3, 288, 144, 0, 1762, 1764, 1, + 0, 0, 0, 1763, 1760, 1, 0, 0, 0, 1764, 1767, 1, 0, 0, 0, 1765, 1763, 1, + 0, 0, 0, 1765, 1766, 1, 0, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1765, 1, + 0, 0, 0, 1768, 1769, 3, 612, 306, 0, 1769, 265, 1, 0, 0, 0, 1770, 1772, + 3, 200, 100, 0, 1771, 1770, 1, 0, 0, 0, 1771, 1772, 1, 0, 0, 0, 1772, 1773, + 1, 0, 0, 0, 1773, 1774, 3, 496, 248, 0, 1774, 1775, 3, 498, 249, 0, 1775, + 1777, 3, 298, 149, 0, 1776, 1778, 3, 282, 141, 0, 1777, 1776, 1, 0, 0, + 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1781, 3, 280, + 140, 0, 1780, 1782, 3, 276, 138, 0, 1781, 1780, 1, 0, 0, 0, 1781, 1782, + 1, 0, 0, 0, 1782, 1784, 1, 0, 0, 0, 1783, 1785, 3, 268, 134, 0, 1784, 1783, + 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1787, 1, 0, 0, 0, 1786, 1788, + 3, 4, 2, 0, 1787, 1786, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 267, + 1, 0, 0, 0, 1789, 1790, 3, 596, 298, 0, 1790, 1791, 3, 272, 136, 0, 1791, + 1806, 1, 0, 0, 0, 1792, 1793, 3, 596, 298, 0, 1793, 1794, 3, 272, 136, + 0, 1794, 1795, 3, 426, 213, 0, 1795, 1796, 3, 270, 135, 0, 1796, 1806, + 1, 0, 0, 0, 1797, 1798, 3, 596, 298, 0, 1798, 1799, 3, 270, 135, 0, 1799, + 1806, 1, 0, 0, 0, 1800, 1801, 3, 596, 298, 0, 1801, 1802, 3, 270, 135, + 0, 1802, 1803, 3, 426, 213, 0, 1803, 1804, 3, 272, 136, 0, 1804, 1806, + 1, 0, 0, 0, 1805, 1789, 1, 0, 0, 0, 1805, 1792, 1, 0, 0, 0, 1805, 1797, + 1, 0, 0, 0, 1805, 1800, 1, 0, 0, 0, 1806, 269, 1, 0, 0, 0, 1807, 1810, + 3, 576, 288, 0, 1808, 1811, 3, 342, 171, 0, 1809, 1811, 3, 364, 182, 0, + 1810, 1808, 1, 0, 0, 0, 1810, 1809, 1, 0, 0, 0, 1811, 271, 1, 0, 0, 0, + 1812, 1813, 3, 584, 292, 0, 1813, 1814, 3, 364, 182, 0, 1814, 273, 1, 0, + 0, 0, 1815, 1816, 3, 596, 298, 0, 1816, 1817, 3, 270, 135, 0, 1817, 275, + 1, 0, 0, 0, 1818, 1819, 3, 486, 243, 0, 1819, 1820, 3, 530, 265, 0, 1820, + 1821, 3, 470, 235, 0, 1821, 277, 1, 0, 0, 0, 1822, 1823, 3, 486, 243, 0, + 1823, 1824, 3, 470, 235, 0, 1824, 279, 1, 0, 0, 0, 1825, 1826, 3, 598, + 299, 0, 1826, 1827, 5, 1, 0, 0, 1827, 1828, 3, 286, 143, 0, 1828, 1829, + 5, 2, 0, 0, 1829, 1834, 1, 0, 0, 0, 1830, 1831, 3, 502, 251, 0, 1831, 1832, + 3, 362, 181, 0, 1832, 1834, 1, 0, 0, 0, 1833, 1825, 1, 0, 0, 0, 1833, 1830, + 1, 0, 0, 0, 1834, 281, 1, 0, 0, 0, 1835, 1836, 5, 1, 0, 0, 1836, 1837, + 3, 284, 142, 0, 1837, 1838, 5, 2, 0, 0, 1838, 283, 1, 0, 0, 0, 1839, 1845, + 3, 378, 189, 0, 1840, 1841, 3, 626, 313, 0, 1841, 1842, 3, 378, 189, 0, + 1842, 1844, 1, 0, 0, 0, 1843, 1840, 1, 0, 0, 0, 1844, 1847, 1, 0, 0, 0, + 1845, 1843, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 285, 1, 0, 0, 0, + 1847, 1845, 1, 0, 0, 0, 1848, 1854, 3, 360, 180, 0, 1849, 1850, 3, 626, + 313, 0, 1850, 1851, 3, 360, 180, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1849, + 1, 0, 0, 0, 1853, 1856, 1, 0, 0, 0, 1854, 1852, 1, 0, 0, 0, 1854, 1855, + 1, 0, 0, 0, 1855, 287, 1, 0, 0, 0, 1856, 1854, 1, 0, 0, 0, 1857, 1864, + 3, 362, 181, 0, 1858, 1864, 3, 352, 176, 0, 1859, 1864, 3, 258, 129, 0, + 1860, 1864, 3, 256, 128, 0, 1861, 1864, 3, 260, 130, 0, 1862, 1864, 3, + 264, 132, 0, 1863, 1857, 1, 0, 0, 0, 1863, 1858, 1, 0, 0, 0, 1863, 1859, + 1, 0, 0, 0, 1863, 1860, 1, 0, 0, 0, 1863, 1861, 1, 0, 0, 0, 1863, 1862, + 1, 0, 0, 0, 1864, 289, 1, 0, 0, 0, 1865, 1867, 3, 560, 280, 0, 1866, 1868, + 3, 308, 154, 0, 1867, 1866, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1870, + 1, 0, 0, 0, 1869, 1871, 3, 502, 251, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, + 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1873, 3, 310, 155, 0, 1873, 1875, + 3, 300, 150, 0, 1874, 1876, 3, 306, 153, 0, 1875, 1874, 1, 0, 0, 0, 1875, + 1876, 1, 0, 0, 0, 1876, 1878, 1, 0, 0, 0, 1877, 1879, 3, 630, 315, 0, 1878, + 1877, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 1881, 1, 0, 0, 0, 1880, + 1882, 3, 302, 151, 0, 1881, 1880, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, + 1884, 1, 0, 0, 0, 1883, 1885, 3, 294, 147, 0, 1884, 1883, 1, 0, 0, 0, 1884, + 1885, 1, 0, 0, 0, 1885, 1887, 1, 0, 0, 0, 1886, 1888, 3, 292, 146, 0, 1887, + 1886, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, + 1891, 3, 4, 2, 0, 1890, 1889, 1, 0, 0, 0, 1890, 1891, 1, 0, 0, 0, 1891, + 291, 1, 0, 0, 0, 1892, 1893, 3, 422, 211, 0, 1893, 1894, 3, 472, 236, 0, + 1894, 293, 1, 0, 0, 0, 1895, 1898, 3, 514, 257, 0, 1896, 1899, 3, 342, + 171, 0, 1897, 1899, 3, 364, 182, 0, 1898, 1896, 1, 0, 0, 0, 1898, 1897, + 1, 0, 0, 0, 1899, 295, 1, 0, 0, 0, 1900, 1901, 5, 83, 0, 0, 1901, 297, + 1, 0, 0, 0, 1902, 1903, 3, 374, 187, 0, 1903, 1904, 5, 10, 0, 0, 1904, + 1906, 1, 0, 0, 0, 1905, 1902, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, + 1907, 1, 0, 0, 0, 1907, 1908, 3, 376, 188, 0, 1908, 299, 1, 0, 0, 0, 1909, + 1910, 3, 476, 238, 0, 1910, 1911, 3, 298, 149, 0, 1911, 301, 1, 0, 0, 0, + 1912, 1913, 3, 542, 271, 0, 1913, 1914, 3, 442, 221, 0, 1914, 1920, 3, + 304, 152, 0, 1915, 1916, 3, 626, 313, 0, 1916, 1917, 3, 304, 152, 0, 1917, + 1919, 1, 0, 0, 0, 1918, 1915, 1, 0, 0, 0, 1919, 1922, 1, 0, 0, 0, 1920, + 1918, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 303, 1, 0, 0, 0, 1922, + 1920, 1, 0, 0, 0, 1923, 1926, 5, 174, 0, 0, 1924, 1927, 3, 432, 216, 0, + 1925, 1927, 3, 456, 228, 0, 1926, 1924, 1, 0, 0, 0, 1926, 1925, 1, 0, 0, + 0, 1926, 1927, 1, 0, 0, 0, 1927, 305, 1, 0, 0, 0, 1928, 1929, 3, 602, 301, + 0, 1929, 1930, 3, 322, 161, 0, 1930, 307, 1, 0, 0, 0, 1931, 1932, 3, 460, + 230, 0, 1932, 309, 1, 0, 0, 0, 1933, 1936, 5, 11, 0, 0, 1934, 1936, 3, + 312, 156, 0, 1935, 1933, 1, 0, 0, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1942, + 1, 0, 0, 0, 1937, 1938, 3, 626, 313, 0, 1938, 1939, 3, 312, 156, 0, 1939, + 1941, 1, 0, 0, 0, 1940, 1937, 1, 0, 0, 0, 1941, 1944, 1, 0, 0, 0, 1942, + 1940, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 311, 1, 0, 0, 0, 1944, + 1942, 1, 0, 0, 0, 1945, 1947, 3, 314, 157, 0, 1946, 1948, 3, 320, 160, + 0, 1947, 1946, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1958, 1, 0, 0, + 0, 1949, 1951, 3, 316, 158, 0, 1950, 1952, 3, 320, 160, 0, 1951, 1950, + 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1958, 1, 0, 0, 0, 1953, 1955, + 3, 318, 159, 0, 1954, 1956, 3, 320, 160, 0, 1955, 1954, 1, 0, 0, 0, 1955, + 1956, 1, 0, 0, 0, 1956, 1958, 1, 0, 0, 0, 1957, 1945, 1, 0, 0, 0, 1957, + 1949, 1, 0, 0, 0, 1957, 1953, 1, 0, 0, 0, 1958, 313, 1, 0, 0, 0, 1959, + 1960, 3, 378, 189, 0, 1960, 315, 1, 0, 0, 0, 1961, 1962, 3, 352, 176, 0, + 1962, 317, 1, 0, 0, 0, 1963, 1964, 3, 378, 189, 0, 1964, 1965, 3, 622, + 311, 0, 1965, 1966, 3, 362, 181, 0, 1966, 1967, 3, 624, 312, 0, 1967, 319, + 1, 0, 0, 0, 1968, 1969, 3, 430, 215, 0, 1969, 1970, 5, 174, 0, 0, 1970, + 321, 1, 0, 0, 0, 1971, 1977, 3, 324, 162, 0, 1972, 1973, 3, 426, 213, 0, + 1973, 1974, 3, 324, 162, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1972, 1, 0, 0, + 0, 1976, 1979, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, + 0, 1978, 323, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1980, 2050, 3, 338, 169, + 0, 1981, 2050, 3, 340, 170, 0, 1982, 2050, 3, 336, 168, 0, 1983, 2050, + 3, 328, 164, 0, 1984, 2050, 3, 330, 165, 0, 1985, 2050, 3, 332, 166, 0, + 1986, 2050, 3, 334, 167, 0, 1987, 2050, 3, 350, 175, 0, 1988, 2050, 3, + 348, 174, 0, 1989, 2050, 3, 346, 173, 0, 1990, 1991, 5, 174, 0, 0, 1991, + 1992, 5, 10, 0, 0, 1992, 1993, 5, 174, 0, 0, 1993, 1994, 3, 296, 148, 0, + 1994, 1995, 3, 362, 181, 0, 1995, 2050, 1, 0, 0, 0, 1996, 1997, 5, 174, + 0, 0, 1997, 1998, 5, 10, 0, 0, 1998, 1999, 5, 174, 0, 0, 1999, 2000, 3, + 438, 219, 0, 2000, 2001, 3, 362, 181, 0, 2001, 2002, 3, 426, 213, 0, 2002, + 2003, 3, 362, 181, 0, 2003, 2050, 1, 0, 0, 0, 2004, 2005, 5, 1, 0, 0, 2005, + 2011, 5, 174, 0, 0, 2006, 2007, 3, 626, 313, 0, 2007, 2008, 5, 174, 0, + 0, 2008, 2010, 1, 0, 0, 0, 2009, 2006, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, + 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 1, 0, 0, + 0, 2013, 2011, 1, 0, 0, 0, 2014, 2015, 5, 2, 0, 0, 2015, 2016, 3, 488, + 244, 0, 2016, 2017, 5, 1, 0, 0, 2017, 2023, 3, 264, 132, 0, 2018, 2019, + 3, 626, 313, 0, 2019, 2020, 3, 264, 132, 0, 2020, 2022, 1, 0, 0, 0, 2021, + 2018, 1, 0, 0, 0, 2022, 2025, 1, 0, 0, 0, 2023, 2021, 1, 0, 0, 0, 2023, + 2024, 1, 0, 0, 0, 2024, 2026, 1, 0, 0, 0, 2025, 2023, 1, 0, 0, 0, 2026, + 2027, 5, 2, 0, 0, 2027, 2050, 1, 0, 0, 0, 2028, 2029, 5, 1, 0, 0, 2029, + 2035, 5, 174, 0, 0, 2030, 2031, 3, 626, 313, 0, 2031, 2032, 5, 174, 0, + 0, 2032, 2034, 1, 0, 0, 0, 2033, 2030, 1, 0, 0, 0, 2034, 2037, 1, 0, 0, + 0, 2035, 2033, 1, 0, 0, 0, 2035, 2036, 1, 0, 0, 0, 2036, 2038, 1, 0, 0, + 0, 2037, 2035, 1, 0, 0, 0, 2038, 2039, 5, 2, 0, 0, 2039, 2040, 3, 326, + 163, 0, 2040, 2046, 3, 264, 132, 0, 2041, 2042, 3, 626, 313, 0, 2042, 2043, + 3, 264, 132, 0, 2043, 2045, 1, 0, 0, 0, 2044, 2041, 1, 0, 0, 0, 2045, 2048, + 1, 0, 0, 0, 2046, 2044, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2050, + 1, 0, 0, 0, 2048, 2046, 1, 0, 0, 0, 2049, 1980, 1, 0, 0, 0, 2049, 1981, + 1, 0, 0, 0, 2049, 1982, 1, 0, 0, 0, 2049, 1983, 1, 0, 0, 0, 2049, 1984, + 1, 0, 0, 0, 2049, 1985, 1, 0, 0, 0, 2049, 1986, 1, 0, 0, 0, 2049, 1987, + 1, 0, 0, 0, 2049, 1988, 1, 0, 0, 0, 2049, 1989, 1, 0, 0, 0, 2049, 1990, + 1, 0, 0, 0, 2049, 1996, 1, 0, 0, 0, 2049, 2004, 1, 0, 0, 0, 2049, 2028, + 1, 0, 0, 0, 2050, 325, 1, 0, 0, 0, 2051, 2052, 7, 2, 0, 0, 2052, 327, 1, + 0, 0, 0, 2053, 2054, 3, 352, 176, 0, 2054, 2055, 3, 326, 163, 0, 2055, + 2056, 3, 362, 181, 0, 2056, 329, 1, 0, 0, 0, 2057, 2058, 3, 352, 176, 0, + 2058, 2059, 3, 326, 163, 0, 2059, 2060, 3, 352, 176, 0, 2060, 331, 1, 0, + 0, 0, 2061, 2062, 3, 378, 189, 0, 2062, 2063, 3, 326, 163, 0, 2063, 2064, + 3, 352, 176, 0, 2064, 333, 1, 0, 0, 0, 2065, 2066, 3, 352, 176, 0, 2066, + 2067, 3, 326, 163, 0, 2067, 2068, 3, 378, 189, 0, 2068, 335, 1, 0, 0, 0, + 2069, 2070, 3, 378, 189, 0, 2070, 2071, 3, 438, 219, 0, 2071, 2072, 3, + 360, 180, 0, 2072, 2073, 3, 426, 213, 0, 2073, 2074, 3, 360, 180, 0, 2074, + 337, 1, 0, 0, 0, 2075, 2076, 3, 378, 189, 0, 2076, 2077, 3, 326, 163, 0, + 2077, 2078, 3, 362, 181, 0, 2078, 339, 1, 0, 0, 0, 2079, 2080, 3, 378, + 189, 0, 2080, 2081, 3, 296, 148, 0, 2081, 2082, 3, 362, 181, 0, 2082, 341, + 1, 0, 0, 0, 2083, 2084, 7, 3, 0, 0, 2084, 343, 1, 0, 0, 0, 2085, 2091, + 3, 342, 171, 0, 2086, 2087, 5, 1, 0, 0, 2087, 2088, 3, 356, 178, 0, 2088, + 2089, 5, 2, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2085, 1, 0, 0, 0, 2090, + 2086, 1, 0, 0, 0, 2091, 345, 1, 0, 0, 0, 2092, 2093, 3, 378, 189, 0, 2093, + 2094, 3, 488, 244, 0, 2094, 2095, 3, 344, 172, 0, 2095, 347, 1, 0, 0, 0, + 2096, 2097, 3, 378, 189, 0, 2097, 2098, 3, 450, 225, 0, 2098, 2099, 3, + 362, 181, 0, 2099, 349, 1, 0, 0, 0, 2100, 2101, 3, 378, 189, 0, 2101, 2102, + 3, 450, 225, 0, 2102, 2103, 3, 504, 252, 0, 2103, 2104, 1, 0, 0, 0, 2104, + 2105, 3, 362, 181, 0, 2105, 351, 1, 0, 0, 0, 2106, 2107, 3, 354, 177, 0, + 2107, 2109, 5, 1, 0, 0, 2108, 2110, 3, 356, 178, 0, 2109, 2108, 1, 0, 0, + 0, 2109, 2110, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2112, 5, 2, 0, + 0, 2112, 353, 1, 0, 0, 0, 2113, 2114, 7, 4, 0, 0, 2114, 355, 1, 0, 0, 0, + 2115, 2121, 3, 358, 179, 0, 2116, 2117, 3, 626, 313, 0, 2117, 2118, 3, + 358, 179, 0, 2118, 2120, 1, 0, 0, 0, 2119, 2116, 1, 0, 0, 0, 2120, 2123, + 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 357, + 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2124, 2128, 3, 360, 180, 0, 2125, 2128, + 3, 378, 189, 0, 2126, 2128, 5, 11, 0, 0, 2127, 2124, 1, 0, 0, 0, 2127, + 2125, 1, 0, 0, 0, 2127, 2126, 1, 0, 0, 0, 2128, 359, 1, 0, 0, 0, 2129, + 2137, 3, 342, 171, 0, 2130, 2137, 3, 362, 181, 0, 2131, 2137, 3, 352, 176, + 0, 2132, 2137, 3, 258, 129, 0, 2133, 2137, 3, 256, 128, 0, 2134, 2137, + 3, 260, 130, 0, 2135, 2137, 3, 264, 132, 0, 2136, 2129, 1, 0, 0, 0, 2136, + 2130, 1, 0, 0, 0, 2136, 2131, 1, 0, 0, 0, 2136, 2132, 1, 0, 0, 0, 2136, + 2133, 1, 0, 0, 0, 2136, 2134, 1, 0, 0, 0, 2136, 2135, 1, 0, 0, 0, 2137, + 361, 1, 0, 0, 0, 2138, 2148, 3, 342, 171, 0, 2139, 2148, 3, 532, 266, 0, + 2140, 2148, 5, 175, 0, 0, 2141, 2148, 3, 368, 184, 0, 2142, 2148, 3, 364, + 182, 0, 2143, 2148, 3, 366, 183, 0, 2144, 2148, 3, 372, 186, 0, 2145, 2148, + 3, 370, 185, 0, 2146, 2148, 3, 58, 29, 0, 2147, 2138, 1, 0, 0, 0, 2147, + 2139, 1, 0, 0, 0, 2147, 2140, 1, 0, 0, 0, 2147, 2141, 1, 0, 0, 0, 2147, + 2142, 1, 0, 0, 0, 2147, 2143, 1, 0, 0, 0, 2147, 2144, 1, 0, 0, 0, 2147, + 2145, 1, 0, 0, 0, 2147, 2146, 1, 0, 0, 0, 2148, 363, 1, 0, 0, 0, 2149, + 2150, 5, 170, 0, 0, 2150, 365, 1, 0, 0, 0, 2151, 2152, 7, 5, 0, 0, 2152, + 367, 1, 0, 0, 0, 2153, 2154, 5, 169, 0, 0, 2154, 369, 1, 0, 0, 0, 2155, + 2156, 7, 6, 0, 0, 2156, 371, 1, 0, 0, 0, 2157, 2158, 5, 172, 0, 0, 2158, + 373, 1, 0, 0, 0, 2159, 2164, 5, 174, 0, 0, 2160, 2161, 5, 17, 0, 0, 2161, + 2162, 5, 174, 0, 0, 2162, 2164, 5, 17, 0, 0, 2163, 2159, 1, 0, 0, 0, 2163, + 2160, 1, 0, 0, 0, 2164, 375, 1, 0, 0, 0, 2165, 2173, 5, 174, 0, 0, 2166, + 2173, 5, 79, 0, 0, 2167, 2173, 5, 125, 0, 0, 2168, 2173, 5, 63, 0, 0, 2169, + 2170, 5, 17, 0, 0, 2170, 2171, 5, 174, 0, 0, 2171, 2173, 5, 17, 0, 0, 2172, + 2165, 1, 0, 0, 0, 2172, 2166, 1, 0, 0, 0, 2172, 2167, 1, 0, 0, 0, 2172, + 2168, 1, 0, 0, 0, 2172, 2169, 1, 0, 0, 0, 2173, 377, 1, 0, 0, 0, 2174, + 2181, 5, 174, 0, 0, 2175, 2181, 3, 586, 293, 0, 2176, 2181, 5, 76, 0, 0, + 2177, 2178, 5, 17, 0, 0, 2178, 2179, 5, 174, 0, 0, 2179, 2181, 5, 17, 0, + 0, 2180, 2174, 1, 0, 0, 0, 2180, 2175, 1, 0, 0, 0, 2180, 2176, 1, 0, 0, + 0, 2180, 2177, 1, 0, 0, 0, 2181, 379, 1, 0, 0, 0, 2182, 2184, 3, 382, 191, + 0, 2183, 2185, 3, 384, 192, 0, 2184, 2183, 1, 0, 0, 0, 2184, 2185, 1, 0, + 0, 0, 2185, 381, 1, 0, 0, 0, 2186, 2187, 7, 7, 0, 0, 2187, 383, 1, 0, 0, + 0, 2188, 2189, 3, 618, 309, 0, 2189, 2195, 3, 380, 190, 0, 2190, 2191, + 3, 626, 313, 0, 2191, 2192, 3, 380, 190, 0, 2192, 2194, 1, 0, 0, 0, 2193, + 2190, 1, 0, 0, 0, 2194, 2197, 1, 0, 0, 0, 2195, 2193, 1, 0, 0, 0, 2195, + 2196, 1, 0, 0, 0, 2196, 2198, 1, 0, 0, 0, 2197, 2195, 1, 0, 0, 0, 2198, + 2199, 3, 620, 310, 0, 2199, 385, 1, 0, 0, 0, 2200, 2203, 3, 432, 216, 0, + 2201, 2203, 3, 456, 228, 0, 2202, 2200, 1, 0, 0, 0, 2202, 2201, 1, 0, 0, + 0, 2203, 387, 1, 0, 0, 0, 2204, 2205, 5, 174, 0, 0, 2205, 389, 1, 0, 0, + 0, 2206, 2207, 5, 174, 0, 0, 2207, 391, 1, 0, 0, 0, 2208, 2209, 3, 368, + 184, 0, 2209, 393, 1, 0, 0, 0, 2210, 2211, 5, 174, 0, 0, 2211, 395, 1, + 0, 0, 0, 2212, 2213, 5, 174, 0, 0, 2213, 397, 1, 0, 0, 0, 2214, 2215, 5, + 174, 0, 0, 2215, 399, 1, 0, 0, 0, 2216, 2217, 5, 174, 0, 0, 2217, 401, + 1, 0, 0, 0, 2218, 2219, 5, 174, 0, 0, 2219, 403, 1, 0, 0, 0, 2220, 2221, + 5, 174, 0, 0, 2221, 405, 1, 0, 0, 0, 2222, 2223, 3, 368, 184, 0, 2223, + 407, 1, 0, 0, 0, 2224, 2225, 5, 174, 0, 0, 2225, 409, 1, 0, 0, 0, 2226, + 2227, 3, 412, 206, 0, 2227, 2228, 3, 380, 190, 0, 2228, 411, 1, 0, 0, 0, + 2229, 2230, 7, 8, 0, 0, 2230, 413, 1, 0, 0, 0, 2231, 2232, 5, 24, 0, 0, + 2232, 415, 1, 0, 0, 0, 2233, 2234, 5, 25, 0, 0, 2234, 417, 1, 0, 0, 0, + 2235, 2236, 5, 26, 0, 0, 2236, 419, 1, 0, 0, 0, 2237, 2238, 5, 26, 0, 0, + 2238, 2239, 5, 106, 0, 0, 2239, 421, 1, 0, 0, 0, 2240, 2241, 5, 27, 0, + 0, 2241, 423, 1, 0, 0, 0, 2242, 2243, 5, 28, 0, 0, 2243, 425, 1, 0, 0, + 0, 2244, 2245, 5, 29, 0, 0, 2245, 427, 1, 0, 0, 0, 2246, 2247, 5, 31, 0, + 0, 2247, 429, 1, 0, 0, 0, 2248, 2249, 5, 32, 0, 0, 2249, 431, 1, 0, 0, + 0, 2250, 2251, 5, 33, 0, 0, 2251, 433, 1, 0, 0, 0, 2252, 2253, 5, 34, 0, + 0, 2253, 435, 1, 0, 0, 0, 2254, 2255, 5, 35, 0, 0, 2255, 437, 1, 0, 0, + 0, 2256, 2257, 5, 37, 0, 0, 2257, 439, 1, 0, 0, 0, 2258, 2259, 5, 36, 0, + 0, 2259, 441, 1, 0, 0, 0, 2260, 2261, 5, 38, 0, 0, 2261, 443, 1, 0, 0, + 0, 2262, 2263, 5, 39, 0, 0, 2263, 445, 1, 0, 0, 0, 2264, 2265, 5, 40, 0, + 0, 2265, 447, 1, 0, 0, 0, 2266, 2267, 5, 42, 0, 0, 2267, 449, 1, 0, 0, + 0, 2268, 2269, 5, 44, 0, 0, 2269, 451, 1, 0, 0, 0, 2270, 2271, 5, 45, 0, + 0, 2271, 453, 1, 0, 0, 0, 2272, 2273, 5, 47, 0, 0, 2273, 455, 1, 0, 0, + 0, 2274, 2275, 5, 48, 0, 0, 2275, 457, 1, 0, 0, 0, 2276, 2277, 5, 49, 0, + 0, 2277, 459, 1, 0, 0, 0, 2278, 2279, 5, 50, 0, 0, 2279, 461, 1, 0, 0, + 0, 2280, 2281, 5, 51, 0, 0, 2281, 463, 1, 0, 0, 0, 2282, 2283, 5, 52, 0, + 0, 2283, 465, 1, 0, 0, 0, 2284, 2285, 5, 54, 0, 0, 2285, 467, 1, 0, 0, + 0, 2286, 2287, 5, 55, 0, 0, 2287, 469, 1, 0, 0, 0, 2288, 2289, 5, 56, 0, + 0, 2289, 471, 1, 0, 0, 0, 2290, 2291, 5, 58, 0, 0, 2291, 473, 1, 0, 0, + 0, 2292, 2293, 5, 59, 0, 0, 2293, 475, 1, 0, 0, 0, 2294, 2295, 5, 60, 0, + 0, 2295, 477, 1, 0, 0, 0, 2296, 2297, 5, 61, 0, 0, 2297, 479, 1, 0, 0, + 0, 2298, 2299, 5, 62, 0, 0, 2299, 481, 1, 0, 0, 0, 2300, 2301, 5, 63, 0, + 0, 2301, 483, 1, 0, 0, 0, 2302, 2303, 5, 64, 0, 0, 2303, 485, 1, 0, 0, + 0, 2304, 2305, 5, 66, 0, 0, 2305, 487, 1, 0, 0, 0, 2306, 2307, 5, 67, 0, + 0, 2307, 489, 1, 0, 0, 0, 2308, 2309, 5, 68, 0, 0, 2309, 491, 1, 0, 0, + 0, 2310, 2311, 5, 70, 0, 0, 2311, 493, 1, 0, 0, 0, 2312, 2313, 5, 71, 0, + 0, 2313, 495, 1, 0, 0, 0, 2314, 2315, 5, 72, 0, 0, 2315, 497, 1, 0, 0, + 0, 2316, 2317, 5, 73, 0, 0, 2317, 499, 1, 0, 0, 0, 2318, 2319, 5, 74, 0, + 0, 2319, 501, 1, 0, 0, 0, 2320, 2321, 5, 75, 0, 0, 2321, 503, 1, 0, 0, + 0, 2322, 2323, 5, 76, 0, 0, 2323, 505, 1, 0, 0, 0, 2324, 2325, 5, 77, 0, + 0, 2325, 507, 1, 0, 0, 0, 2326, 2327, 5, 78, 0, 0, 2327, 509, 1, 0, 0, + 0, 2328, 2329, 5, 79, 0, 0, 2329, 511, 1, 0, 0, 0, 2330, 2331, 5, 80, 0, + 0, 2331, 513, 1, 0, 0, 0, 2332, 2333, 5, 82, 0, 0, 2333, 515, 1, 0, 0, + 0, 2334, 2335, 5, 84, 0, 0, 2335, 517, 1, 0, 0, 0, 2336, 2337, 5, 87, 0, + 0, 2337, 519, 1, 0, 0, 0, 2338, 2339, 5, 88, 0, 0, 2339, 521, 1, 0, 0, + 0, 2340, 2341, 5, 89, 0, 0, 2341, 523, 1, 0, 0, 0, 2342, 2343, 5, 90, 0, + 0, 2343, 525, 1, 0, 0, 0, 2344, 2345, 5, 93, 0, 0, 2345, 527, 1, 0, 0, + 0, 2346, 2347, 5, 92, 0, 0, 2347, 529, 1, 0, 0, 0, 2348, 2349, 5, 94, 0, + 0, 2349, 531, 1, 0, 0, 0, 2350, 2351, 5, 95, 0, 0, 2351, 533, 1, 0, 0, + 0, 2352, 2353, 5, 96, 0, 0, 2353, 535, 1, 0, 0, 0, 2354, 2355, 5, 97, 0, + 0, 2355, 537, 1, 0, 0, 0, 2356, 2357, 5, 99, 0, 0, 2357, 539, 1, 0, 0, + 0, 2358, 2359, 5, 100, 0, 0, 2359, 541, 1, 0, 0, 0, 2360, 2361, 5, 101, + 0, 0, 2361, 543, 1, 0, 0, 0, 2362, 2363, 5, 103, 0, 0, 2363, 545, 1, 0, + 0, 0, 2364, 2365, 5, 107, 0, 0, 2365, 547, 1, 0, 0, 0, 2366, 2367, 5, 109, + 0, 0, 2367, 549, 1, 0, 0, 0, 2368, 2369, 5, 110, 0, 0, 2369, 551, 1, 0, + 0, 0, 2370, 2371, 5, 111, 0, 0, 2371, 553, 1, 0, 0, 0, 2372, 2373, 5, 112, + 0, 0, 2373, 555, 1, 0, 0, 0, 2374, 2375, 5, 114, 0, 0, 2375, 557, 1, 0, + 0, 0, 2376, 2377, 5, 115, 0, 0, 2377, 559, 1, 0, 0, 0, 2378, 2379, 5, 117, + 0, 0, 2379, 561, 1, 0, 0, 0, 2380, 2381, 5, 118, 0, 0, 2381, 563, 1, 0, + 0, 0, 2382, 2383, 5, 119, 0, 0, 2383, 565, 1, 0, 0, 0, 2384, 2385, 5, 121, + 0, 0, 2385, 567, 1, 0, 0, 0, 2386, 2387, 5, 122, 0, 0, 2387, 569, 1, 0, + 0, 0, 2388, 2389, 5, 123, 0, 0, 2389, 571, 1, 0, 0, 0, 2390, 2391, 5, 124, + 0, 0, 2391, 573, 1, 0, 0, 0, 2392, 2393, 5, 125, 0, 0, 2393, 575, 1, 0, + 0, 0, 2394, 2395, 5, 127, 0, 0, 2395, 577, 1, 0, 0, 0, 2396, 2397, 5, 128, + 0, 0, 2397, 579, 1, 0, 0, 0, 2398, 2399, 5, 130, 0, 0, 2399, 581, 1, 0, + 0, 0, 2400, 2401, 5, 132, 0, 0, 2401, 583, 1, 0, 0, 0, 2402, 2403, 5, 133, + 0, 0, 2403, 585, 1, 0, 0, 0, 2404, 2405, 5, 135, 0, 0, 2405, 587, 1, 0, + 0, 0, 2406, 2407, 5, 136, 0, 0, 2407, 589, 1, 0, 0, 0, 2408, 2409, 5, 137, + 0, 0, 2409, 591, 1, 0, 0, 0, 2410, 2411, 5, 138, 0, 0, 2411, 593, 1, 0, + 0, 0, 2412, 2413, 5, 139, 0, 0, 2413, 595, 1, 0, 0, 0, 2414, 2415, 5, 140, + 0, 0, 2415, 597, 1, 0, 0, 0, 2416, 2417, 5, 142, 0, 0, 2417, 599, 1, 0, + 0, 0, 2418, 2419, 5, 143, 0, 0, 2419, 601, 1, 0, 0, 0, 2420, 2421, 5, 144, + 0, 0, 2421, 603, 1, 0, 0, 0, 2422, 2423, 5, 145, 0, 0, 2423, 605, 1, 0, + 0, 0, 2424, 2425, 5, 113, 0, 0, 2425, 607, 1, 0, 0, 0, 2426, 2427, 5, 65, + 0, 0, 2427, 609, 1, 0, 0, 0, 2428, 2429, 5, 1, 0, 0, 2429, 611, 1, 0, 0, + 0, 2430, 2431, 5, 2, 0, 0, 2431, 613, 1, 0, 0, 0, 2432, 2433, 5, 3, 0, + 0, 2433, 615, 1, 0, 0, 0, 2434, 2435, 5, 4, 0, 0, 2435, 617, 1, 0, 0, 0, + 2436, 2437, 5, 20, 0, 0, 2437, 619, 1, 0, 0, 0, 2438, 2439, 5, 21, 0, 0, + 2439, 621, 1, 0, 0, 0, 2440, 2441, 5, 5, 0, 0, 2441, 623, 1, 0, 0, 0, 2442, + 2443, 5, 6, 0, 0, 2443, 625, 1, 0, 0, 0, 2444, 2445, 5, 7, 0, 0, 2445, + 627, 1, 0, 0, 0, 2446, 2447, 5, 9, 0, 0, 2447, 629, 1, 0, 0, 0, 2448, 2449, + 3, 608, 304, 0, 2449, 2450, 3, 442, 221, 0, 2450, 2456, 3, 632, 316, 0, + 2451, 2452, 3, 626, 313, 0, 2452, 2453, 3, 632, 316, 0, 2453, 2455, 1, + 0, 0, 0, 2454, 2451, 1, 0, 0, 0, 2455, 2458, 1, 0, 0, 0, 2456, 2454, 1, + 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 631, 1, 0, 0, 0, 2458, 2456, 1, + 0, 0, 0, 2459, 2460, 5, 174, 0, 0, 2460, 633, 1, 0, 0, 0, 180, 637, 640, + 646, 651, 653, 658, 661, 664, 708, 712, 720, 727, 732, 748, 751, 758, 763, + 774, 784, 799, 810, 819, 824, 832, 837, 841, 846, 851, 866, 872, 877, 887, + 892, 909, 916, 924, 938, 943, 955, 959, 963, 968, 973, 992, 999, 1007, + 1011, 1016, 1035, 1044, 1059, 1061, 1073, 1087, 1094, 1101, 1109, 1120, + 1136, 1155, 1178, 1190, 1206, 1216, 1225, 1244, 1252, 1258, 1263, 1270, + 1275, 1283, 1288, 1295, 1300, 1307, 1312, 1319, 1328, 1335, 1342, 1349, + 1354, 1361, 1368, 1372, 1375, 1383, 1393, 1404, 1410, 1419, 1432, 1440, + 1446, 1451, 1465, 1485, 1494, 1506, 1510, 1514, 1528, 1536, 1545, 1556, + 1563, 1566, 1576, 1582, 1600, 1604, 1608, 1613, 1616, 1624, 1629, 1633, + 1635, 1638, 1643, 1650, 1653, 1664, 1677, 1684, 1718, 1721, 1737, 1749, + 1752, 1765, 1771, 1777, 1781, 1784, 1787, 1805, 1810, 1833, 1845, 1854, + 1863, 1867, 1870, 1875, 1878, 1881, 1884, 1887, 1890, 1898, 1905, 1920, + 1926, 1935, 1942, 1947, 1951, 1955, 1957, 1977, 2011, 2023, 2035, 2046, + 2049, 2090, 2109, 2121, 2127, 2136, 2147, 2163, 2172, 2180, 2184, 2195, + 2202, 2456, } deserializer := antlr.NewATNDeserializer(nil) staticData.atn = deserializer.Deserialize(staticData.serializedATN) @@ -1685,153 +1686,157 @@ const ( CqlParserRULE_compareOperator = 163 CqlParserRULE_relationFunctionCompareConstant = 164 CqlParserRULE_relationFunctionCompareFunction = 165 - CqlParserRULE_relationBetween = 166 - CqlParserRULE_relationCompare = 167 - CqlParserRULE_relationLike = 168 - CqlParserRULE_marker = 169 - CqlParserRULE_tupleValue = 170 - CqlParserRULE_relationIn = 171 - CqlParserRULE_relationContains = 172 - CqlParserRULE_relationContainsKey = 173 - CqlParserRULE_functionCall = 174 - CqlParserRULE_functionArgs = 175 - CqlParserRULE_valueAny = 176 - CqlParserRULE_constant = 177 - CqlParserRULE_decimalLiteral = 178 - CqlParserRULE_floatLiteral = 179 - CqlParserRULE_stringLiteral = 180 - CqlParserRULE_booleanLiteral = 181 - CqlParserRULE_hexadecimalLiteral = 182 - CqlParserRULE_keyspace = 183 - CqlParserRULE_table = 184 - CqlParserRULE_column = 185 - CqlParserRULE_dataType = 186 - CqlParserRULE_dataTypeName = 187 - CqlParserRULE_dataTypeDefinition = 188 - CqlParserRULE_orderDirection = 189 - CqlParserRULE_role = 190 - CqlParserRULE_trigger = 191 - CqlParserRULE_triggerClass = 192 - CqlParserRULE_materializedView = 193 - CqlParserRULE_type_ = 194 - CqlParserRULE_aggregate = 195 - CqlParserRULE_function_ = 196 - CqlParserRULE_language = 197 - CqlParserRULE_user = 198 - CqlParserRULE_password = 199 - CqlParserRULE_hashKey = 200 - CqlParserRULE_param = 201 - CqlParserRULE_paramName = 202 - CqlParserRULE_kwAdd = 203 - CqlParserRULE_kwAggregate = 204 - CqlParserRULE_kwAll = 205 - CqlParserRULE_kwAllPermissions = 206 - CqlParserRULE_kwAllow = 207 - CqlParserRULE_kwAlter = 208 - CqlParserRULE_kwAnd = 209 - CqlParserRULE_kwApply = 210 - CqlParserRULE_kwAs = 211 - CqlParserRULE_kwAsc = 212 - CqlParserRULE_kwAuthorize = 213 - CqlParserRULE_kwBatch = 214 - CqlParserRULE_kwBetween = 215 - CqlParserRULE_kwBegin = 216 - CqlParserRULE_kwBy = 217 - CqlParserRULE_kwCalled = 218 - CqlParserRULE_kwClustering = 219 - CqlParserRULE_kwCompact = 220 - CqlParserRULE_kwContains = 221 - CqlParserRULE_kwCreate = 222 - CqlParserRULE_kwDelete = 223 - CqlParserRULE_kwDesc = 224 - CqlParserRULE_kwDescibe = 225 - CqlParserRULE_kwDistinct = 226 - CqlParserRULE_kwDrop = 227 - CqlParserRULE_kwDurableWrites = 228 - CqlParserRULE_kwEntries = 229 - CqlParserRULE_kwExecute = 230 - CqlParserRULE_kwExists = 231 - CqlParserRULE_kwFiltering = 232 - CqlParserRULE_kwFinalfunc = 233 - CqlParserRULE_kwFrom = 234 - CqlParserRULE_kwFull = 235 - CqlParserRULE_kwFunction = 236 - CqlParserRULE_kwFunctions = 237 - CqlParserRULE_kwGrant = 238 - CqlParserRULE_kwIf = 239 - CqlParserRULE_kwIn = 240 - CqlParserRULE_kwIndex = 241 - CqlParserRULE_kwInitcond = 242 - CqlParserRULE_kwInput = 243 - CqlParserRULE_kwInsert = 244 - CqlParserRULE_kwInto = 245 - CqlParserRULE_kwIs = 246 - CqlParserRULE_kwJson = 247 - CqlParserRULE_kwKey = 248 - CqlParserRULE_kwKeys = 249 - CqlParserRULE_kwKeyspace = 250 - CqlParserRULE_kwKeyspaces = 251 - CqlParserRULE_kwLanguage = 252 - CqlParserRULE_kwLimit = 253 - CqlParserRULE_kwList = 254 - CqlParserRULE_kwLogged = 255 - CqlParserRULE_kwLogin = 256 - CqlParserRULE_kwMaterialized = 257 - CqlParserRULE_kwModify = 258 - CqlParserRULE_kwNosuperuser = 259 - CqlParserRULE_kwNorecursive = 260 - CqlParserRULE_kwNot = 261 - CqlParserRULE_kwNull = 262 - CqlParserRULE_kwOf = 263 - CqlParserRULE_kwOn = 264 - CqlParserRULE_kwOptions = 265 - CqlParserRULE_kwOr = 266 - CqlParserRULE_kwOrder = 267 - CqlParserRULE_kwPassword = 268 - CqlParserRULE_kwPrimary = 269 - CqlParserRULE_kwRename = 270 - CqlParserRULE_kwReplace = 271 - CqlParserRULE_kwReplication = 272 - CqlParserRULE_kwReturns = 273 - CqlParserRULE_kwRole = 274 - CqlParserRULE_kwRoles = 275 - CqlParserRULE_kwSelect = 276 - CqlParserRULE_kwSet = 277 - CqlParserRULE_kwSfunc = 278 - CqlParserRULE_kwStorage = 279 - CqlParserRULE_kwStype = 280 - CqlParserRULE_kwSuperuser = 281 - CqlParserRULE_kwTable = 282 - CqlParserRULE_kwTables = 283 - CqlParserRULE_kwTimestamp = 284 - CqlParserRULE_kwTo = 285 - CqlParserRULE_kwTrigger = 286 - CqlParserRULE_kwTruncate = 287 - CqlParserRULE_kwTtl = 288 - CqlParserRULE_kwType = 289 - CqlParserRULE_kwUnlogged = 290 - CqlParserRULE_kwUpdate = 291 - CqlParserRULE_kwUse = 292 - CqlParserRULE_kwUser = 293 - CqlParserRULE_kwUsing = 294 - CqlParserRULE_kwValues = 295 - CqlParserRULE_kwView = 296 - CqlParserRULE_kwWhere = 297 - CqlParserRULE_kwWith = 298 - CqlParserRULE_kwRevoke = 299 - CqlParserRULE_kwGroup = 300 - CqlParserRULE_syntaxBracketLr = 301 - CqlParserRULE_syntaxBracketRr = 302 - CqlParserRULE_syntaxBracketLc = 303 - CqlParserRULE_syntaxBracketRc = 304 - CqlParserRULE_syntaxBracketLa = 305 - CqlParserRULE_syntaxBracketRa = 306 - CqlParserRULE_syntaxBracketLs = 307 - CqlParserRULE_syntaxBracketRs = 308 - CqlParserRULE_syntaxComma = 309 - CqlParserRULE_syntaxColon = 310 - CqlParserRULE_groupSpec = 311 - CqlParserRULE_groupSpecElement = 312 + CqlParserRULE_relationColumnCompareFunction = 166 + CqlParserRULE_relationFunctionCompareColumn = 167 + CqlParserRULE_relationBetween = 168 + CqlParserRULE_relationCompare = 169 + CqlParserRULE_relationLike = 170 + CqlParserRULE_marker = 171 + CqlParserRULE_tupleValue = 172 + CqlParserRULE_relationIn = 173 + CqlParserRULE_relationContains = 174 + CqlParserRULE_relationContainsKey = 175 + CqlParserRULE_functionCall = 176 + CqlParserRULE_functionName = 177 + CqlParserRULE_functionArgs = 178 + CqlParserRULE_functionArg = 179 + CqlParserRULE_valueAny = 180 + CqlParserRULE_constant = 181 + CqlParserRULE_decimalLiteral = 182 + CqlParserRULE_floatLiteral = 183 + CqlParserRULE_stringLiteral = 184 + CqlParserRULE_booleanLiteral = 185 + CqlParserRULE_hexadecimalLiteral = 186 + CqlParserRULE_keyspace = 187 + CqlParserRULE_table = 188 + CqlParserRULE_column = 189 + CqlParserRULE_dataType = 190 + CqlParserRULE_dataTypeName = 191 + CqlParserRULE_dataTypeDefinition = 192 + CqlParserRULE_orderDirection = 193 + CqlParserRULE_role = 194 + CqlParserRULE_trigger = 195 + CqlParserRULE_triggerClass = 196 + CqlParserRULE_materializedView = 197 + CqlParserRULE_type_ = 198 + CqlParserRULE_aggregate = 199 + CqlParserRULE_function_ = 200 + CqlParserRULE_language = 201 + CqlParserRULE_user = 202 + CqlParserRULE_password = 203 + CqlParserRULE_hashKey = 204 + CqlParserRULE_param = 205 + CqlParserRULE_paramName = 206 + CqlParserRULE_kwAdd = 207 + CqlParserRULE_kwAggregate = 208 + CqlParserRULE_kwAll = 209 + CqlParserRULE_kwAllPermissions = 210 + CqlParserRULE_kwAllow = 211 + CqlParserRULE_kwAlter = 212 + CqlParserRULE_kwAnd = 213 + CqlParserRULE_kwApply = 214 + CqlParserRULE_kwAs = 215 + CqlParserRULE_kwAsc = 216 + CqlParserRULE_kwAuthorize = 217 + CqlParserRULE_kwBatch = 218 + CqlParserRULE_kwBetween = 219 + CqlParserRULE_kwBegin = 220 + CqlParserRULE_kwBy = 221 + CqlParserRULE_kwCalled = 222 + CqlParserRULE_kwClustering = 223 + CqlParserRULE_kwCompact = 224 + CqlParserRULE_kwContains = 225 + CqlParserRULE_kwCreate = 226 + CqlParserRULE_kwDelete = 227 + CqlParserRULE_kwDesc = 228 + CqlParserRULE_kwDescibe = 229 + CqlParserRULE_kwDistinct = 230 + CqlParserRULE_kwDrop = 231 + CqlParserRULE_kwDurableWrites = 232 + CqlParserRULE_kwEntries = 233 + CqlParserRULE_kwExecute = 234 + CqlParserRULE_kwExists = 235 + CqlParserRULE_kwFiltering = 236 + CqlParserRULE_kwFinalfunc = 237 + CqlParserRULE_kwFrom = 238 + CqlParserRULE_kwFull = 239 + CqlParserRULE_kwFunction = 240 + CqlParserRULE_kwFunctions = 241 + CqlParserRULE_kwGrant = 242 + CqlParserRULE_kwIf = 243 + CqlParserRULE_kwIn = 244 + CqlParserRULE_kwIndex = 245 + CqlParserRULE_kwInitcond = 246 + CqlParserRULE_kwInput = 247 + CqlParserRULE_kwInsert = 248 + CqlParserRULE_kwInto = 249 + CqlParserRULE_kwIs = 250 + CqlParserRULE_kwJson = 251 + CqlParserRULE_kwKey = 252 + CqlParserRULE_kwKeys = 253 + CqlParserRULE_kwKeyspace = 254 + CqlParserRULE_kwKeyspaces = 255 + CqlParserRULE_kwLanguage = 256 + CqlParserRULE_kwLimit = 257 + CqlParserRULE_kwList = 258 + CqlParserRULE_kwLogged = 259 + CqlParserRULE_kwLogin = 260 + CqlParserRULE_kwMaterialized = 261 + CqlParserRULE_kwModify = 262 + CqlParserRULE_kwNosuperuser = 263 + CqlParserRULE_kwNorecursive = 264 + CqlParserRULE_kwNot = 265 + CqlParserRULE_kwNull = 266 + CqlParserRULE_kwOf = 267 + CqlParserRULE_kwOn = 268 + CqlParserRULE_kwOptions = 269 + CqlParserRULE_kwOr = 270 + CqlParserRULE_kwOrder = 271 + CqlParserRULE_kwPassword = 272 + CqlParserRULE_kwPrimary = 273 + CqlParserRULE_kwRename = 274 + CqlParserRULE_kwReplace = 275 + CqlParserRULE_kwReplication = 276 + CqlParserRULE_kwReturns = 277 + CqlParserRULE_kwRole = 278 + CqlParserRULE_kwRoles = 279 + CqlParserRULE_kwSelect = 280 + CqlParserRULE_kwSet = 281 + CqlParserRULE_kwSfunc = 282 + CqlParserRULE_kwStorage = 283 + CqlParserRULE_kwStype = 284 + CqlParserRULE_kwSuperuser = 285 + CqlParserRULE_kwTable = 286 + CqlParserRULE_kwTables = 287 + CqlParserRULE_kwTimestamp = 288 + CqlParserRULE_kwTo = 289 + CqlParserRULE_kwTrigger = 290 + CqlParserRULE_kwTruncate = 291 + CqlParserRULE_kwTtl = 292 + CqlParserRULE_kwType = 293 + CqlParserRULE_kwUnlogged = 294 + CqlParserRULE_kwUpdate = 295 + CqlParserRULE_kwUse = 296 + CqlParserRULE_kwUser = 297 + CqlParserRULE_kwUsing = 298 + CqlParserRULE_kwValues = 299 + CqlParserRULE_kwView = 300 + CqlParserRULE_kwWhere = 301 + CqlParserRULE_kwWith = 302 + CqlParserRULE_kwRevoke = 303 + CqlParserRULE_kwGroup = 304 + CqlParserRULE_syntaxBracketLr = 305 + CqlParserRULE_syntaxBracketRr = 306 + CqlParserRULE_syntaxBracketLc = 307 + CqlParserRULE_syntaxBracketRc = 308 + CqlParserRULE_syntaxBracketLa = 309 + CqlParserRULE_syntaxBracketRa = 310 + CqlParserRULE_syntaxBracketLs = 311 + CqlParserRULE_syntaxBracketRs = 312 + CqlParserRULE_syntaxComma = 313 + CqlParserRULE_syntaxColon = 314 + CqlParserRULE_groupSpec = 315 + CqlParserRULE_groupSpecElement = 316 ) // IRootContext is an interface to support dynamic dispatch. @@ -1958,7 +1963,7 @@ func (p *CqlParser) Root() (localctx IRootContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(627) + p.SetState(635) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -1967,18 +1972,18 @@ func (p *CqlParser) Root() (localctx IRootContext) { for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3272217739657472) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&9570149209211137) != 0) || ((int64((_la-132)) & ^0x3f) == 0 && ((int64(1)<<(_la-132))&97) != 0) { { - p.SetState(626) + p.SetState(634) p.Cqls() } - p.SetState(629) + p.SetState(637) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } _la = p.GetTokenStream().LA(1) } - p.SetState(632) + p.SetState(640) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -1987,7 +1992,7 @@ func (p *CqlParser) Root() (localctx IRootContext) { if _la == CqlParserMINUSMINUS { { - p.SetState(631) + p.SetState(639) p.Match(CqlParserMINUSMINUS) if p.HasError() { // Recognition error - abort rule @@ -1997,7 +2002,7 @@ func (p *CqlParser) Root() (localctx IRootContext) { } { - p.SetState(634) + p.SetState(642) p.Match(CqlParserEOF) if p.HasError() { // Recognition error - abort rule @@ -2230,7 +2235,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { var _alt int p.EnterOuterAlt(localctx, 1) - p.SetState(645) + p.SetState(653) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2241,7 +2246,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { } for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { - p.SetState(643) + p.SetState(651) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2250,10 +2255,10 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DESC, CqlParserK_DESCRIBE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_LIST, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE: { - p.SetState(636) + p.SetState(644) p.Cql() } - p.SetState(638) + p.SetState(646) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2262,7 +2267,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { if _la == CqlParserMINUSMINUS { { - p.SetState(637) + p.SetState(645) p.Match(CqlParserMINUSMINUS) if p.HasError() { // Recognition error - abort rule @@ -2272,13 +2277,13 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { } { - p.SetState(640) + p.SetState(648) p.StatementSeparator() } case CqlParserSEMI: { - p.SetState(642) + p.SetState(650) p.Empty_() } @@ -2288,7 +2293,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { } } - p.SetState(647) + p.SetState(655) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2298,7 +2303,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { goto errorExit } } - p.SetState(656) + p.SetState(664) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2307,14 +2312,14 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DESC, CqlParserK_DESCRIBE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_LIST, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE: { - p.SetState(648) + p.SetState(656) p.Cql() } - p.SetState(653) + p.SetState(661) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 { - p.SetState(650) + p.SetState(658) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -2323,7 +2328,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { if _la == CqlParserMINUSMINUS { { - p.SetState(649) + p.SetState(657) p.Match(CqlParserMINUSMINUS) if p.HasError() { // Recognition error - abort rule @@ -2333,7 +2338,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { } { - p.SetState(652) + p.SetState(660) p.StatementSeparator() } @@ -2343,7 +2348,7 @@ func (p *CqlParser) Cqls() (localctx ICqlsContext) { case CqlParserSEMI: { - p.SetState(655) + p.SetState(663) p.Empty_() } @@ -2440,7 +2445,7 @@ func (p *CqlParser) StatementSeparator() (localctx IStatementSeparatorContext) { p.EnterRule(localctx, 4, CqlParserRULE_statementSeparator) p.EnterOuterAlt(localctx, 1) { - p.SetState(658) + p.SetState(666) p.Match(CqlParserSEMI) if p.HasError() { // Recognition error - abort rule @@ -2548,7 +2553,7 @@ func (p *CqlParser) Empty_() (localctx IEmpty_Context) { p.EnterRule(localctx, 6, CqlParserRULE_empty_) p.EnterOuterAlt(localctx, 1) { - p.SetState(660) + p.SetState(668) p.StatementSeparator() } @@ -3279,7 +3284,7 @@ func (s *CqlContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Cql() (localctx ICqlContext) { localctx = NewCqlContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 8, CqlParserRULE_cql) - p.SetState(700) + p.SetState(708) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -3289,266 +3294,266 @@ func (p *CqlParser) Cql() (localctx ICqlContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(662) + p.SetState(670) p.AlterKeyspace() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(663) + p.SetState(671) p.AlterMaterializedView() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(664) + p.SetState(672) p.AlterRole() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(665) + p.SetState(673) p.AlterTable() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(666) + p.SetState(674) p.AlterType() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(667) + p.SetState(675) p.AlterUser() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(668) + p.SetState(676) p.ApplyBatch() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(669) + p.SetState(677) p.CreateAggregate() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(670) + p.SetState(678) p.CreateFunction() } case 10: p.EnterOuterAlt(localctx, 10) { - p.SetState(671) + p.SetState(679) p.CreateIndex() } case 11: p.EnterOuterAlt(localctx, 11) { - p.SetState(672) + p.SetState(680) p.CreateKeyspace() } case 12: p.EnterOuterAlt(localctx, 12) { - p.SetState(673) + p.SetState(681) p.CreateMaterializedView() } case 13: p.EnterOuterAlt(localctx, 13) { - p.SetState(674) + p.SetState(682) p.CreateRole() } case 14: p.EnterOuterAlt(localctx, 14) { - p.SetState(675) + p.SetState(683) p.CreateTable() } case 15: p.EnterOuterAlt(localctx, 15) { - p.SetState(676) + p.SetState(684) p.CreateTrigger() } case 16: p.EnterOuterAlt(localctx, 16) { - p.SetState(677) + p.SetState(685) p.CreateType() } case 17: p.EnterOuterAlt(localctx, 17) { - p.SetState(678) + p.SetState(686) p.CreateUser() } case 18: p.EnterOuterAlt(localctx, 18) { - p.SetState(679) + p.SetState(687) p.Delete_() } case 19: p.EnterOuterAlt(localctx, 19) { - p.SetState(680) + p.SetState(688) p.DropAggregate() } case 20: p.EnterOuterAlt(localctx, 20) { - p.SetState(681) + p.SetState(689) p.DropFunction() } case 21: p.EnterOuterAlt(localctx, 21) { - p.SetState(682) + p.SetState(690) p.DropIndex() } case 22: p.EnterOuterAlt(localctx, 22) { - p.SetState(683) + p.SetState(691) p.DropKeyspace() } case 23: p.EnterOuterAlt(localctx, 23) { - p.SetState(684) + p.SetState(692) p.DropMaterializedView() } case 24: p.EnterOuterAlt(localctx, 24) { - p.SetState(685) + p.SetState(693) p.DropRole() } case 25: p.EnterOuterAlt(localctx, 25) { - p.SetState(686) + p.SetState(694) p.DropTable() } case 26: p.EnterOuterAlt(localctx, 26) { - p.SetState(687) + p.SetState(695) p.DropTrigger() } case 27: p.EnterOuterAlt(localctx, 27) { - p.SetState(688) + p.SetState(696) p.DropType() } case 28: p.EnterOuterAlt(localctx, 28) { - p.SetState(689) + p.SetState(697) p.DropUser() } case 29: p.EnterOuterAlt(localctx, 29) { - p.SetState(690) + p.SetState(698) p.Grant() } case 30: p.EnterOuterAlt(localctx, 30) { - p.SetState(691) + p.SetState(699) p.Insert() } case 31: p.EnterOuterAlt(localctx, 31) { - p.SetState(692) + p.SetState(700) p.ListPermissions() } case 32: p.EnterOuterAlt(localctx, 32) { - p.SetState(693) + p.SetState(701) p.ListRoles() } case 33: p.EnterOuterAlt(localctx, 33) { - p.SetState(694) + p.SetState(702) p.Revoke() } case 34: p.EnterOuterAlt(localctx, 34) { - p.SetState(695) + p.SetState(703) p.Select_() } case 35: p.EnterOuterAlt(localctx, 35) { - p.SetState(696) + p.SetState(704) p.Truncate() } case 36: p.EnterOuterAlt(localctx, 36) { - p.SetState(697) + p.SetState(705) p.Update() } case 37: p.EnterOuterAlt(localctx, 37) { - p.SetState(698) + p.SetState(706) p.Use_() } case 38: p.EnterOuterAlt(localctx, 38) { - p.SetState(699) + p.SetState(707) p.DescribeStatement() } @@ -3689,7 +3694,7 @@ func (p *CqlParser) DescribeStatement() (localctx IDescribeStatementContext) { localctx = NewDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 10, CqlParserRULE_describeStatement) p.EnterOuterAlt(localctx, 1) - p.SetState(704) + p.SetState(712) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -3698,13 +3703,13 @@ func (p *CqlParser) DescribeStatement() (localctx IDescribeStatementContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_DESC: { - p.SetState(702) + p.SetState(710) p.KwDesc() } case CqlParserK_DESCRIBE: { - p.SetState(703) + p.SetState(711) p.KwDescibe() } @@ -3713,7 +3718,7 @@ func (p *CqlParser) DescribeStatement() (localctx IDescribeStatementContext) { goto errorExit } { - p.SetState(706) + p.SetState(714) p.DescribeTarget() } @@ -3866,7 +3871,7 @@ func (s *DescribeTargetContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) DescribeTarget() (localctx IDescribeTargetContext) { localctx = NewDescribeTargetContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 12, CqlParserRULE_describeTarget) - p.SetState(712) + p.SetState(720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -3876,28 +3881,28 @@ func (p *CqlParser) DescribeTarget() (localctx IDescribeTargetContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(708) + p.SetState(716) p.DescribeTargetKeyspaces() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(709) + p.SetState(717) p.DescribeTargetTables() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(710) + p.SetState(718) p.DescribeTargetTable() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(711) + p.SetState(719) p.DescribeTargetKeyspace() } @@ -4005,7 +4010,7 @@ func (p *CqlParser) DescribeTargetKeyspaces() (localctx IDescribeTargetKeyspaces p.EnterRule(localctx, 14, CqlParserRULE_describeTargetKeyspaces) p.EnterOuterAlt(localctx, 1) { - p.SetState(714) + p.SetState(722) p.KwKeyspaces() } @@ -4109,7 +4114,7 @@ func (p *CqlParser) DescribeTargetTables() (localctx IDescribeTargetTablesContex p.EnterRule(localctx, 16, CqlParserRULE_describeTargetTables) p.EnterOuterAlt(localctx, 1) { - p.SetState(716) + p.SetState(724) p.KwTables() } @@ -4231,7 +4236,7 @@ func (p *CqlParser) DescribeTargetTable() (localctx IDescribeTargetTableContext) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(719) + p.SetState(727) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4240,13 +4245,13 @@ func (p *CqlParser) DescribeTargetTable() (localctx IDescribeTargetTableContext) if _la == CqlParserK_TABLE { { - p.SetState(718) + p.SetState(726) p.KwTable() } } { - p.SetState(721) + p.SetState(729) p.TableSpec() } @@ -4368,7 +4373,7 @@ func (p *CqlParser) DescribeTargetKeyspace() (localctx IDescribeTargetKeyspaceCo var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(724) + p.SetState(732) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4377,13 +4382,13 @@ func (p *CqlParser) DescribeTargetKeyspace() (localctx IDescribeTargetKeyspaceCo if _la == CqlParserK_KEYSPACE { { - p.SetState(723) + p.SetState(731) p.KwKeyspace() } } { - p.SetState(726) + p.SetState(734) p.Keyspace() } @@ -4572,27 +4577,27 @@ func (p *CqlParser) Revoke() (localctx IRevokeContext) { p.EnterRule(localctx, 22, CqlParserRULE_revoke) p.EnterOuterAlt(localctx, 1) { - p.SetState(728) + p.SetState(736) p.KwRevoke() } { - p.SetState(729) + p.SetState(737) p.Priviledge() } { - p.SetState(730) + p.SetState(738) p.KwOn() } { - p.SetState(731) + p.SetState(739) p.Resource() } { - p.SetState(732) + p.SetState(740) p.KwFrom() } { - p.SetState(733) + p.SetState(741) p.Role() } @@ -4766,14 +4771,14 @@ func (p *CqlParser) ListRoles() (localctx IListRolesContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(735) + p.SetState(743) p.KwList() } { - p.SetState(736) + p.SetState(744) p.KwRoles() } - p.SetState(740) + p.SetState(748) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4782,16 +4787,16 @@ func (p *CqlParser) ListRoles() (localctx IListRolesContext) { if _la == CqlParserK_OF { { - p.SetState(737) + p.SetState(745) p.KwOf() } { - p.SetState(738) + p.SetState(746) p.Role() } } - p.SetState(743) + p.SetState(751) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -4800,7 +4805,7 @@ func (p *CqlParser) ListRoles() (localctx IListRolesContext) { if _la == CqlParserK_NORECURSIVE { { - p.SetState(742) + p.SetState(750) p.KwNorecursive() } @@ -4993,14 +4998,14 @@ func (p *CqlParser) ListPermissions() (localctx IListPermissionsContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(745) + p.SetState(753) p.KwList() } { - p.SetState(746) + p.SetState(754) p.Priviledge() } - p.SetState(750) + p.SetState(758) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5009,16 +5014,16 @@ func (p *CqlParser) ListPermissions() (localctx IListPermissionsContext) { if _la == CqlParserK_ON { { - p.SetState(747) + p.SetState(755) p.KwOn() } { - p.SetState(748) + p.SetState(756) p.Resource() } } - p.SetState(755) + p.SetState(763) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5027,11 +5032,11 @@ func (p *CqlParser) ListPermissions() (localctx IListPermissionsContext) { if _la == CqlParserK_OF { { - p.SetState(752) + p.SetState(760) p.KwOf() } { - p.SetState(753) + p.SetState(761) p.Role() } @@ -5222,27 +5227,27 @@ func (p *CqlParser) Grant() (localctx IGrantContext) { p.EnterRule(localctx, 28, CqlParserRULE_grant) p.EnterOuterAlt(localctx, 1) { - p.SetState(757) + p.SetState(765) p.KwGrant() } { - p.SetState(758) + p.SetState(766) p.Priviledge() } { - p.SetState(759) + p.SetState(767) p.KwOn() } { - p.SetState(760) + p.SetState(768) p.Resource() } { - p.SetState(761) + p.SetState(769) p.KwTo() } { - p.SetState(762) + p.SetState(770) p.Role() } @@ -5497,7 +5502,7 @@ func (s *PriviledgeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) { localctx = NewPriviledgeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 30, CqlParserRULE_priviledge) - p.SetState(776) + p.SetState(784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5506,7 +5511,7 @@ func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_ALL: p.EnterOuterAlt(localctx, 1) - p.SetState(766) + p.SetState(774) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5515,13 +5520,13 @@ func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) { switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) { case 1: { - p.SetState(764) + p.SetState(772) p.KwAll() } case 2: { - p.SetState(765) + p.SetState(773) p.KwAllPermissions() } @@ -5532,56 +5537,56 @@ func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) { case CqlParserK_ALTER: p.EnterOuterAlt(localctx, 2) { - p.SetState(768) + p.SetState(776) p.KwAlter() } case CqlParserK_AUTHORIZE: p.EnterOuterAlt(localctx, 3) { - p.SetState(769) + p.SetState(777) p.KwAuthorize() } case CqlParserK_DESCRIBE: p.EnterOuterAlt(localctx, 4) { - p.SetState(770) + p.SetState(778) p.KwDescibe() } case CqlParserK_EXECUTE: p.EnterOuterAlt(localctx, 5) { - p.SetState(771) + p.SetState(779) p.KwExecute() } case CqlParserK_CREATE: p.EnterOuterAlt(localctx, 6) { - p.SetState(772) + p.SetState(780) p.KwCreate() } case CqlParserK_DROP: p.EnterOuterAlt(localctx, 7) { - p.SetState(773) + p.SetState(781) p.KwDrop() } case CqlParserK_MODIFY: p.EnterOuterAlt(localctx, 8) { - p.SetState(774) + p.SetState(782) p.KwModify() } case CqlParserK_SELECT: p.EnterOuterAlt(localctx, 9) { - p.SetState(775) + p.SetState(783) p.KwSelect() } @@ -5899,7 +5904,7 @@ func (p *CqlParser) Resource() (localctx IResourceContext) { p.EnterRule(localctx, 32, CqlParserRULE_resource) var _la int - p.SetState(811) + p.SetState(819) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -5909,53 +5914,53 @@ func (p *CqlParser) Resource() (localctx IResourceContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(778) + p.SetState(786) p.KwAll() } { - p.SetState(779) + p.SetState(787) p.KwFunctions() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(781) + p.SetState(789) p.KwAll() } { - p.SetState(782) + p.SetState(790) p.KwFunctions() } { - p.SetState(783) + p.SetState(791) p.KwIn() } { - p.SetState(784) + p.SetState(792) p.KwKeyspace() } { - p.SetState(785) + p.SetState(793) p.Keyspace() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(787) + p.SetState(795) p.KwFunction() } - p.SetState(791) + p.SetState(799) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, p.GetParserRuleContext()) == 1 { { - p.SetState(788) + p.SetState(796) p.Keyspace() } { - p.SetState(789) + p.SetState(797) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -5967,35 +5972,35 @@ func (p *CqlParser) Resource() (localctx IResourceContext) { goto errorExit } { - p.SetState(793) + p.SetState(801) p.Function_() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(795) + p.SetState(803) p.KwAll() } { - p.SetState(796) + p.SetState(804) p.KwKeyspaces() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(798) + p.SetState(806) p.KwKeyspace() } { - p.SetState(799) + p.SetState(807) p.Keyspace() } case 6: p.EnterOuterAlt(localctx, 6) - p.SetState(802) + p.SetState(810) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6004,35 +6009,35 @@ func (p *CqlParser) Resource() (localctx IResourceContext) { if _la == CqlParserK_TABLE { { - p.SetState(801) + p.SetState(809) p.KwTable() } } { - p.SetState(804) + p.SetState(812) p.TableSpec() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(805) + p.SetState(813) p.KwAll() } { - p.SetState(806) + p.SetState(814) p.KwRoles() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(808) + p.SetState(816) p.KwRole() } { - p.SetState(809) + p.SetState(817) p.Role() } @@ -6278,14 +6283,14 @@ func (p *CqlParser) CreateUser() (localctx ICreateUserContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(813) + p.SetState(821) p.KwCreate() } { - p.SetState(814) + p.SetState(822) p.KwUser() } - p.SetState(816) + p.SetState(824) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6294,28 +6299,28 @@ func (p *CqlParser) CreateUser() (localctx ICreateUserContext) { if _la == CqlParserK_IF { { - p.SetState(815) + p.SetState(823) p.IfNotExist() } } { - p.SetState(818) + p.SetState(826) p.User() } { - p.SetState(819) + p.SetState(827) p.KwWith() } { - p.SetState(820) + p.SetState(828) p.KwPassword() } { - p.SetState(821) + p.SetState(829) p.StringLiteral() } - p.SetState(824) + p.SetState(832) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6323,13 +6328,13 @@ func (p *CqlParser) CreateUser() (localctx ICreateUserContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_SUPERUSER: { - p.SetState(822) + p.SetState(830) p.KwSuperuser() } case CqlParserK_NOSUPERUSER: { - p.SetState(823) + p.SetState(831) p.KwNosuperuser() } @@ -6508,14 +6513,14 @@ func (p *CqlParser) CreateRole() (localctx ICreateRoleContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(826) + p.SetState(834) p.KwCreate() } { - p.SetState(827) + p.SetState(835) p.KwRole() } - p.SetState(829) + p.SetState(837) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6524,16 +6529,16 @@ func (p *CqlParser) CreateRole() (localctx ICreateRoleContext) { if _la == CqlParserK_IF { { - p.SetState(828) + p.SetState(836) p.IfNotExist() } } { - p.SetState(831) + p.SetState(839) p.Role() } - p.SetState(833) + p.SetState(841) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6542,7 +6547,7 @@ func (p *CqlParser) CreateRole() (localctx ICreateRoleContext) { if _la == CqlParserK_WITH { { - p.SetState(832) + p.SetState(840) p.RoleWith() } @@ -6774,14 +6779,14 @@ func (p *CqlParser) CreateType() (localctx ICreateTypeContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(835) + p.SetState(843) p.KwCreate() } { - p.SetState(836) + p.SetState(844) p.KwType() } - p.SetState(838) + p.SetState(846) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -6790,21 +6795,21 @@ func (p *CqlParser) CreateType() (localctx ICreateTypeContext) { if _la == CqlParserK_IF { { - p.SetState(837) + p.SetState(845) p.IfNotExist() } } - p.SetState(843) + p.SetState(851) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { { - p.SetState(840) + p.SetState(848) p.Keyspace() } { - p.SetState(841) + p.SetState(849) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -6816,19 +6821,19 @@ func (p *CqlParser) CreateType() (localctx ICreateTypeContext) { goto errorExit } { - p.SetState(845) + p.SetState(853) p.Type_() } { - p.SetState(846) + p.SetState(854) p.SyntaxBracketLr() } { - p.SetState(847) + p.SetState(855) p.TypeMemberColumnList() } { - p.SetState(848) + p.SetState(856) p.SyntaxBracketRr() } @@ -7046,14 +7051,14 @@ func (p *CqlParser) TypeMemberColumnList() (localctx ITypeMemberColumnListContex p.EnterOuterAlt(localctx, 1) { - p.SetState(850) + p.SetState(858) p.Column() } { - p.SetState(851) + p.SetState(859) p.DataType() } - p.SetState(858) + p.SetState(866) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7062,19 +7067,19 @@ func (p *CqlParser) TypeMemberColumnList() (localctx ITypeMemberColumnListContex for _la == CqlParserCOMMA { { - p.SetState(852) + p.SetState(860) p.SyntaxComma() } { - p.SetState(853) + p.SetState(861) p.Column() } { - p.SetState(854) + p.SetState(862) p.DataType() } - p.SetState(860) + p.SetState(868) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7291,14 +7296,14 @@ func (p *CqlParser) CreateTrigger() (localctx ICreateTriggerContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(861) + p.SetState(869) p.KwCreate() } { - p.SetState(862) + p.SetState(870) p.KwTrigger() } - p.SetState(864) + p.SetState(872) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7307,21 +7312,21 @@ func (p *CqlParser) CreateTrigger() (localctx ICreateTriggerContext) { if _la == CqlParserK_IF { { - p.SetState(863) + p.SetState(871) p.IfNotExist() } } - p.SetState(869) + p.SetState(877) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { { - p.SetState(866) + p.SetState(874) p.Keyspace() } { - p.SetState(867) + p.SetState(875) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -7333,15 +7338,15 @@ func (p *CqlParser) CreateTrigger() (localctx ICreateTriggerContext) { goto errorExit } { - p.SetState(871) + p.SetState(879) p.Trigger() } { - p.SetState(872) + p.SetState(880) p.KwUsing() } { - p.SetState(873) + p.SetState(881) p.TriggerClass() } @@ -7767,18 +7772,18 @@ func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewCo p.EnterOuterAlt(localctx, 1) { - p.SetState(875) + p.SetState(883) p.KwCreate() } { - p.SetState(876) + p.SetState(884) p.KwMaterialized() } { - p.SetState(877) + p.SetState(885) p.KwView() } - p.SetState(879) + p.SetState(887) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7787,21 +7792,21 @@ func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewCo if _la == CqlParserK_IF { { - p.SetState(878) + p.SetState(886) p.IfNotExist() } } - p.SetState(884) + p.SetState(892) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 32, p.GetParserRuleContext()) == 1 { { - p.SetState(881) + p.SetState(889) p.Keyspace() } { - p.SetState(882) + p.SetState(890) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -7813,54 +7818,54 @@ func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewCo goto errorExit } { - p.SetState(886) + p.SetState(894) p.MaterializedView() } { - p.SetState(887) + p.SetState(895) p.KwAs() } { - p.SetState(888) + p.SetState(896) p.KwSelect() } { - p.SetState(889) + p.SetState(897) p.ColumnList() } { - p.SetState(890) + p.SetState(898) p.KwFrom() } { - p.SetState(891) + p.SetState(899) p.TableSpec() } { - p.SetState(892) + p.SetState(900) p.MaterializedViewWhere() } { - p.SetState(893) + p.SetState(901) p.KwPrimary() } { - p.SetState(894) + p.SetState(902) p.KwKey() } { - p.SetState(895) + p.SetState(903) p.SyntaxBracketLr() } { - p.SetState(896) + p.SetState(904) p.ColumnList() } { - p.SetState(897) + p.SetState(905) p.SyntaxBracketRr() } - p.SetState(901) + p.SetState(909) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -7869,11 +7874,11 @@ func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewCo if _la == CqlParserK_WITH { { - p.SetState(898) + p.SetState(906) p.KwWith() } { - p.SetState(899) + p.SetState(907) p.MaterializedViewOptions() } @@ -8032,14 +8037,14 @@ func (p *CqlParser) MaterializedViewWhere() (localctx IMaterializedViewWhereCont p.EnterOuterAlt(localctx, 1) { - p.SetState(903) + p.SetState(911) p.KwWhere() } { - p.SetState(904) + p.SetState(912) p.ColumnNotNullList() } - p.SetState(908) + p.SetState(916) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8048,11 +8053,11 @@ func (p *CqlParser) MaterializedViewWhere() (localctx IMaterializedViewWhereCont if _la == CqlParserK_AND { { - p.SetState(905) + p.SetState(913) p.KwAnd() } { - p.SetState(906) + p.SetState(914) p.RelationElements() } @@ -8229,10 +8234,10 @@ func (p *CqlParser) ColumnNotNullList() (localctx IColumnNotNullListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(910) + p.SetState(918) p.ColumnNotNull() } - p.SetState(916) + p.SetState(924) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8244,16 +8249,16 @@ func (p *CqlParser) ColumnNotNullList() (localctx IColumnNotNullListContext) { for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(911) + p.SetState(919) p.KwAnd() } { - p.SetState(912) + p.SetState(920) p.ColumnNotNull() } } - p.SetState(918) + p.SetState(926) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8415,19 +8420,19 @@ func (p *CqlParser) ColumnNotNull() (localctx IColumnNotNullContext) { p.EnterRule(localctx, 50, CqlParserRULE_columnNotNull) p.EnterOuterAlt(localctx, 1) { - p.SetState(919) + p.SetState(927) p.Column() } { - p.SetState(920) + p.SetState(928) p.KwIs() } { - p.SetState(921) + p.SetState(929) p.KwNot() } { - p.SetState(922) + p.SetState(930) p.KwNull() } @@ -8563,7 +8568,7 @@ func (s *MaterializedViewOptionsContext) ExitRule(listener antlr.ParseTreeListen func (p *CqlParser) MaterializedViewOptions() (localctx IMaterializedViewOptionsContext) { localctx = NewMaterializedViewOptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 52, CqlParserRULE_materializedViewOptions) - p.SetState(930) + p.SetState(938) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8573,29 +8578,29 @@ func (p *CqlParser) MaterializedViewOptions() (localctx IMaterializedViewOptions case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(924) + p.SetState(932) p.TableOptions() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(925) + p.SetState(933) p.TableOptions() } { - p.SetState(926) + p.SetState(934) p.KwAnd() } { - p.SetState(927) + p.SetState(935) p.ClusteringOrder() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(929) + p.SetState(937) p.ClusteringOrder() } @@ -8880,14 +8885,14 @@ func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(932) + p.SetState(940) p.KwCreate() } { - p.SetState(933) + p.SetState(941) p.KwKeyspace() } - p.SetState(935) + p.SetState(943) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8896,25 +8901,25 @@ func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) { if _la == CqlParserK_IF { { - p.SetState(934) + p.SetState(942) p.IfNotExist() } } { - p.SetState(937) + p.SetState(945) p.Keyspace() } { - p.SetState(938) + p.SetState(946) p.KwWith() } { - p.SetState(939) + p.SetState(947) p.KwReplication() } { - p.SetState(940) + p.SetState(948) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -8922,18 +8927,18 @@ func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) { } } { - p.SetState(941) + p.SetState(949) p.SyntaxBracketLc() } { - p.SetState(942) + p.SetState(950) p.ReplicationList() } { - p.SetState(943) + p.SetState(951) p.SyntaxBracketRc() } - p.SetState(947) + p.SetState(955) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -8942,11 +8947,11 @@ func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) { if _la == CqlParserK_AND { { - p.SetState(944) + p.SetState(952) p.KwAnd() } { - p.SetState(945) + p.SetState(953) p.DurableWrites() } @@ -9314,10 +9319,10 @@ func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(949) + p.SetState(957) p.KwCreate() } - p.SetState(951) + p.SetState(959) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9326,16 +9331,16 @@ func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { if _la == CqlParserK_OR { { - p.SetState(950) + p.SetState(958) p.OrReplace() } } { - p.SetState(953) + p.SetState(961) p.KwFunction() } - p.SetState(955) + p.SetState(963) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9344,21 +9349,21 @@ func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { if _la == CqlParserK_IF { { - p.SetState(954) + p.SetState(962) p.IfNotExist() } } - p.SetState(960) + p.SetState(968) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 41, p.GetParserRuleContext()) == 1 { { - p.SetState(957) + p.SetState(965) p.Keyspace() } { - p.SetState(958) + p.SetState(966) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -9370,14 +9375,14 @@ func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { goto errorExit } { - p.SetState(962) + p.SetState(970) p.Function_() } { - p.SetState(963) + p.SetState(971) p.SyntaxBracketLr() } - p.SetState(965) + p.SetState(973) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9386,41 +9391,41 @@ func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { if _la == CqlParserK_INPUT || _la == CqlParserOBJECT_NAME { { - p.SetState(964) + p.SetState(972) p.ParamList() } } { - p.SetState(967) + p.SetState(975) p.SyntaxBracketRr() } { - p.SetState(968) + p.SetState(976) p.ReturnMode() } { - p.SetState(969) + p.SetState(977) p.KwReturns() } { - p.SetState(970) + p.SetState(978) p.DataType() } { - p.SetState(971) + p.SetState(979) p.KwLanguage() } { - p.SetState(972) + p.SetState(980) p.Language() } { - p.SetState(973) + p.SetState(981) p.KwAs() } { - p.SetState(974) + p.SetState(982) p.CodeBlock() } @@ -9519,7 +9524,7 @@ func (p *CqlParser) CodeBlock() (localctx ICodeBlockContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(976) + p.SetState(984) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserCODE_BLOCK || _la == CqlParserSTRING_LITERAL) { @@ -9701,10 +9706,10 @@ func (p *CqlParser) ParamList() (localctx IParamListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(978) + p.SetState(986) p.Param() } - p.SetState(984) + p.SetState(992) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9713,15 +9718,15 @@ func (p *CqlParser) ParamList() (localctx IParamListContext) { for _la == CqlParserCOMMA { { - p.SetState(979) + p.SetState(987) p.SyntaxComma() } { - p.SetState(980) + p.SetState(988) p.Param() } - p.SetState(986) + p.SetState(994) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9922,7 +9927,7 @@ func (p *CqlParser) ReturnMode() (localctx IReturnModeContext) { localctx = NewReturnModeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 62, CqlParserRULE_returnMode) p.EnterOuterAlt(localctx, 1) - p.SetState(991) + p.SetState(999) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -9931,17 +9936,17 @@ func (p *CqlParser) ReturnMode() (localctx IReturnModeContext) { switch p.GetTokenStream().LA(1) { case CqlParserK_CALLED: { - p.SetState(987) + p.SetState(995) p.KwCalled() } case CqlParserK_RETURNS: { - p.SetState(988) + p.SetState(996) p.KwReturns() } { - p.SetState(989) + p.SetState(997) p.KwNull() } @@ -9950,15 +9955,15 @@ func (p *CqlParser) ReturnMode() (localctx IReturnModeContext) { goto errorExit } { - p.SetState(993) + p.SetState(1001) p.KwOn() } { - p.SetState(994) + p.SetState(1002) p.KwNull() } { - p.SetState(995) + p.SetState(1003) p.KwInput() } @@ -10359,10 +10364,10 @@ func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(997) + p.SetState(1005) p.KwCreate() } - p.SetState(999) + p.SetState(1007) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10371,16 +10376,16 @@ func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) { if _la == CqlParserK_OR { { - p.SetState(998) + p.SetState(1006) p.OrReplace() } } { - p.SetState(1001) + p.SetState(1009) p.KwAggregate() } - p.SetState(1003) + p.SetState(1011) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10389,21 +10394,21 @@ func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) { if _la == CqlParserK_IF { { - p.SetState(1002) + p.SetState(1010) p.IfNotExist() } } - p.SetState(1008) + p.SetState(1016) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 47, p.GetParserRuleContext()) == 1 { { - p.SetState(1005) + p.SetState(1013) p.Keyspace() } { - p.SetState(1006) + p.SetState(1014) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -10415,51 +10420,51 @@ func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) { goto errorExit } { - p.SetState(1010) + p.SetState(1018) p.Aggregate() } { - p.SetState(1011) + p.SetState(1019) p.SyntaxBracketLr() } { - p.SetState(1012) + p.SetState(1020) p.DataType() } { - p.SetState(1013) + p.SetState(1021) p.SyntaxBracketRr() } { - p.SetState(1014) + p.SetState(1022) p.KwSfunc() } { - p.SetState(1015) + p.SetState(1023) p.Function_() } { - p.SetState(1016) + p.SetState(1024) p.KwStype() } { - p.SetState(1017) + p.SetState(1025) p.DataType() } { - p.SetState(1018) + p.SetState(1026) p.KwFinalfunc() } { - p.SetState(1019) + p.SetState(1027) p.Function_() } { - p.SetState(1020) + p.SetState(1028) p.KwInitcond() } { - p.SetState(1021) + p.SetState(1029) p.InitCondDefinition() } @@ -10612,7 +10617,7 @@ func (s *InitCondDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) InitCondDefinition() (localctx IInitCondDefinitionContext) { localctx = NewInitCondDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 66, CqlParserRULE_initCondDefinition) - p.SetState(1027) + p.SetState(1035) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10622,28 +10627,28 @@ func (p *CqlParser) InitCondDefinition() (localctx IInitCondDefinitionContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1023) + p.SetState(1031) p.Constant() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1024) + p.SetState(1032) p.InitCondList() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1025) + p.SetState(1033) p.InitCondListNested() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1026) + p.SetState(1034) p.InitCondHash() } @@ -10856,14 +10861,14 @@ func (p *CqlParser) InitCondHash() (localctx IInitCondHashContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1029) + p.SetState(1037) p.SyntaxBracketLc() } { - p.SetState(1030) + p.SetState(1038) p.InitCondHashItem() } - p.SetState(1036) + p.SetState(1044) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10872,15 +10877,15 @@ func (p *CqlParser) InitCondHash() (localctx IInitCondHashContext) { for _la == CqlParserCOMMA { { - p.SetState(1031) + p.SetState(1039) p.SyntaxComma() } { - p.SetState(1032) + p.SetState(1040) p.InitCondHashItem() } - p.SetState(1038) + p.SetState(1046) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -10888,7 +10893,7 @@ func (p *CqlParser) InitCondHash() (localctx IInitCondHashContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1039) + p.SetState(1047) p.SyntaxBracketRc() } @@ -11014,11 +11019,11 @@ func (p *CqlParser) InitCondHashItem() (localctx IInitCondHashItemContext) { p.EnterRule(localctx, 70, CqlParserRULE_initCondHashItem) p.EnterOuterAlt(localctx, 1) { - p.SetState(1041) + p.SetState(1049) p.HashKey() } { - p.SetState(1042) + p.SetState(1050) p.Match(CqlParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -11026,7 +11031,7 @@ func (p *CqlParser) InitCondHashItem() (localctx IInitCondHashItemContext) { } } { - p.SetState(1043) + p.SetState(1051) p.InitCondDefinition() } @@ -11278,14 +11283,14 @@ func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1045) + p.SetState(1053) p.SyntaxBracketLr() } { - p.SetState(1046) + p.SetState(1054) p.InitCondList() } - p.SetState(1053) + p.SetState(1061) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11293,7 +11298,7 @@ func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { _la = p.GetTokenStream().LA(1) for _la == CqlParserLR_BRACKET || _la == CqlParserCOMMA { - p.SetState(1051) + p.SetState(1059) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11302,17 +11307,17 @@ func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { switch p.GetTokenStream().LA(1) { case CqlParserCOMMA: { - p.SetState(1047) + p.SetState(1055) p.SyntaxComma() } { - p.SetState(1048) + p.SetState(1056) p.Constant() } case CqlParserLR_BRACKET: { - p.SetState(1050) + p.SetState(1058) p.InitCondList() } @@ -11321,7 +11326,7 @@ func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { goto errorExit } - p.SetState(1055) + p.SetState(1063) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11329,7 +11334,7 @@ func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1056) + p.SetState(1064) p.SyntaxBracketRr() } @@ -11538,14 +11543,14 @@ func (p *CqlParser) InitCondList() (localctx IInitCondListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1058) + p.SetState(1066) p.SyntaxBracketLr() } { - p.SetState(1059) + p.SetState(1067) p.Constant() } - p.SetState(1065) + p.SetState(1073) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11554,15 +11559,15 @@ func (p *CqlParser) InitCondList() (localctx IInitCondListContext) { for _la == CqlParserCOMMA { { - p.SetState(1060) + p.SetState(1068) p.SyntaxComma() } { - p.SetState(1061) + p.SetState(1069) p.Constant() } - p.SetState(1067) + p.SetState(1075) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11570,7 +11575,7 @@ func (p *CqlParser) InitCondList() (localctx IInitCondListContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1068) + p.SetState(1076) p.SyntaxBracketRr() } @@ -11691,11 +11696,11 @@ func (p *CqlParser) OrReplace() (localctx IOrReplaceContext) { p.EnterRule(localctx, 76, CqlParserRULE_orReplace) p.EnterOuterAlt(localctx, 1) { - p.SetState(1070) + p.SetState(1078) p.KwOr() } { - p.SetState(1071) + p.SetState(1079) p.KwReplace() } @@ -11886,26 +11891,26 @@ func (p *CqlParser) AlterUser() (localctx IAlterUserContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1073) + p.SetState(1081) p.KwAlter() } { - p.SetState(1074) + p.SetState(1082) p.KwUser() } { - p.SetState(1075) + p.SetState(1083) p.User() } { - p.SetState(1076) + p.SetState(1084) p.KwWith() } { - p.SetState(1077) + p.SetState(1085) p.UserPassword() } - p.SetState(1079) + p.SetState(1087) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -11914,7 +11919,7 @@ func (p *CqlParser) AlterUser() (localctx IAlterUserContext) { if _la == CqlParserK_NOSUPERUSER || _la == CqlParserK_SUPERUSER { { - p.SetState(1078) + p.SetState(1086) p.UserSuperUser() } @@ -12037,11 +12042,11 @@ func (p *CqlParser) UserPassword() (localctx IUserPasswordContext) { p.EnterRule(localctx, 80, CqlParserRULE_userPassword) p.EnterOuterAlt(localctx, 1) { - p.SetState(1081) + p.SetState(1089) p.KwPassword() } { - p.SetState(1082) + p.SetState(1090) p.StringLiteral() } @@ -12160,7 +12165,7 @@ func (s *UserSuperUserContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) UserSuperUser() (localctx IUserSuperUserContext) { localctx = NewUserSuperUserContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 82, CqlParserRULE_userSuperUser) - p.SetState(1086) + p.SetState(1094) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -12170,14 +12175,14 @@ func (p *CqlParser) UserSuperUser() (localctx IUserSuperUserContext) { case CqlParserK_SUPERUSER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1084) + p.SetState(1092) p.KwSuperuser() } case CqlParserK_NOSUPERUSER: p.EnterOuterAlt(localctx, 2) { - p.SetState(1085) + p.SetState(1093) p.KwNosuperuser() } @@ -12359,23 +12364,23 @@ func (p *CqlParser) AlterType() (localctx IAlterTypeContext) { p.EnterRule(localctx, 84, CqlParserRULE_alterType) p.EnterOuterAlt(localctx, 1) { - p.SetState(1088) + p.SetState(1096) p.KwAlter() } { - p.SetState(1089) + p.SetState(1097) p.KwType() } - p.SetState(1093) + p.SetState(1101) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 { { - p.SetState(1090) + p.SetState(1098) p.Keyspace() } { - p.SetState(1091) + p.SetState(1099) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -12387,11 +12392,11 @@ func (p *CqlParser) AlterType() (localctx IAlterTypeContext) { goto errorExit } { - p.SetState(1095) + p.SetState(1103) p.Type_() } { - p.SetState(1096) + p.SetState(1104) p.AlterTypeOperation() } @@ -12527,7 +12532,7 @@ func (s *AlterTypeOperationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) AlterTypeOperation() (localctx IAlterTypeOperationContext) { localctx = NewAlterTypeOperationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 86, CqlParserRULE_alterTypeOperation) - p.SetState(1101) + p.SetState(1109) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -12537,21 +12542,21 @@ func (p *CqlParser) AlterTypeOperation() (localctx IAlterTypeOperationContext) { case CqlParserK_ALTER: p.EnterOuterAlt(localctx, 1) { - p.SetState(1098) + p.SetState(1106) p.AlterTypeAlterType() } case CqlParserK_ADD: p.EnterOuterAlt(localctx, 2) { - p.SetState(1099) + p.SetState(1107) p.AlterTypeAdd() } case CqlParserK_RENAME: p.EnterOuterAlt(localctx, 3) { - p.SetState(1100) + p.SetState(1108) p.AlterTypeRename() } @@ -12677,11 +12682,11 @@ func (p *CqlParser) AlterTypeRename() (localctx IAlterTypeRenameContext) { p.EnterRule(localctx, 88, CqlParserRULE_alterTypeRename) p.EnterOuterAlt(localctx, 1) { - p.SetState(1103) + p.SetState(1111) p.KwRename() } { - p.SetState(1104) + p.SetState(1112) p.AlterTypeRenameList() } @@ -12856,10 +12861,10 @@ func (p *CqlParser) AlterTypeRenameList() (localctx IAlterTypeRenameListContext) p.EnterOuterAlt(localctx, 1) { - p.SetState(1106) + p.SetState(1114) p.AlterTypeRenameItem() } - p.SetState(1112) + p.SetState(1120) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -12868,15 +12873,15 @@ func (p *CqlParser) AlterTypeRenameList() (localctx IAlterTypeRenameListContext) for _la == CqlParserK_AND { { - p.SetState(1107) + p.SetState(1115) p.KwAnd() } { - p.SetState(1108) + p.SetState(1116) p.AlterTypeRenameItem() } - p.SetState(1114) + p.SetState(1122) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -13027,15 +13032,15 @@ func (p *CqlParser) AlterTypeRenameItem() (localctx IAlterTypeRenameItemContext) p.EnterRule(localctx, 92, CqlParserRULE_alterTypeRenameItem) p.EnterOuterAlt(localctx, 1) { - p.SetState(1115) + p.SetState(1123) p.Column() } { - p.SetState(1116) + p.SetState(1124) p.KwTo() } { - p.SetState(1117) + p.SetState(1125) p.Column() } @@ -13270,18 +13275,18 @@ func (p *CqlParser) AlterTypeAdd() (localctx IAlterTypeAddContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1119) + p.SetState(1127) p.KwAdd() } { - p.SetState(1120) + p.SetState(1128) p.Column() } { - p.SetState(1121) + p.SetState(1129) p.DataType() } - p.SetState(1128) + p.SetState(1136) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -13290,19 +13295,19 @@ func (p *CqlParser) AlterTypeAdd() (localctx IAlterTypeAddContext) { for _la == CqlParserCOMMA { { - p.SetState(1122) + p.SetState(1130) p.SyntaxComma() } { - p.SetState(1123) + p.SetState(1131) p.Column() } { - p.SetState(1124) + p.SetState(1132) p.DataType() } - p.SetState(1130) + p.SetState(1138) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -13461,19 +13466,19 @@ func (p *CqlParser) AlterTypeAlterType() (localctx IAlterTypeAlterTypeContext) { p.EnterRule(localctx, 96, CqlParserRULE_alterTypeAlterType) p.EnterOuterAlt(localctx, 1) { - p.SetState(1131) + p.SetState(1139) p.KwAlter() } { - p.SetState(1132) + p.SetState(1140) p.Column() } { - p.SetState(1133) + p.SetState(1141) p.KwType() } { - p.SetState(1134) + p.SetState(1142) p.DataType() } @@ -13628,19 +13633,19 @@ func (p *CqlParser) AlterTable() (localctx IAlterTableContext) { p.EnterRule(localctx, 98, CqlParserRULE_alterTable) p.EnterOuterAlt(localctx, 1) { - p.SetState(1136) + p.SetState(1144) p.KwAlter() } { - p.SetState(1137) + p.SetState(1145) p.KwTable() } { - p.SetState(1138) + p.SetState(1146) p.TableSpec() } { - p.SetState(1139) + p.SetState(1147) p.AlterTableOperation() } @@ -13827,7 +13832,7 @@ func (s *AlterTableOperationContext) ExitRule(listener antlr.ParseTreeListener) func (p *CqlParser) AlterTableOperation() (localctx IAlterTableOperationContext) { localctx = NewAlterTableOperationContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 100, CqlParserRULE_alterTableOperation) - p.SetState(1147) + p.SetState(1155) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -13837,42 +13842,42 @@ func (p *CqlParser) AlterTableOperation() (localctx IAlterTableOperationContext) case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1141) + p.SetState(1149) p.AlterTableAdd() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1142) + p.SetState(1150) p.AlterTableDropColumns() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1143) + p.SetState(1151) p.AlterTableDropCompactStorage() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1144) + p.SetState(1152) p.AlterTableAlterColumnTypes() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1145) + p.SetState(1153) p.AlterTableRename() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1146) + p.SetState(1154) p.AlterTableWith() } @@ -13997,11 +14002,11 @@ func (p *CqlParser) AlterTableWith() (localctx IAlterTableWithContext) { p.EnterRule(localctx, 102, CqlParserRULE_alterTableWith) p.EnterOuterAlt(localctx, 1) { - p.SetState(1149) + p.SetState(1157) p.KwWith() } { - p.SetState(1150) + p.SetState(1158) p.TableOptions() } @@ -14165,19 +14170,19 @@ func (p *CqlParser) AlterTableRename() (localctx IAlterTableRenameContext) { p.EnterRule(localctx, 104, CqlParserRULE_alterTableRename) p.EnterOuterAlt(localctx, 1) { - p.SetState(1152) + p.SetState(1160) p.KwRename() } { - p.SetState(1153) + p.SetState(1161) p.Column() } { - p.SetState(1154) + p.SetState(1162) p.KwTo() } { - p.SetState(1155) + p.SetState(1163) p.Column() } @@ -14315,15 +14320,15 @@ func (p *CqlParser) AlterTableDropCompactStorage() (localctx IAlterTableDropComp p.EnterRule(localctx, 106, CqlParserRULE_alterTableDropCompactStorage) p.EnterOuterAlt(localctx, 1) { - p.SetState(1157) + p.SetState(1165) p.KwDrop() } { - p.SetState(1158) + p.SetState(1166) p.KwCompact() } { - p.SetState(1159) + p.SetState(1167) p.KwStorage() } @@ -14444,11 +14449,11 @@ func (p *CqlParser) AlterTableDropColumns() (localctx IAlterTableDropColumnsCont p.EnterRule(localctx, 108, CqlParserRULE_alterTableDropColumns) p.EnterOuterAlt(localctx, 1) { - p.SetState(1161) + p.SetState(1169) p.KwDrop() } { - p.SetState(1162) + p.SetState(1170) p.AlterTableDropColumnList() } @@ -14623,10 +14628,10 @@ func (p *CqlParser) AlterTableDropColumnList() (localctx IAlterTableDropColumnLi p.EnterOuterAlt(localctx, 1) { - p.SetState(1164) + p.SetState(1172) p.Column() } - p.SetState(1170) + p.SetState(1178) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14635,15 +14640,15 @@ func (p *CqlParser) AlterTableDropColumnList() (localctx IAlterTableDropColumnLi for _la == CqlParserCOMMA { { - p.SetState(1165) + p.SetState(1173) p.SyntaxComma() } { - p.SetState(1166) + p.SetState(1174) p.Column() } - p.SetState(1172) + p.SetState(1180) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14768,11 +14773,11 @@ func (p *CqlParser) AlterTableAlterColumnTypes() (localctx IAlterTableAlterColum p.EnterRule(localctx, 112, CqlParserRULE_alterTableAlterColumnTypes) p.EnterOuterAlt(localctx, 1) { - p.SetState(1173) + p.SetState(1181) p.KwAlter() } { - p.SetState(1174) + p.SetState(1182) p.AlterTableAlterColumnTypeList() } @@ -14947,10 +14952,10 @@ func (p *CqlParser) AlterTableAlterColumnTypeList() (localctx IAlterTableAlterCo p.EnterOuterAlt(localctx, 1) { - p.SetState(1176) + p.SetState(1184) p.AlterTableAlterColumnType() } - p.SetState(1182) + p.SetState(1190) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -14959,15 +14964,15 @@ func (p *CqlParser) AlterTableAlterColumnTypeList() (localctx IAlterTableAlterCo for _la == CqlParserCOMMA { { - p.SetState(1177) + p.SetState(1185) p.SyntaxComma() } { - p.SetState(1178) + p.SetState(1186) p.AlterTableAlterColumnType() } - p.SetState(1184) + p.SetState(1192) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15109,15 +15114,15 @@ func (p *CqlParser) AlterTableAlterColumnType() (localctx IAlterTableAlterColumn p.EnterRule(localctx, 116, CqlParserRULE_alterTableAlterColumnType) p.EnterOuterAlt(localctx, 1) { - p.SetState(1185) + p.SetState(1193) p.Column() } { - p.SetState(1186) + p.SetState(1194) p.KwType() } { - p.SetState(1187) + p.SetState(1195) p.DataType() } @@ -15238,11 +15243,11 @@ func (p *CqlParser) AlterTableAdd() (localctx IAlterTableAddContext) { p.EnterRule(localctx, 118, CqlParserRULE_alterTableAdd) p.EnterOuterAlt(localctx, 1) { - p.SetState(1189) + p.SetState(1197) p.KwAdd() } { - p.SetState(1190) + p.SetState(1198) p.AlterTableColumnDefinition() } @@ -15417,10 +15422,10 @@ func (p *CqlParser) AlterTableColumnDefinition() (localctx IAlterTableColumnDefi p.EnterOuterAlt(localctx, 1) { - p.SetState(1192) + p.SetState(1200) p.AlterTableAddColumn() } - p.SetState(1198) + p.SetState(1206) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15429,15 +15434,15 @@ func (p *CqlParser) AlterTableColumnDefinition() (localctx IAlterTableColumnDefi for _la == CqlParserCOMMA { { - p.SetState(1193) + p.SetState(1201) p.SyntaxComma() } { - p.SetState(1194) + p.SetState(1202) p.AlterTableAddColumn() } - p.SetState(1200) + p.SetState(1208) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15562,11 +15567,11 @@ func (p *CqlParser) AlterTableAddColumn() (localctx IAlterTableAddColumnContext) p.EnterRule(localctx, 122, CqlParserRULE_alterTableAddColumn) p.EnterOuterAlt(localctx, 1) { - p.SetState(1201) + p.SetState(1209) p.Column() } { - p.SetState(1202) + p.SetState(1210) p.DataType() } @@ -15723,18 +15728,18 @@ func (p *CqlParser) AlterRole() (localctx IAlterRoleContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1204) + p.SetState(1212) p.KwAlter() } { - p.SetState(1205) + p.SetState(1213) p.KwRole() } { - p.SetState(1206) + p.SetState(1214) p.Role() } - p.SetState(1208) + p.SetState(1216) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15743,7 +15748,7 @@ func (p *CqlParser) AlterRole() (localctx IAlterRoleContext) { if _la == CqlParserK_WITH { { - p.SetState(1207) + p.SetState(1215) p.RoleWith() } @@ -15937,15 +15942,15 @@ func (p *CqlParser) RoleWith() (localctx IRoleWithContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1210) + p.SetState(1218) p.KwWith() } { - p.SetState(1211) + p.SetState(1219) p.RoleWithOptions() } - p.SetState(1217) + p.SetState(1225) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -15954,15 +15959,15 @@ func (p *CqlParser) RoleWith() (localctx IRoleWithContext) { for _la == CqlParserK_AND { { - p.SetState(1212) + p.SetState(1220) p.KwAnd() } { - p.SetState(1213) + p.SetState(1221) p.RoleWithOptions() } - p.SetState(1219) + p.SetState(1227) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16175,7 +16180,7 @@ func (s *RoleWithOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { localctx = NewRoleWithOptionsContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 128, CqlParserRULE_roleWithOptions) - p.SetState(1236) + p.SetState(1244) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16185,11 +16190,11 @@ func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { case CqlParserK_PASSWORD: p.EnterOuterAlt(localctx, 1) { - p.SetState(1220) + p.SetState(1228) p.KwPassword() } { - p.SetState(1221) + p.SetState(1229) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -16197,18 +16202,18 @@ func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { } } { - p.SetState(1222) + p.SetState(1230) p.StringLiteral() } case CqlParserK_LOGIN: p.EnterOuterAlt(localctx, 2) { - p.SetState(1224) + p.SetState(1232) p.KwLogin() } { - p.SetState(1225) + p.SetState(1233) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -16216,18 +16221,18 @@ func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { } } { - p.SetState(1226) + p.SetState(1234) p.BooleanLiteral() } case CqlParserK_SUPERUSER: p.EnterOuterAlt(localctx, 3) { - p.SetState(1228) + p.SetState(1236) p.KwSuperuser() } { - p.SetState(1229) + p.SetState(1237) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -16235,18 +16240,18 @@ func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { } } { - p.SetState(1230) + p.SetState(1238) p.BooleanLiteral() } case CqlParserK_OPTIONS: p.EnterOuterAlt(localctx, 4) { - p.SetState(1232) + p.SetState(1240) p.KwOptions() } { - p.SetState(1233) + p.SetState(1241) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -16254,7 +16259,7 @@ func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { } } { - p.SetState(1234) + p.SetState(1242) p.OptionHash() } @@ -16472,27 +16477,27 @@ func (p *CqlParser) AlterMaterializedView() (localctx IAlterMaterializedViewCont p.EnterOuterAlt(localctx, 1) { - p.SetState(1238) + p.SetState(1246) p.KwAlter() } { - p.SetState(1239) + p.SetState(1247) p.KwMaterialized() } { - p.SetState(1240) + p.SetState(1248) p.KwView() } - p.SetState(1244) + p.SetState(1252) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 { { - p.SetState(1241) + p.SetState(1249) p.Keyspace() } { - p.SetState(1242) + p.SetState(1250) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -16504,10 +16509,10 @@ func (p *CqlParser) AlterMaterializedView() (localctx IAlterMaterializedViewCont goto errorExit } { - p.SetState(1246) + p.SetState(1254) p.MaterializedView() } - p.SetState(1250) + p.SetState(1258) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16516,11 +16521,11 @@ func (p *CqlParser) AlterMaterializedView() (localctx IAlterMaterializedViewCont if _la == CqlParserK_WITH { { - p.SetState(1247) + p.SetState(1255) p.KwWith() } { - p.SetState(1248) + p.SetState(1256) p.TableOptions() } @@ -16679,14 +16684,14 @@ func (p *CqlParser) DropUser() (localctx IDropUserContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1252) + p.SetState(1260) p.KwDrop() } { - p.SetState(1253) + p.SetState(1261) p.KwUser() } - p.SetState(1255) + p.SetState(1263) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16695,13 +16700,13 @@ func (p *CqlParser) DropUser() (localctx IDropUserContext) { if _la == CqlParserK_IF { { - p.SetState(1254) + p.SetState(1262) p.IfExist() } } { - p.SetState(1257) + p.SetState(1265) p.User() } @@ -16880,14 +16885,14 @@ func (p *CqlParser) DropType() (localctx IDropTypeContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1259) + p.SetState(1267) p.KwDrop() } { - p.SetState(1260) + p.SetState(1268) p.KwType() } - p.SetState(1262) + p.SetState(1270) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -16896,21 +16901,21 @@ func (p *CqlParser) DropType() (localctx IDropTypeContext) { if _la == CqlParserK_IF { { - p.SetState(1261) + p.SetState(1269) p.IfExist() } } - p.SetState(1267) + p.SetState(1275) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 { { - p.SetState(1264) + p.SetState(1272) p.Keyspace() } { - p.SetState(1265) + p.SetState(1273) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -16922,7 +16927,7 @@ func (p *CqlParser) DropType() (localctx IDropTypeContext) { goto errorExit } { - p.SetState(1269) + p.SetState(1277) p.Type_() } @@ -17118,18 +17123,18 @@ func (p *CqlParser) DropMaterializedView() (localctx IDropMaterializedViewContex p.EnterOuterAlt(localctx, 1) { - p.SetState(1271) + p.SetState(1279) p.KwDrop() } { - p.SetState(1272) + p.SetState(1280) p.KwMaterialized() } { - p.SetState(1273) + p.SetState(1281) p.KwView() } - p.SetState(1275) + p.SetState(1283) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17138,21 +17143,21 @@ func (p *CqlParser) DropMaterializedView() (localctx IDropMaterializedViewContex if _la == CqlParserK_IF { { - p.SetState(1274) + p.SetState(1282) p.IfExist() } } - p.SetState(1280) + p.SetState(1288) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 { { - p.SetState(1277) + p.SetState(1285) p.Keyspace() } { - p.SetState(1278) + p.SetState(1286) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -17164,7 +17169,7 @@ func (p *CqlParser) DropMaterializedView() (localctx IDropMaterializedViewContex goto errorExit } { - p.SetState(1282) + p.SetState(1290) p.MaterializedView() } @@ -17343,14 +17348,14 @@ func (p *CqlParser) DropAggregate() (localctx IDropAggregateContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1284) + p.SetState(1292) p.KwDrop() } { - p.SetState(1285) + p.SetState(1293) p.KwAggregate() } - p.SetState(1287) + p.SetState(1295) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17359,21 +17364,21 @@ func (p *CqlParser) DropAggregate() (localctx IDropAggregateContext) { if _la == CqlParserK_IF { { - p.SetState(1286) + p.SetState(1294) p.IfExist() } } - p.SetState(1292) + p.SetState(1300) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 { { - p.SetState(1289) + p.SetState(1297) p.Keyspace() } { - p.SetState(1290) + p.SetState(1298) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -17385,7 +17390,7 @@ func (p *CqlParser) DropAggregate() (localctx IDropAggregateContext) { goto errorExit } { - p.SetState(1294) + p.SetState(1302) p.Aggregate() } @@ -17564,14 +17569,14 @@ func (p *CqlParser) DropFunction() (localctx IDropFunctionContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1296) + p.SetState(1304) p.KwDrop() } { - p.SetState(1297) + p.SetState(1305) p.KwFunction() } - p.SetState(1299) + p.SetState(1307) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17580,21 +17585,21 @@ func (p *CqlParser) DropFunction() (localctx IDropFunctionContext) { if _la == CqlParserK_IF { { - p.SetState(1298) + p.SetState(1306) p.IfExist() } } - p.SetState(1304) + p.SetState(1312) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 { { - p.SetState(1301) + p.SetState(1309) p.Keyspace() } { - p.SetState(1302) + p.SetState(1310) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -17606,7 +17611,7 @@ func (p *CqlParser) DropFunction() (localctx IDropFunctionContext) { goto errorExit } { - p.SetState(1306) + p.SetState(1314) p.Function_() } @@ -17797,14 +17802,14 @@ func (p *CqlParser) DropTrigger() (localctx IDropTriggerContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1308) + p.SetState(1316) p.KwDrop() } { - p.SetState(1309) + p.SetState(1317) p.KwTrigger() } - p.SetState(1311) + p.SetState(1319) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -17813,21 +17818,21 @@ func (p *CqlParser) DropTrigger() (localctx IDropTriggerContext) { if _la == CqlParserK_IF { { - p.SetState(1310) + p.SetState(1318) p.IfExist() } } { - p.SetState(1313) + p.SetState(1321) p.Trigger() } { - p.SetState(1314) + p.SetState(1322) p.KwOn() } { - p.SetState(1315) + p.SetState(1323) p.TableSpec() } @@ -17984,14 +17989,14 @@ func (p *CqlParser) DropRole() (localctx IDropRoleContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1317) + p.SetState(1325) p.KwDrop() } { - p.SetState(1318) + p.SetState(1326) p.KwRole() } - p.SetState(1320) + p.SetState(1328) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18000,13 +18005,13 @@ func (p *CqlParser) DropRole() (localctx IDropRoleContext) { if _la == CqlParserK_IF { { - p.SetState(1319) + p.SetState(1327) p.IfExist() } } { - p.SetState(1322) + p.SetState(1330) p.Role() } @@ -18163,14 +18168,14 @@ func (p *CqlParser) DropTable() (localctx IDropTableContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1324) + p.SetState(1332) p.KwDrop() } { - p.SetState(1325) + p.SetState(1333) p.KwTable() } - p.SetState(1327) + p.SetState(1335) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18179,13 +18184,13 @@ func (p *CqlParser) DropTable() (localctx IDropTableContext) { if _la == CqlParserK_IF { { - p.SetState(1326) + p.SetState(1334) p.IfExist() } } { - p.SetState(1329) + p.SetState(1337) p.TableSpec() } @@ -18342,14 +18347,14 @@ func (p *CqlParser) DropKeyspace() (localctx IDropKeyspaceContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1331) + p.SetState(1339) p.KwDrop() } { - p.SetState(1332) + p.SetState(1340) p.KwKeyspace() } - p.SetState(1334) + p.SetState(1342) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18358,13 +18363,13 @@ func (p *CqlParser) DropKeyspace() (localctx IDropKeyspaceContext) { if _la == CqlParserK_IF { { - p.SetState(1333) + p.SetState(1341) p.IfExist() } } { - p.SetState(1336) + p.SetState(1344) p.Keyspace() } @@ -18543,14 +18548,14 @@ func (p *CqlParser) DropIndex() (localctx IDropIndexContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1338) + p.SetState(1346) p.KwDrop() } { - p.SetState(1339) + p.SetState(1347) p.KwIndex() } - p.SetState(1341) + p.SetState(1349) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18559,21 +18564,21 @@ func (p *CqlParser) DropIndex() (localctx IDropIndexContext) { if _la == CqlParserK_IF { { - p.SetState(1340) + p.SetState(1348) p.IfExist() } } - p.SetState(1346) + p.SetState(1354) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 { { - p.SetState(1343) + p.SetState(1351) p.Keyspace() } { - p.SetState(1344) + p.SetState(1352) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -18585,7 +18590,7 @@ func (p *CqlParser) DropIndex() (localctx IDropIndexContext) { goto errorExit } { - p.SetState(1348) + p.SetState(1356) p.IndexName() } @@ -18810,14 +18815,14 @@ func (p *CqlParser) CreateTable() (localctx ICreateTableContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1350) + p.SetState(1358) p.KwCreate() } { - p.SetState(1351) + p.SetState(1359) p.KwTable() } - p.SetState(1353) + p.SetState(1361) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18826,28 +18831,28 @@ func (p *CqlParser) CreateTable() (localctx ICreateTableContext) { if _la == CqlParserK_IF { { - p.SetState(1352) + p.SetState(1360) p.IfNotExist() } } { - p.SetState(1355) + p.SetState(1363) p.TableSpec() } { - p.SetState(1356) + p.SetState(1364) p.SyntaxBracketLr() } { - p.SetState(1357) + p.SetState(1365) p.ColumnDefinitionList() } { - p.SetState(1358) + p.SetState(1366) p.SyntaxBracketRr() } - p.SetState(1360) + p.SetState(1368) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -18856,7 +18861,7 @@ func (p *CqlParser) CreateTable() (localctx ICreateTableContext) { if _la == CqlParserK_WITH { { - p.SetState(1359) + p.SetState(1367) p.WithElement() } @@ -18998,10 +19003,10 @@ func (p *CqlParser) WithElement() (localctx IWithElementContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1362) + p.SetState(1370) p.KwWith() } - p.SetState(1364) + p.SetState(1372) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19010,12 +19015,12 @@ func (p *CqlParser) WithElement() (localctx IWithElementContext) { if _la == CqlParserOBJECT_NAME { { - p.SetState(1363) + p.SetState(1371) p.TableOptions() } } - p.SetState(1367) + p.SetState(1375) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19024,7 +19029,7 @@ func (p *CqlParser) WithElement() (localctx IWithElementContext) { if _la == CqlParserK_CLUSTERING { { - p.SetState(1366) + p.SetState(1374) p.ClusteringOrder() } @@ -19234,26 +19239,26 @@ func (p *CqlParser) ClusteringOrder() (localctx IClusteringOrderContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1369) + p.SetState(1377) p.KwClustering() } { - p.SetState(1370) + p.SetState(1378) p.KwOrder() } { - p.SetState(1371) + p.SetState(1379) p.KwBy() } { - p.SetState(1372) + p.SetState(1380) p.SyntaxBracketLr() } { - p.SetState(1373) + p.SetState(1381) p.Column() } - p.SetState(1375) + p.SetState(1383) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19262,13 +19267,13 @@ func (p *CqlParser) ClusteringOrder() (localctx IClusteringOrderContext) { if _la == CqlParserK_ASC || _la == CqlParserK_DESC { { - p.SetState(1374) + p.SetState(1382) p.OrderDirection() } } { - p.SetState(1377) + p.SetState(1385) p.SyntaxBracketRr() } @@ -19443,10 +19448,10 @@ func (p *CqlParser) TableOptions() (localctx ITableOptionsContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1379) + p.SetState(1387) p.TableOptionItem() } - p.SetState(1385) + p.SetState(1393) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19458,16 +19463,16 @@ func (p *CqlParser) TableOptions() (localctx ITableOptionsContext) { for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(1380) + p.SetState(1388) p.KwAnd() } { - p.SetState(1381) + p.SetState(1389) p.TableOptionItem() } } - p.SetState(1387) + p.SetState(1395) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19615,7 +19620,7 @@ func (s *TableOptionItemContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) { localctx = NewTableOptionItemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 160, CqlParserRULE_tableOptionItem) - p.SetState(1396) + p.SetState(1404) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19625,11 +19630,11 @@ func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1388) + p.SetState(1396) p.TableOptionName() } { - p.SetState(1389) + p.SetState(1397) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -19637,18 +19642,18 @@ func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) { } } { - p.SetState(1390) + p.SetState(1398) p.TableOptionValue() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1392) + p.SetState(1400) p.TableOptionName() } { - p.SetState(1393) + p.SetState(1401) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -19656,7 +19661,7 @@ func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) { } } { - p.SetState(1394) + p.SetState(1402) p.OptionHash() } @@ -19752,7 +19757,7 @@ func (p *CqlParser) TableOptionName() (localctx ITableOptionNameContext) { p.EnterRule(localctx, 162, CqlParserRULE_tableOptionName) p.EnterOuterAlt(localctx, 1) { - p.SetState(1398) + p.SetState(1406) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -19875,7 +19880,7 @@ func (s *TableOptionValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) TableOptionValue() (localctx ITableOptionValueContext) { localctx = NewTableOptionValueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 164, CqlParserRULE_tableOptionValue) - p.SetState(1402) + p.SetState(1410) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -19885,14 +19890,14 @@ func (p *CqlParser) TableOptionValue() (localctx ITableOptionValueContext) { case CqlParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 1) { - p.SetState(1400) + p.SetState(1408) p.StringLiteral() } case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(1401) + p.SetState(1409) p.FloatLiteral() } @@ -20106,14 +20111,14 @@ func (p *CqlParser) OptionHash() (localctx IOptionHashContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1404) + p.SetState(1412) p.SyntaxBracketLc() } { - p.SetState(1405) + p.SetState(1413) p.OptionHashItem() } - p.SetState(1411) + p.SetState(1419) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20122,15 +20127,15 @@ func (p *CqlParser) OptionHash() (localctx IOptionHashContext) { for _la == CqlParserCOMMA { { - p.SetState(1406) + p.SetState(1414) p.SyntaxComma() } { - p.SetState(1407) + p.SetState(1415) p.OptionHashItem() } - p.SetState(1413) + p.SetState(1421) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20138,7 +20143,7 @@ func (p *CqlParser) OptionHash() (localctx IOptionHashContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1414) + p.SetState(1422) p.SyntaxBracketRc() } @@ -20264,11 +20269,11 @@ func (p *CqlParser) OptionHashItem() (localctx IOptionHashItemContext) { p.EnterRule(localctx, 168, CqlParserRULE_optionHashItem) p.EnterOuterAlt(localctx, 1) { - p.SetState(1416) + p.SetState(1424) p.OptionHashKey() } { - p.SetState(1417) + p.SetState(1425) p.Match(CqlParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -20276,7 +20281,7 @@ func (p *CqlParser) OptionHashItem() (localctx IOptionHashItemContext) { } } { - p.SetState(1418) + p.SetState(1426) p.OptionHashValue() } @@ -20380,7 +20385,7 @@ func (p *CqlParser) OptionHashKey() (localctx IOptionHashKeyContext) { p.EnterRule(localctx, 170, CqlParserRULE_optionHashKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1420) + p.SetState(1428) p.StringLiteral() } @@ -20499,7 +20504,7 @@ func (s *OptionHashValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) OptionHashValue() (localctx IOptionHashValueContext) { localctx = NewOptionHashValueContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 172, CqlParserRULE_optionHashValue) - p.SetState(1424) + p.SetState(1432) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20509,14 +20514,14 @@ func (p *CqlParser) OptionHashValue() (localctx IOptionHashValueContext) { case CqlParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 1) { - p.SetState(1422) + p.SetState(1430) p.StringLiteral() } case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(1423) + p.SetState(1431) p.FloatLiteral() } @@ -20715,11 +20720,11 @@ func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContex p.EnterOuterAlt(localctx, 1) { - p.SetState(1426) + p.SetState(1434) p.ColumnDefinition() } - p.SetState(1432) + p.SetState(1440) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20731,16 +20736,16 @@ func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContex for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { if _alt == 1 { { - p.SetState(1427) + p.SetState(1435) p.SyntaxComma() } { - p.SetState(1428) + p.SetState(1436) p.ColumnDefinition() } } - p.SetState(1434) + p.SetState(1442) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20750,7 +20755,7 @@ func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContex goto errorExit } } - p.SetState(1438) + p.SetState(1446) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20759,11 +20764,11 @@ func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContex if _la == CqlParserCOMMA { { - p.SetState(1435) + p.SetState(1443) p.SyntaxComma() } { - p.SetState(1436) + p.SetState(1444) p.PrimaryKeyElement() } @@ -20905,14 +20910,14 @@ func (p *CqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1440) + p.SetState(1448) p.Column() } { - p.SetState(1441) + p.SetState(1449) p.DataType() } - p.SetState(1443) + p.SetState(1451) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -20921,7 +20926,7 @@ func (p *CqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) { if _la == CqlParserK_PRIMARY { { - p.SetState(1442) + p.SetState(1450) p.PrimaryKeyColumn() } @@ -21044,11 +21049,11 @@ func (p *CqlParser) PrimaryKeyColumn() (localctx IPrimaryKeyColumnContext) { p.EnterRule(localctx, 178, CqlParserRULE_primaryKeyColumn) p.EnterOuterAlt(localctx, 1) { - p.SetState(1445) + p.SetState(1453) p.KwPrimary() } { - p.SetState(1446) + p.SetState(1454) p.KwKey() } @@ -21220,23 +21225,23 @@ func (p *CqlParser) PrimaryKeyElement() (localctx IPrimaryKeyElementContext) { p.EnterRule(localctx, 180, CqlParserRULE_primaryKeyElement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1448) + p.SetState(1456) p.KwPrimary() } { - p.SetState(1449) + p.SetState(1457) p.KwKey() } { - p.SetState(1450) + p.SetState(1458) p.SyntaxBracketLr() } { - p.SetState(1451) + p.SetState(1459) p.PrimaryKeyDefinition() } { - p.SetState(1452) + p.SetState(1460) p.SyntaxBracketRr() } @@ -21372,7 +21377,7 @@ func (s *PrimaryKeyDefinitionContext) ExitRule(listener antlr.ParseTreeListener) func (p *CqlParser) PrimaryKeyDefinition() (localctx IPrimaryKeyDefinitionContext) { localctx = NewPrimaryKeyDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 182, CqlParserRULE_primaryKeyDefinition) - p.SetState(1457) + p.SetState(1465) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -21382,21 +21387,21 @@ func (p *CqlParser) PrimaryKeyDefinition() (localctx IPrimaryKeyDefinitionContex case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1454) + p.SetState(1462) p.SinglePrimaryKey() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1455) + p.SetState(1463) p.CompoundKey() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1456) + p.SetState(1464) p.CompositeKey() } @@ -21504,7 +21509,7 @@ func (p *CqlParser) SinglePrimaryKey() (localctx ISinglePrimaryKeyContext) { p.EnterRule(localctx, 184, CqlParserRULE_singlePrimaryKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1459) + p.SetState(1467) p.Column() } @@ -21642,16 +21647,16 @@ func (p *CqlParser) CompoundKey() (localctx ICompoundKeyContext) { p.EnterRule(localctx, 186, CqlParserRULE_compoundKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1461) + p.SetState(1469) p.PartitionKey() } { - p.SetState(1462) + p.SetState(1470) p.SyntaxComma() } { - p.SetState(1463) + p.SetState(1471) p.ClusteringKeyList() } @@ -21823,24 +21828,24 @@ func (p *CqlParser) CompositeKey() (localctx ICompositeKeyContext) { p.EnterRule(localctx, 188, CqlParserRULE_compositeKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1465) + p.SetState(1473) p.SyntaxBracketLr() } { - p.SetState(1466) + p.SetState(1474) p.PartitionKeyList() } { - p.SetState(1467) + p.SetState(1475) p.SyntaxBracketRr() } { - p.SetState(1468) + p.SetState(1476) p.SyntaxComma() } { - p.SetState(1469) + p.SetState(1477) p.ClusteringKeyList() } @@ -22015,11 +22020,11 @@ func (p *CqlParser) PartitionKeyList() (localctx IPartitionKeyListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1471) + p.SetState(1479) p.PartitionKey() } - p.SetState(1477) + p.SetState(1485) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22028,15 +22033,15 @@ func (p *CqlParser) PartitionKeyList() (localctx IPartitionKeyListContext) { for _la == CqlParserCOMMA { { - p.SetState(1472) + p.SetState(1480) p.SyntaxComma() } { - p.SetState(1473) + p.SetState(1481) p.PartitionKey() } - p.SetState(1479) + p.SetState(1487) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22215,11 +22220,11 @@ func (p *CqlParser) ClusteringKeyList() (localctx IClusteringKeyListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1480) + p.SetState(1488) p.ClusteringKey() } - p.SetState(1486) + p.SetState(1494) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22228,15 +22233,15 @@ func (p *CqlParser) ClusteringKeyList() (localctx IClusteringKeyListContext) { for _la == CqlParserCOMMA { { - p.SetState(1481) + p.SetState(1489) p.SyntaxComma() } { - p.SetState(1482) + p.SetState(1490) p.ClusteringKey() } - p.SetState(1488) + p.SetState(1496) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22344,7 +22349,7 @@ func (p *CqlParser) PartitionKey() (localctx IPartitionKeyContext) { p.EnterRule(localctx, 194, CqlParserRULE_partitionKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1489) + p.SetState(1497) p.Column() } @@ -22448,7 +22453,7 @@ func (p *CqlParser) ClusteringKey() (localctx IClusteringKeyContext) { p.EnterRule(localctx, 196, CqlParserRULE_clusteringKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(1491) + p.SetState(1499) p.Column() } @@ -22569,11 +22574,11 @@ func (p *CqlParser) ApplyBatch() (localctx IApplyBatchContext) { p.EnterRule(localctx, 198, CqlParserRULE_applyBatch) p.EnterOuterAlt(localctx, 1) { - p.SetState(1493) + p.SetState(1501) p.KwApply() } { - p.SetState(1494) + p.SetState(1502) p.KwBatch() } @@ -22730,10 +22735,10 @@ func (p *CqlParser) BeginBatch() (localctx IBeginBatchContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1496) + p.SetState(1504) p.KwBegin() } - p.SetState(1498) + p.SetState(1506) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22742,16 +22747,16 @@ func (p *CqlParser) BeginBatch() (localctx IBeginBatchContext) { if _la == CqlParserK_LOGGED || _la == CqlParserK_UNLOGGED { { - p.SetState(1497) + p.SetState(1505) p.BatchType() } } { - p.SetState(1500) + p.SetState(1508) p.KwBatch() } - p.SetState(1502) + p.SetState(1510) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22760,7 +22765,7 @@ func (p *CqlParser) BeginBatch() (localctx IBeginBatchContext) { if _la == CqlParserK_USING { { - p.SetState(1501) + p.SetState(1509) p.UsingTimestampSpec() } @@ -22881,7 +22886,7 @@ func (s *BatchTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) BatchType() (localctx IBatchTypeContext) { localctx = NewBatchTypeContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 202, CqlParserRULE_batchType) - p.SetState(1506) + p.SetState(1514) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -22891,14 +22896,14 @@ func (p *CqlParser) BatchType() (localctx IBatchTypeContext) { case CqlParserK_LOGGED: p.EnterOuterAlt(localctx, 1) { - p.SetState(1504) + p.SetState(1512) p.KwLogged() } case CqlParserK_UNLOGGED: p.EnterOuterAlt(localctx, 2) { - p.SetState(1505) + p.SetState(1513) p.KwUnlogged() } @@ -23167,27 +23172,27 @@ func (p *CqlParser) AlterKeyspace() (localctx IAlterKeyspaceContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1508) + p.SetState(1516) p.KwAlter() } { - p.SetState(1509) + p.SetState(1517) p.KwKeyspace() } { - p.SetState(1510) + p.SetState(1518) p.Keyspace() } { - p.SetState(1511) + p.SetState(1519) p.KwWith() } { - p.SetState(1512) + p.SetState(1520) p.KwReplication() } { - p.SetState(1513) + p.SetState(1521) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -23195,18 +23200,18 @@ func (p *CqlParser) AlterKeyspace() (localctx IAlterKeyspaceContext) { } } { - p.SetState(1514) + p.SetState(1522) p.SyntaxBracketLc() } { - p.SetState(1515) + p.SetState(1523) p.ReplicationList() } { - p.SetState(1516) + p.SetState(1524) p.SyntaxBracketRc() } - p.SetState(1520) + p.SetState(1528) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23215,11 +23220,11 @@ func (p *CqlParser) AlterKeyspace() (localctx IAlterKeyspaceContext) { if _la == CqlParserK_AND { { - p.SetState(1517) + p.SetState(1525) p.KwAnd() } { - p.SetState(1518) + p.SetState(1526) p.DurableWrites() } @@ -23396,11 +23401,11 @@ func (p *CqlParser) ReplicationList() (localctx IReplicationListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1522) + p.SetState(1530) p.ReplicationListItem() } - p.SetState(1528) + p.SetState(1536) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23409,15 +23414,15 @@ func (p *CqlParser) ReplicationList() (localctx IReplicationListContext) { for _la == CqlParserCOMMA { { - p.SetState(1523) + p.SetState(1531) p.SyntaxComma() } { - p.SetState(1524) + p.SetState(1532) p.ReplicationListItem() } - p.SetState(1530) + p.SetState(1538) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23526,7 +23531,7 @@ func (s *ReplicationListItemContext) ExitRule(listener antlr.ParseTreeListener) func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) { localctx = NewReplicationListItemContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 208, CqlParserRULE_replicationListItem) - p.SetState(1537) + p.SetState(1545) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -23536,7 +23541,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1531) + p.SetState(1539) p.Match(CqlParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23544,7 +23549,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) } } { - p.SetState(1532) + p.SetState(1540) p.Match(CqlParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -23552,7 +23557,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) } } { - p.SetState(1533) + p.SetState(1541) p.Match(CqlParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23563,7 +23568,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1534) + p.SetState(1542) p.Match(CqlParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23571,7 +23576,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) } } { - p.SetState(1535) + p.SetState(1543) p.Match(CqlParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -23579,7 +23584,7 @@ func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) } } { - p.SetState(1536) + p.SetState(1544) p.Match(CqlParserDECIMAL_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -23713,11 +23718,11 @@ func (p *CqlParser) DurableWrites() (localctx IDurableWritesContext) { p.EnterRule(localctx, 210, CqlParserRULE_durableWrites) p.EnterOuterAlt(localctx, 1) { - p.SetState(1539) + p.SetState(1547) p.KwDurableWrites() } { - p.SetState(1540) + p.SetState(1548) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -23725,7 +23730,7 @@ func (p *CqlParser) DurableWrites() (localctx IDurableWritesContext) { } } { - p.SetState(1541) + p.SetState(1549) p.BooleanLiteral() } @@ -23846,11 +23851,11 @@ func (p *CqlParser) Use_() (localctx IUse_Context) { p.EnterRule(localctx, 212, CqlParserRULE_use_) p.EnterOuterAlt(localctx, 1) { - p.SetState(1543) + p.SetState(1551) p.KwUse() } { - p.SetState(1544) + p.SetState(1552) p.Keyspace() } @@ -23990,10 +23995,10 @@ func (p *CqlParser) Truncate() (localctx ITruncateContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1546) + p.SetState(1554) p.KwTruncate() } - p.SetState(1548) + p.SetState(1556) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24002,13 +24007,13 @@ func (p *CqlParser) Truncate() (localctx ITruncateContext) { if _la == CqlParserK_TABLE { { - p.SetState(1547) + p.SetState(1555) p.KwTable() } } { - p.SetState(1550) + p.SetState(1558) p.TableSpec() } @@ -24250,14 +24255,14 @@ func (p *CqlParser) CreateIndex() (localctx ICreateIndexContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1552) + p.SetState(1560) p.KwCreate() } { - p.SetState(1553) + p.SetState(1561) p.KwIndex() } - p.SetState(1555) + p.SetState(1563) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24266,12 +24271,12 @@ func (p *CqlParser) CreateIndex() (localctx ICreateIndexContext) { if _la == CqlParserK_IF { { - p.SetState(1554) + p.SetState(1562) p.IfNotExist() } } - p.SetState(1558) + p.SetState(1566) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24280,29 +24285,29 @@ func (p *CqlParser) CreateIndex() (localctx ICreateIndexContext) { if _la == CqlParserSTRING_LITERAL || _la == CqlParserOBJECT_NAME { { - p.SetState(1557) + p.SetState(1565) p.IndexName() } } { - p.SetState(1560) + p.SetState(1568) p.KwOn() } { - p.SetState(1561) + p.SetState(1569) p.TableSpec() } { - p.SetState(1562) + p.SetState(1570) p.SyntaxBracketLr() } { - p.SetState(1563) + p.SetState(1571) p.IndexColumnSpec() } { - p.SetState(1564) + p.SetState(1572) p.SyntaxBracketRr() } @@ -24409,7 +24414,7 @@ func (s *IndexNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) IndexName() (localctx IIndexNameContext) { localctx = NewIndexNameContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 218, CqlParserRULE_indexName) - p.SetState(1568) + p.SetState(1576) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24419,7 +24424,7 @@ func (p *CqlParser) IndexName() (localctx IIndexNameContext) { case CqlParserOBJECT_NAME: p.EnterOuterAlt(localctx, 1) { - p.SetState(1566) + p.SetState(1574) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -24430,7 +24435,7 @@ func (p *CqlParser) IndexName() (localctx IIndexNameContext) { case CqlParserSTRING_LITERAL: p.EnterOuterAlt(localctx, 2) { - p.SetState(1567) + p.SetState(1575) p.StringLiteral() } @@ -24588,7 +24593,7 @@ func (s *IndexColumnSpecContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) IndexColumnSpec() (localctx IIndexColumnSpecContext) { localctx = NewIndexColumnSpecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 220, CqlParserRULE_indexColumnSpec) - p.SetState(1574) + p.SetState(1582) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -24598,28 +24603,28 @@ func (p *CqlParser) IndexColumnSpec() (localctx IIndexColumnSpecContext) { case CqlParserDQUOTE, CqlParserK_KEY, CqlParserK_TYPE, CqlParserOBJECT_NAME: p.EnterOuterAlt(localctx, 1) { - p.SetState(1570) + p.SetState(1578) p.Column() } case CqlParserK_KEYS: p.EnterOuterAlt(localctx, 2) { - p.SetState(1571) + p.SetState(1579) p.IndexKeysSpec() } case CqlParserK_ENTRIES: p.EnterOuterAlt(localctx, 3) { - p.SetState(1572) + p.SetState(1580) p.IndexEntriesSSpec() } case CqlParserK_FULL: p.EnterOuterAlt(localctx, 4) { - p.SetState(1573) + p.SetState(1581) p.IndexFullSpec() } @@ -24767,15 +24772,15 @@ func (p *CqlParser) IndexKeysSpec() (localctx IIndexKeysSpecContext) { p.EnterRule(localctx, 222, CqlParserRULE_indexKeysSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1576) + p.SetState(1584) p.KwKeys() } { - p.SetState(1577) + p.SetState(1585) p.SyntaxBracketLr() } { - p.SetState(1578) + p.SetState(1586) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -24783,7 +24788,7 @@ func (p *CqlParser) IndexKeysSpec() (localctx IIndexKeysSpecContext) { } } { - p.SetState(1579) + p.SetState(1587) p.SyntaxBracketRr() } @@ -24926,15 +24931,15 @@ func (p *CqlParser) IndexEntriesSSpec() (localctx IIndexEntriesSSpecContext) { p.EnterRule(localctx, 224, CqlParserRULE_indexEntriesSSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1581) + p.SetState(1589) p.KwEntries() } { - p.SetState(1582) + p.SetState(1590) p.SyntaxBracketLr() } { - p.SetState(1583) + p.SetState(1591) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -24942,7 +24947,7 @@ func (p *CqlParser) IndexEntriesSSpec() (localctx IIndexEntriesSSpecContext) { } } { - p.SetState(1584) + p.SetState(1592) p.SyntaxBracketRr() } @@ -25085,15 +25090,15 @@ func (p *CqlParser) IndexFullSpec() (localctx IIndexFullSpecContext) { p.EnterRule(localctx, 226, CqlParserRULE_indexFullSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1586) + p.SetState(1594) p.KwFull() } { - p.SetState(1587) + p.SetState(1595) p.SyntaxBracketLr() } { - p.SetState(1588) + p.SetState(1596) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -25101,7 +25106,7 @@ func (p *CqlParser) IndexFullSpec() (localctx IIndexFullSpecContext) { } } { - p.SetState(1589) + p.SetState(1597) p.SyntaxBracketRr() } @@ -25342,7 +25347,7 @@ func (p *CqlParser) Delete_() (localctx IDelete_Context) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1592) + p.SetState(1600) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25351,16 +25356,16 @@ func (p *CqlParser) Delete_() (localctx IDelete_Context) { if _la == CqlParserK_BEGIN { { - p.SetState(1591) + p.SetState(1599) p.BeginBatch() } } { - p.SetState(1594) + p.SetState(1602) p.KwDelete() } - p.SetState(1596) + p.SetState(1604) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25369,16 +25374,16 @@ func (p *CqlParser) Delete_() (localctx IDelete_Context) { if _la == CqlParserDQUOTE || _la == CqlParserK_KEY || _la == CqlParserK_TYPE || _la == CqlParserOBJECT_NAME { { - p.SetState(1595) + p.SetState(1603) p.DeleteColumnList() } } { - p.SetState(1598) + p.SetState(1606) p.FromSpec() } - p.SetState(1600) + p.SetState(1608) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25387,21 +25392,21 @@ func (p *CqlParser) Delete_() (localctx IDelete_Context) { if _la == CqlParserK_USING { { - p.SetState(1599) + p.SetState(1607) p.UsingTimestampSpec() } } { - p.SetState(1602) + p.SetState(1610) p.WhereSpec() } - p.SetState(1605) + p.SetState(1613) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) == 1 { { - p.SetState(1603) + p.SetState(1611) p.IfExist() } @@ -25409,19 +25414,19 @@ func (p *CqlParser) Delete_() (localctx IDelete_Context) { goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) == 2 { { - p.SetState(1604) + p.SetState(1612) p.IfSpec() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(1608) + p.SetState(1616) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 114, p.GetParserRuleContext()) == 1 { { - p.SetState(1607) + p.SetState(1615) p.StatementSeparator() } @@ -25600,11 +25605,11 @@ func (p *CqlParser) DeleteColumnList() (localctx IDeleteColumnListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1610) + p.SetState(1618) p.DeleteColumnItem() } - p.SetState(1616) + p.SetState(1624) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25613,15 +25618,15 @@ func (p *CqlParser) DeleteColumnList() (localctx IDeleteColumnListContext) { for _la == CqlParserCOMMA { { - p.SetState(1611) + p.SetState(1619) p.SyntaxComma() } { - p.SetState(1612) + p.SetState(1620) p.DeleteColumnItem() } - p.SetState(1618) + p.SetState(1626) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25763,7 +25768,7 @@ func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { p.EnterRule(localctx, 232, CqlParserRULE_deleteColumnItem) var _la int - p.SetState(1627) + p.SetState(1635) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25773,10 +25778,10 @@ func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1619) + p.SetState(1627) p.SelectColumn() } - p.SetState(1621) + p.SetState(1629) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25785,7 +25790,7 @@ func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { if _la == CqlParserK_AS { { - p.SetState(1620) + p.SetState(1628) p.AsSpec() } @@ -25794,10 +25799,10 @@ func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1623) + p.SetState(1631) p.SelectIndex() } - p.SetState(1625) + p.SetState(1633) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -25806,7 +25811,7 @@ func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { if _la == CqlParserK_AS { { - p.SetState(1624) + p.SetState(1632) p.AsSpec() } @@ -26070,7 +26075,7 @@ func (p *CqlParser) Update() (localctx IUpdateContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1630) + p.SetState(1638) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26079,20 +26084,20 @@ func (p *CqlParser) Update() (localctx IUpdateContext) { if _la == CqlParserK_BEGIN { { - p.SetState(1629) + p.SetState(1637) p.BeginBatch() } } { - p.SetState(1632) + p.SetState(1640) p.KwUpdate() } { - p.SetState(1633) + p.SetState(1641) p.TableSpec() } - p.SetState(1635) + p.SetState(1643) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26101,29 +26106,29 @@ func (p *CqlParser) Update() (localctx IUpdateContext) { if _la == CqlParserK_USING { { - p.SetState(1634) + p.SetState(1642) p.UsingTtlTimestamp() } } { - p.SetState(1637) + p.SetState(1645) p.KwSet() } { - p.SetState(1638) + p.SetState(1646) p.Assignments() } { - p.SetState(1639) + p.SetState(1647) p.WhereSpec() } - p.SetState(1642) + p.SetState(1650) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) == 1 { { - p.SetState(1640) + p.SetState(1648) p.IfExist() } @@ -26131,19 +26136,19 @@ func (p *CqlParser) Update() (localctx IUpdateContext) { goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) == 2 { { - p.SetState(1641) + p.SetState(1649) p.IfSpec() } } else if p.HasError() { // JIM goto errorExit } - p.SetState(1645) + p.SetState(1653) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) == 1 { { - p.SetState(1644) + p.SetState(1652) p.StatementSeparator() } @@ -26268,11 +26273,11 @@ func (p *CqlParser) IfSpec() (localctx IIfSpecContext) { p.EnterRule(localctx, 236, CqlParserRULE_ifSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1647) + p.SetState(1655) p.KwIf() } { - p.SetState(1648) + p.SetState(1656) p.IfConditionList() } @@ -26447,11 +26452,11 @@ func (p *CqlParser) IfConditionList() (localctx IIfConditionListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1650) + p.SetState(1658) p.IfCondition() } - p.SetState(1656) + p.SetState(1664) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26460,15 +26465,15 @@ func (p *CqlParser) IfConditionList() (localctx IIfConditionListContext) { for _la == CqlParserK_AND { { - p.SetState(1651) + p.SetState(1659) p.KwAnd() } { - p.SetState(1652) + p.SetState(1660) p.IfCondition() } - p.SetState(1658) + p.SetState(1666) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26586,7 +26591,7 @@ func (p *CqlParser) IfCondition() (localctx IIfConditionContext) { p.EnterRule(localctx, 240, CqlParserRULE_ifCondition) p.EnterOuterAlt(localctx, 1) { - p.SetState(1659) + p.SetState(1667) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -26594,7 +26599,7 @@ func (p *CqlParser) IfCondition() (localctx IIfConditionContext) { } } { - p.SetState(1660) + p.SetState(1668) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -26602,7 +26607,7 @@ func (p *CqlParser) IfCondition() (localctx IIfConditionContext) { } } { - p.SetState(1661) + p.SetState(1669) p.Constant() } @@ -26777,11 +26782,11 @@ func (p *CqlParser) Assignments() (localctx IAssignmentsContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1663) + p.SetState(1671) p.AssignmentElement() } - p.SetState(1669) + p.SetState(1677) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26790,15 +26795,15 @@ func (p *CqlParser) Assignments() (localctx IAssignmentsContext) { for _la == CqlParserCOMMA { { - p.SetState(1664) + p.SetState(1672) p.SyntaxComma() } { - p.SetState(1665) + p.SetState(1673) p.AssignmentElement() } - p.SetState(1671) + p.SetState(1679) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26955,7 +26960,7 @@ func (s *AssignmentElementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) AssignmentElement() (localctx IAssignmentElementContext) { localctx = NewAssignmentElementContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 244, CqlParserRULE_assignmentElement) - p.SetState(1676) + p.SetState(1684) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -26965,28 +26970,28 @@ func (p *CqlParser) AssignmentElement() (localctx IAssignmentElementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1672) + p.SetState(1680) p.AssignmentAppend() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1673) + p.SetState(1681) p.AssignmentPrepend() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1674) + p.SetState(1682) p.AssignmentEquals() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1675) + p.SetState(1683) p.AssignmentIndex() } @@ -27116,11 +27121,11 @@ func (p *CqlParser) AssignmentEquals() (localctx IAssignmentEqualsContext) { p.EnterRule(localctx, 246, CqlParserRULE_assignmentEquals) p.EnterOuterAlt(localctx, 1) { - p.SetState(1678) + p.SetState(1686) p.Column() } { - p.SetState(1679) + p.SetState(1687) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -27128,7 +27133,7 @@ func (p *CqlParser) AssignmentEquals() (localctx IAssignmentEqualsContext) { } } { - p.SetState(1680) + p.SetState(1688) p.ValueAny() } @@ -27276,11 +27281,11 @@ func (p *CqlParser) AssignmentPrepend() (localctx IAssignmentPrependContext) { p.EnterRule(localctx, 248, CqlParserRULE_assignmentPrepend) p.EnterOuterAlt(localctx, 1) { - p.SetState(1682) + p.SetState(1690) p.Column() } { - p.SetState(1683) + p.SetState(1691) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -27288,15 +27293,15 @@ func (p *CqlParser) AssignmentPrepend() (localctx IAssignmentPrependContext) { } } { - p.SetState(1684) + p.SetState(1692) p.ValueAny() } { - p.SetState(1685) + p.SetState(1693) p.ArithmeticOperator() } { - p.SetState(1686) + p.SetState(1694) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -27448,11 +27453,11 @@ func (p *CqlParser) AssignmentAppend() (localctx IAssignmentAppendContext) { p.EnterRule(localctx, 250, CqlParserRULE_assignmentAppend) p.EnterOuterAlt(localctx, 1) { - p.SetState(1688) + p.SetState(1696) p.Column() } { - p.SetState(1689) + p.SetState(1697) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -27460,7 +27465,7 @@ func (p *CqlParser) AssignmentAppend() (localctx IAssignmentAppendContext) { } } { - p.SetState(1690) + p.SetState(1698) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -27468,11 +27473,11 @@ func (p *CqlParser) AssignmentAppend() (localctx IAssignmentAppendContext) { } } { - p.SetState(1691) + p.SetState(1699) p.ArithmeticOperator() } { - p.SetState(1692) + p.SetState(1700) p.ValueAny() } @@ -27610,15 +27615,15 @@ func (p *CqlParser) IndexOrKeyAccess() (localctx IIndexOrKeyAccessContext) { p.EnterRule(localctx, 252, CqlParserRULE_indexOrKeyAccess) p.EnterOuterAlt(localctx, 1) { - p.SetState(1694) + p.SetState(1702) p.SyntaxBracketLs() } { - p.SetState(1695) + p.SetState(1703) p.Constant() } { - p.SetState(1696) + p.SetState(1704) p.SyntaxBracketRs() } @@ -27761,15 +27766,15 @@ func (p *CqlParser) AssignmentIndex() (localctx IAssignmentIndexContext) { p.EnterRule(localctx, 254, CqlParserRULE_assignmentIndex) p.EnterOuterAlt(localctx, 1) { - p.SetState(1698) + p.SetState(1706) p.Column() } { - p.SetState(1699) + p.SetState(1707) p.IndexOrKeyAccess() } { - p.SetState(1700) + p.SetState(1708) p.Match(CqlParserOPERATOR_EQ) if p.HasError() { // Recognition error - abort rule @@ -27777,7 +27782,7 @@ func (p *CqlParser) AssignmentIndex() (localctx IAssignmentIndexContext) { } } { - p.SetState(1701) + p.SetState(1709) p.Constant() } @@ -27986,10 +27991,10 @@ func (p *CqlParser) ValueSet() (localctx IValueSetContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1703) + p.SetState(1711) p.SyntaxBracketLc() } - p.SetState(1713) + p.SetState(1721) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -27998,10 +28003,10 @@ func (p *CqlParser) ValueSet() (localctx IValueSetContext) { if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&127405909868545) != 0) { { - p.SetState(1704) + p.SetState(1712) p.Constant() } - p.SetState(1710) + p.SetState(1718) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28010,15 +28015,15 @@ func (p *CqlParser) ValueSet() (localctx IValueSetContext) { for _la == CqlParserCOMMA { { - p.SetState(1705) + p.SetState(1713) p.SyntaxComma() } { - p.SetState(1706) + p.SetState(1714) p.Constant() } - p.SetState(1712) + p.SetState(1720) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28028,7 +28033,7 @@ func (p *CqlParser) ValueSet() (localctx IValueSetContext) { } { - p.SetState(1715) + p.SetState(1723) p.SyntaxBracketRc() } @@ -28280,24 +28285,24 @@ func (p *CqlParser) ValueMap() (localctx IValueMapContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1717) + p.SetState(1725) p.SyntaxBracketLc() } { - p.SetState(1718) + p.SetState(1726) p.Constant() } { - p.SetState(1719) + p.SetState(1727) p.SyntaxColon() } { - p.SetState(1720) + p.SetState(1728) p.Constant() } - p.SetState(1729) + p.SetState(1737) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28306,23 +28311,23 @@ func (p *CqlParser) ValueMap() (localctx IValueMapContext) { for _la == CqlParserCOMMA { { - p.SetState(1722) + p.SetState(1730) p.SyntaxComma() } { - p.SetState(1723) + p.SetState(1731) p.Constant() } { - p.SetState(1724) + p.SetState(1732) p.SyntaxColon() } { - p.SetState(1725) + p.SetState(1733) p.Constant() } - p.SetState(1731) + p.SetState(1739) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28330,7 +28335,7 @@ func (p *CqlParser) ValueMap() (localctx IValueMapContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(1732) + p.SetState(1740) p.SyntaxBracketRc() } @@ -28539,10 +28544,10 @@ func (p *CqlParser) ValueList() (localctx IValueListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1734) + p.SetState(1742) p.SyntaxBracketLs() } - p.SetState(1744) + p.SetState(1752) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28551,10 +28556,10 @@ func (p *CqlParser) ValueList() (localctx IValueListContext) { if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&127405909868545) != 0) { { - p.SetState(1735) + p.SetState(1743) p.Constant() } - p.SetState(1741) + p.SetState(1749) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28563,15 +28568,15 @@ func (p *CqlParser) ValueList() (localctx IValueListContext) { for _la == CqlParserCOMMA { { - p.SetState(1736) + p.SetState(1744) p.SyntaxComma() } { - p.SetState(1737) + p.SetState(1745) p.Constant() } - p.SetState(1743) + p.SetState(1751) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28581,7 +28586,7 @@ func (p *CqlParser) ValueList() (localctx IValueListContext) { } { - p.SetState(1746) + p.SetState(1754) p.SyntaxBracketRs() } @@ -28680,7 +28685,7 @@ func (p *CqlParser) ArithmeticOperator() (localctx IArithmeticOperatorContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1748) + p.SetState(1756) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { @@ -28896,15 +28901,15 @@ func (p *CqlParser) AssignmentTuple() (localctx IAssignmentTupleContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1750) + p.SetState(1758) p.SyntaxBracketLr() } { - p.SetState(1751) + p.SetState(1759) p.Expression() } - p.SetState(1757) + p.SetState(1765) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28913,15 +28918,15 @@ func (p *CqlParser) AssignmentTuple() (localctx IAssignmentTupleContext) { for _la == CqlParserCOMMA { { - p.SetState(1752) + p.SetState(1760) p.SyntaxComma() } { - p.SetState(1753) + p.SetState(1761) p.Expression() } - p.SetState(1759) + p.SetState(1767) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -28930,7 +28935,7 @@ func (p *CqlParser) AssignmentTuple() (localctx IAssignmentTupleContext) { } { - p.SetState(1760) + p.SetState(1768) p.SyntaxBracketRr() } @@ -29171,7 +29176,7 @@ func (p *CqlParser) Insert() (localctx IInsertContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1763) + p.SetState(1771) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29180,24 +29185,24 @@ func (p *CqlParser) Insert() (localctx IInsertContext) { if _la == CqlParserK_BEGIN { { - p.SetState(1762) + p.SetState(1770) p.BeginBatch() } } { - p.SetState(1765) + p.SetState(1773) p.KwInsert() } { - p.SetState(1766) + p.SetState(1774) p.KwInto() } { - p.SetState(1767) + p.SetState(1775) p.TableSpec() } - p.SetState(1769) + p.SetState(1777) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29206,16 +29211,16 @@ func (p *CqlParser) Insert() (localctx IInsertContext) { if _la == CqlParserLR_BRACKET { { - p.SetState(1768) + p.SetState(1776) p.InsertColumnSpec() } } { - p.SetState(1771) + p.SetState(1779) p.InsertValuesSpec() } - p.SetState(1773) + p.SetState(1781) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29224,12 +29229,12 @@ func (p *CqlParser) Insert() (localctx IInsertContext) { if _la == CqlParserK_IF { { - p.SetState(1772) + p.SetState(1780) p.IfNotExist() } } - p.SetState(1776) + p.SetState(1784) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29238,17 +29243,17 @@ func (p *CqlParser) Insert() (localctx IInsertContext) { if _la == CqlParserK_USING { { - p.SetState(1775) + p.SetState(1783) p.UsingTtlTimestamp() } } - p.SetState(1779) + p.SetState(1787) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 136, p.GetParserRuleContext()) == 1 { { - p.SetState(1778) + p.SetState(1786) p.StatementSeparator() } @@ -29405,7 +29410,7 @@ func (s *UsingTtlTimestampContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) UsingTtlTimestamp() (localctx IUsingTtlTimestampContext) { localctx = NewUsingTtlTimestampContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 268, CqlParserRULE_usingTtlTimestamp) - p.SetState(1797) + p.SetState(1805) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29415,60 +29420,60 @@ func (p *CqlParser) UsingTtlTimestamp() (localctx IUsingTtlTimestampContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1781) + p.SetState(1789) p.KwUsing() } { - p.SetState(1782) + p.SetState(1790) p.Ttl() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1784) + p.SetState(1792) p.KwUsing() } { - p.SetState(1785) + p.SetState(1793) p.Ttl() } { - p.SetState(1786) + p.SetState(1794) p.KwAnd() } { - p.SetState(1787) + p.SetState(1795) p.Timestamp() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1789) + p.SetState(1797) p.KwUsing() } { - p.SetState(1790) + p.SetState(1798) p.Timestamp() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1792) + p.SetState(1800) p.KwUsing() } { - p.SetState(1793) + p.SetState(1801) p.Timestamp() } { - p.SetState(1794) + p.SetState(1802) p.KwAnd() } { - p.SetState(1795) + p.SetState(1803) p.Ttl() } @@ -29610,10 +29615,10 @@ func (p *CqlParser) Timestamp() (localctx ITimestampContext) { p.EnterRule(localctx, 270, CqlParserRULE_timestamp) p.EnterOuterAlt(localctx, 1) { - p.SetState(1799) + p.SetState(1807) p.KwTimestamp() } - p.SetState(1802) + p.SetState(1810) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -29622,13 +29627,13 @@ func (p *CqlParser) Timestamp() (localctx ITimestampContext) { switch p.GetTokenStream().LA(1) { case CqlParserQUESTION_MARK, CqlParserNAMED_MARK: { - p.SetState(1800) + p.SetState(1808) p.Marker() } case CqlParserDECIMAL_LITERAL: { - p.SetState(1801) + p.SetState(1809) p.DecimalLiteral() } @@ -29754,11 +29759,11 @@ func (p *CqlParser) Ttl() (localctx ITtlContext) { p.EnterRule(localctx, 272, CqlParserRULE_ttl) p.EnterOuterAlt(localctx, 1) { - p.SetState(1804) + p.SetState(1812) p.KwTtl() } { - p.SetState(1805) + p.SetState(1813) p.DecimalLiteral() } @@ -29879,11 +29884,11 @@ func (p *CqlParser) UsingTimestampSpec() (localctx IUsingTimestampSpecContext) { p.EnterRule(localctx, 274, CqlParserRULE_usingTimestampSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1807) + p.SetState(1815) p.KwUsing() } { - p.SetState(1808) + p.SetState(1816) p.Timestamp() } @@ -30021,15 +30026,15 @@ func (p *CqlParser) IfNotExist() (localctx IIfNotExistContext) { p.EnterRule(localctx, 276, CqlParserRULE_ifNotExist) p.EnterOuterAlt(localctx, 1) { - p.SetState(1810) + p.SetState(1818) p.KwIf() } { - p.SetState(1811) + p.SetState(1819) p.KwNot() } { - p.SetState(1812) + p.SetState(1820) p.KwExists() } @@ -30150,11 +30155,11 @@ func (p *CqlParser) IfExist() (localctx IIfExistContext) { p.EnterRule(localctx, 278, CqlParserRULE_ifExist) p.EnterOuterAlt(localctx, 1) { - p.SetState(1814) + p.SetState(1822) p.KwIf() } { - p.SetState(1815) + p.SetState(1823) p.KwExists() } @@ -30317,7 +30322,7 @@ func (s *InsertValuesSpecContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) { localctx = NewInsertValuesSpecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 280, CqlParserRULE_insertValuesSpec) - p.SetState(1825) + p.SetState(1833) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30327,11 +30332,11 @@ func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) { case CqlParserK_VALUES: p.EnterOuterAlt(localctx, 1) { - p.SetState(1817) + p.SetState(1825) p.KwValues() } { - p.SetState(1818) + p.SetState(1826) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -30339,11 +30344,11 @@ func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) { } } { - p.SetState(1819) + p.SetState(1827) p.ValueListSpec() } { - p.SetState(1820) + p.SetState(1828) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -30354,11 +30359,11 @@ func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) { case CqlParserK_JSON: p.EnterOuterAlt(localctx, 2) { - p.SetState(1822) + p.SetState(1830) p.KwJson() } { - p.SetState(1823) + p.SetState(1831) p.Constant() } @@ -30477,7 +30482,7 @@ func (p *CqlParser) InsertColumnSpec() (localctx IInsertColumnSpecContext) { p.EnterRule(localctx, 282, CqlParserRULE_insertColumnSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1827) + p.SetState(1835) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -30485,11 +30490,11 @@ func (p *CqlParser) InsertColumnSpec() (localctx IInsertColumnSpecContext) { } } { - p.SetState(1828) + p.SetState(1836) p.ColumnList() } { - p.SetState(1829) + p.SetState(1837) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -30668,10 +30673,10 @@ func (p *CqlParser) ColumnList() (localctx IColumnListContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1831) + p.SetState(1839) p.Column() } - p.SetState(1837) + p.SetState(1845) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30680,15 +30685,15 @@ func (p *CqlParser) ColumnList() (localctx IColumnListContext) { for _la == CqlParserCOMMA { { - p.SetState(1832) + p.SetState(1840) p.SyntaxComma() } { - p.SetState(1833) + p.SetState(1841) p.Column() } - p.SetState(1839) + p.SetState(1847) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30867,10 +30872,10 @@ func (p *CqlParser) ValueListSpec() (localctx IValueListSpecContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1840) + p.SetState(1848) p.ValueAny() } - p.SetState(1846) + p.SetState(1854) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -30879,15 +30884,15 @@ func (p *CqlParser) ValueListSpec() (localctx IValueListSpecContext) { for _la == CqlParserCOMMA { { - p.SetState(1841) + p.SetState(1849) p.SyntaxComma() } { - p.SetState(1842) + p.SetState(1850) p.ValueAny() } - p.SetState(1848) + p.SetState(1856) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31078,7 +31083,7 @@ func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Expression() (localctx IExpressionContext) { localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 288, CqlParserRULE_expression) - p.SetState(1855) + p.SetState(1863) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31088,42 +31093,42 @@ func (p *CqlParser) Expression() (localctx IExpressionContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1849) + p.SetState(1857) p.Constant() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1850) + p.SetState(1858) p.FunctionCall() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1851) + p.SetState(1859) p.ValueMap() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1852) + p.SetState(1860) p.ValueSet() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1853) + p.SetState(1861) p.ValueList() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1854) + p.SetState(1862) p.AssignmentTuple() } @@ -31403,10 +31408,10 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1857) + p.SetState(1865) p.KwSelect() } - p.SetState(1859) + p.SetState(1867) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31415,12 +31420,12 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_DISTINCT { { - p.SetState(1858) + p.SetState(1866) p.DistinctSpec() } } - p.SetState(1862) + p.SetState(1870) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31429,20 +31434,20 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_JSON { { - p.SetState(1861) + p.SetState(1869) p.KwJson() } } { - p.SetState(1864) + p.SetState(1872) p.SelectElements() } { - p.SetState(1865) + p.SetState(1873) p.FromSpec() } - p.SetState(1867) + p.SetState(1875) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31451,12 +31456,12 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_WHERE { { - p.SetState(1866) + p.SetState(1874) p.WhereSpec() } } - p.SetState(1870) + p.SetState(1878) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31465,12 +31470,12 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_GROUP { { - p.SetState(1869) + p.SetState(1877) p.GroupSpec() } } - p.SetState(1873) + p.SetState(1881) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31479,12 +31484,12 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_ORDER { { - p.SetState(1872) + p.SetState(1880) p.OrderSpec() } } - p.SetState(1876) + p.SetState(1884) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31493,12 +31498,12 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_LIMIT { { - p.SetState(1875) + p.SetState(1883) p.LimitSpec() } } - p.SetState(1879) + p.SetState(1887) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31507,17 +31512,17 @@ func (p *CqlParser) Select_() (localctx ISelect_Context) { if _la == CqlParserK_ALLOW { { - p.SetState(1878) + p.SetState(1886) p.AllowFilteringSpec() } } - p.SetState(1882) + p.SetState(1890) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 150, p.GetParserRuleContext()) == 1 { { - p.SetState(1881) + p.SetState(1889) p.StatementSeparator() } @@ -31642,11 +31647,11 @@ func (p *CqlParser) AllowFilteringSpec() (localctx IAllowFilteringSpecContext) { p.EnterRule(localctx, 292, CqlParserRULE_allowFilteringSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1884) + p.SetState(1892) p.KwAllow() } { - p.SetState(1885) + p.SetState(1893) p.KwFiltering() } @@ -31784,10 +31789,10 @@ func (p *CqlParser) LimitSpec() (localctx ILimitSpecContext) { p.EnterRule(localctx, 294, CqlParserRULE_limitSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1887) + p.SetState(1895) p.KwLimit() } - p.SetState(1890) + p.SetState(1898) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -31796,13 +31801,13 @@ func (p *CqlParser) LimitSpec() (localctx ILimitSpecContext) { switch p.GetTokenStream().LA(1) { case CqlParserQUESTION_MARK, CqlParserNAMED_MARK: { - p.SetState(1888) + p.SetState(1896) p.Marker() } case CqlParserDECIMAL_LITERAL: { - p.SetState(1889) + p.SetState(1897) p.DecimalLiteral() } @@ -31899,7 +31904,7 @@ func (p *CqlParser) KwLike() (localctx IKwLikeContext) { p.EnterRule(localctx, 296, CqlParserRULE_kwLike) p.EnterOuterAlt(localctx, 1) { - p.SetState(1892) + p.SetState(1900) p.Match(CqlParserK_LIKE) if p.HasError() { // Recognition error - abort rule @@ -32028,16 +32033,16 @@ func (p *CqlParser) TableSpec() (localctx ITableSpecContext) { localctx = NewTableSpecContext(p, p.GetParserRuleContext(), p.GetState()) p.EnterRule(localctx, 298, CqlParserRULE_tableSpec) p.EnterOuterAlt(localctx, 1) - p.SetState(1897) + p.SetState(1905) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 152, p.GetParserRuleContext()) == 1 { { - p.SetState(1894) + p.SetState(1902) p.Keyspace() } { - p.SetState(1895) + p.SetState(1903) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -32049,7 +32054,7 @@ func (p *CqlParser) TableSpec() (localctx ITableSpecContext) { goto errorExit } { - p.SetState(1899) + p.SetState(1907) p.Table() } @@ -32170,11 +32175,11 @@ func (p *CqlParser) FromSpec() (localctx IFromSpecContext) { p.EnterRule(localctx, 300, CqlParserRULE_fromSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1901) + p.SetState(1909) p.KwFrom() } { - p.SetState(1902) + p.SetState(1910) p.TableSpec() } @@ -32383,18 +32388,18 @@ func (p *CqlParser) OrderSpec() (localctx IOrderSpecContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1904) + p.SetState(1912) p.KwOrder() } { - p.SetState(1905) + p.SetState(1913) p.KwBy() } { - p.SetState(1906) + p.SetState(1914) p.OrderSpecElement() } - p.SetState(1912) + p.SetState(1920) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32403,15 +32408,15 @@ func (p *CqlParser) OrderSpec() (localctx IOrderSpecContext) { for _la == CqlParserCOMMA { { - p.SetState(1907) + p.SetState(1915) p.SyntaxComma() } { - p.SetState(1908) + p.SetState(1916) p.OrderSpecElement() } - p.SetState(1914) + p.SetState(1922) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32541,19 +32546,19 @@ func (p *CqlParser) OrderSpecElement() (localctx IOrderSpecElementContext) { p.EnterRule(localctx, 304, CqlParserRULE_orderSpecElement) p.EnterOuterAlt(localctx, 1) { - p.SetState(1915) + p.SetState(1923) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(1918) + p.SetState(1926) p.GetErrorHandler().Sync(p) if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) == 1 { { - p.SetState(1916) + p.SetState(1924) p.KwAsc() } @@ -32561,7 +32566,7 @@ func (p *CqlParser) OrderSpecElement() (localctx IOrderSpecElementContext) { goto errorExit } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) == 2 { { - p.SetState(1917) + p.SetState(1925) p.KwDesc() } @@ -32686,11 +32691,11 @@ func (p *CqlParser) WhereSpec() (localctx IWhereSpecContext) { p.EnterRule(localctx, 306, CqlParserRULE_whereSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1920) + p.SetState(1928) p.KwWhere() } { - p.SetState(1921) + p.SetState(1929) p.RelationElements() } @@ -32794,7 +32799,7 @@ func (p *CqlParser) DistinctSpec() (localctx IDistinctSpecContext) { p.EnterRule(localctx, 308, CqlParserRULE_distinctSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1923) + p.SetState(1931) p.KwDistinct() } @@ -32984,7 +32989,7 @@ func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(1927) + p.SetState(1935) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -32993,7 +32998,7 @@ func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { switch p.GetTokenStream().LA(1) { case CqlParserSTAR: { - p.SetState(1925) + p.SetState(1933) var _m = p.Match(CqlParserSTAR) @@ -33006,7 +33011,7 @@ func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { case CqlParserDQUOTE, CqlParserK_KEY, CqlParserK_TYPE, CqlParserK_UUID, CqlParserK_WRITETIME, CqlParserOBJECT_NAME: { - p.SetState(1926) + p.SetState(1934) p.SelectElement() } @@ -33014,7 +33019,7 @@ func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) goto errorExit } - p.SetState(1934) + p.SetState(1942) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33023,15 +33028,15 @@ func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { for _la == CqlParserCOMMA { { - p.SetState(1929) + p.SetState(1937) p.SyntaxComma() } { - p.SetState(1930) + p.SetState(1938) p.SelectElement() } - p.SetState(1936) + p.SetState(1944) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33190,7 +33195,7 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { p.EnterRule(localctx, 312, CqlParserRULE_selectElement) var _la int - p.SetState(1949) + p.SetState(1957) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33200,10 +33205,10 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1937) + p.SetState(1945) p.SelectColumn() } - p.SetState(1939) + p.SetState(1947) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33212,7 +33217,7 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { if _la == CqlParserK_AS { { - p.SetState(1938) + p.SetState(1946) p.AsSpec() } @@ -33221,10 +33226,10 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1941) + p.SetState(1949) p.SelectFunction() } - p.SetState(1943) + p.SetState(1951) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33233,7 +33238,7 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { if _la == CqlParserK_AS { { - p.SetState(1942) + p.SetState(1950) p.AsSpec() } @@ -33242,10 +33247,10 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1945) + p.SetState(1953) p.SelectIndex() } - p.SetState(1947) + p.SetState(1955) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33254,7 +33259,7 @@ func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { if _la == CqlParserK_AS { { - p.SetState(1946) + p.SetState(1954) p.AsSpec() } @@ -33364,7 +33369,7 @@ func (p *CqlParser) SelectColumn() (localctx ISelectColumnContext) { p.EnterRule(localctx, 314, CqlParserRULE_selectColumn) p.EnterOuterAlt(localctx, 1) { - p.SetState(1951) + p.SetState(1959) p.Column() } @@ -33468,7 +33473,7 @@ func (p *CqlParser) SelectFunction() (localctx ISelectFunctionContext) { p.EnterRule(localctx, 316, CqlParserRULE_selectFunction) p.EnterOuterAlt(localctx, 1) { - p.SetState(1953) + p.SetState(1961) p.FunctionCall() } @@ -33623,19 +33628,19 @@ func (p *CqlParser) SelectIndex() (localctx ISelectIndexContext) { p.EnterRule(localctx, 318, CqlParserRULE_selectIndex) p.EnterOuterAlt(localctx, 1) { - p.SetState(1955) + p.SetState(1963) p.Column() } { - p.SetState(1956) + p.SetState(1964) p.SyntaxBracketLs() } { - p.SetState(1957) + p.SetState(1965) p.Constant() } { - p.SetState(1958) + p.SetState(1966) p.SyntaxBracketRs() } @@ -33744,11 +33749,11 @@ func (p *CqlParser) AsSpec() (localctx IAsSpecContext) { p.EnterRule(localctx, 320, CqlParserRULE_asSpec) p.EnterOuterAlt(localctx, 1) { - p.SetState(1960) + p.SetState(1968) p.KwAs() } { - p.SetState(1961) + p.SetState(1969) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -33927,11 +33932,11 @@ func (p *CqlParser) RelationElements() (localctx IRelationElementsContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(1963) + p.SetState(1971) p.RelationElement() } - p.SetState(1969) + p.SetState(1977) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33940,15 +33945,15 @@ func (p *CqlParser) RelationElements() (localctx IRelationElementsContext) { for _la == CqlParserK_AND { { - p.SetState(1964) + p.SetState(1972) p.KwAnd() } { - p.SetState(1965) + p.SetState(1973) p.RelationElement() } - p.SetState(1971) + p.SetState(1979) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -33982,6 +33987,8 @@ type IRelationElementContext interface { RelationBetween() IRelationBetweenContext RelationFunctionCompareConstant() IRelationFunctionCompareConstantContext RelationFunctionCompareFunction() IRelationFunctionCompareFunctionContext + RelationColumnCompareFunction() IRelationColumnCompareFunctionContext + RelationFunctionCompareColumn() IRelationFunctionCompareColumnContext RelationContainsKey() IRelationContainsKeyContext RelationContains() IRelationContainsContext RelationIn() IRelationInContext @@ -34120,6 +34127,38 @@ func (s *RelationElementContext) RelationFunctionCompareFunction() IRelationFunc return t.(IRelationFunctionCompareFunctionContext) } +func (s *RelationElementContext) RelationColumnCompareFunction() IRelationColumnCompareFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationColumnCompareFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationColumnCompareFunctionContext) +} + +func (s *RelationElementContext) RelationFunctionCompareColumn() IRelationFunctionCompareColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationFunctionCompareColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationFunctionCompareColumnContext) +} + func (s *RelationElementContext) RelationContainsKey() IRelationContainsKeyContext { var t antlr.RuleContext for _, ctx := range s.GetChildren() { @@ -34424,7 +34463,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { p.EnterRule(localctx, 324, CqlParserRULE_relationElement) var _la int - p.SetState(2039) + p.SetState(2049) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34434,63 +34473,77 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(1972) + p.SetState(1980) p.RelationCompare() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(1973) + p.SetState(1981) p.RelationLike() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(1974) + p.SetState(1982) p.RelationBetween() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(1975) + p.SetState(1983) p.RelationFunctionCompareConstant() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(1976) + p.SetState(1984) p.RelationFunctionCompareFunction() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(1977) - p.RelationContainsKey() + p.SetState(1985) + p.RelationColumnCompareFunction() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(1978) - p.RelationContains() + p.SetState(1986) + p.RelationFunctionCompareColumn() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(1979) - p.RelationIn() + p.SetState(1987) + p.RelationContainsKey() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(1980) + p.SetState(1988) + p.RelationContains() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1989) + p.RelationIn() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1990) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34498,7 +34551,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1981) + p.SetState(1991) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -34506,7 +34559,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1982) + p.SetState(1992) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34514,18 +34567,18 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1983) + p.SetState(1993) p.KwLike() } { - p.SetState(1984) + p.SetState(1994) p.Constant() } - case 10: - p.EnterOuterAlt(localctx, 10) + case 12: + p.EnterOuterAlt(localctx, 12) { - p.SetState(1986) + p.SetState(1996) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34533,7 +34586,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1987) + p.SetState(1997) p.Match(CqlParserDOT) if p.HasError() { // Recognition error - abort rule @@ -34541,7 +34594,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1988) + p.SetState(1998) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34549,26 +34602,26 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1989) + p.SetState(1999) p.KwBetween() } { - p.SetState(1990) + p.SetState(2000) p.Constant() } { - p.SetState(1991) + p.SetState(2001) p.KwAnd() } { - p.SetState(1992) + p.SetState(2002) p.Constant() } - case 11: - p.EnterOuterAlt(localctx, 11) + case 13: + p.EnterOuterAlt(localctx, 13) { - p.SetState(1994) + p.SetState(2004) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34576,14 +34629,14 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(1995) + p.SetState(2005) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2001) + p.SetState(2011) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34592,11 +34645,11 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { for _la == CqlParserCOMMA { { - p.SetState(1996) + p.SetState(2006) p.SyntaxComma() } { - p.SetState(1997) + p.SetState(2007) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34604,7 +34657,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } - p.SetState(2003) + p.SetState(2013) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34612,7 +34665,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2004) + p.SetState(2014) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34620,11 +34673,11 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(2005) + p.SetState(2015) p.KwIn() } { - p.SetState(2006) + p.SetState(2016) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34632,10 +34685,10 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(2007) + p.SetState(2017) p.AssignmentTuple() } - p.SetState(2013) + p.SetState(2023) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34644,15 +34697,15 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { for _la == CqlParserCOMMA { { - p.SetState(2008) + p.SetState(2018) p.SyntaxComma() } { - p.SetState(2009) + p.SetState(2019) p.AssignmentTuple() } - p.SetState(2015) + p.SetState(2025) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34660,7 +34713,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2016) + p.SetState(2026) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34668,10 +34721,10 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } - case 12: - p.EnterOuterAlt(localctx, 12) + case 14: + p.EnterOuterAlt(localctx, 14) { - p.SetState(2018) + p.SetState(2028) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34679,14 +34732,14 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(2019) + p.SetState(2029) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule goto errorExit } } - p.SetState(2025) + p.SetState(2035) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34695,11 +34748,11 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { for _la == CqlParserCOMMA { { - p.SetState(2020) + p.SetState(2030) p.SyntaxComma() } { - p.SetState(2021) + p.SetState(2031) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -34707,7 +34760,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } - p.SetState(2027) + p.SetState(2037) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34715,7 +34768,7 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2028) + p.SetState(2038) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -34723,15 +34776,15 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { } } { - p.SetState(2029) + p.SetState(2039) p.CompareOperator() } { - p.SetState(2030) + p.SetState(2040) p.AssignmentTuple() } - p.SetState(2036) + p.SetState(2046) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34740,15 +34793,15 @@ func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { for _la == CqlParserCOMMA { { - p.SetState(2031) + p.SetState(2041) p.SyntaxComma() } { - p.SetState(2032) + p.SetState(2042) p.AssignmentTuple() } - p.SetState(2038) + p.SetState(2048) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -34870,7 +34923,7 @@ func (p *CqlParser) CompareOperator() (localctx ICompareOperatorContext) { p.EnterOuterAlt(localctx, 1) { - p.SetState(2041) + p.SetState(2051) _la = p.GetTokenStream().LA(1) if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { @@ -35015,15 +35068,15 @@ func (p *CqlParser) RelationFunctionCompareConstant() (localctx IRelationFunctio p.EnterRule(localctx, 328, CqlParserRULE_relationFunctionCompareConstant) p.EnterOuterAlt(localctx, 1) { - p.SetState(2043) + p.SetState(2053) p.FunctionCall() } { - p.SetState(2044) + p.SetState(2054) p.CompareOperator() } { - p.SetState(2045) + p.SetState(2055) p.Constant() } @@ -35170,15 +35223,15 @@ func (p *CqlParser) RelationFunctionCompareFunction() (localctx IRelationFunctio p.EnterRule(localctx, 330, CqlParserRULE_relationFunctionCompareFunction) p.EnterOuterAlt(localctx, 1) { - p.SetState(2047) + p.SetState(2057) p.FunctionCall() } { - p.SetState(2048) + p.SetState(2058) p.CompareOperator() } { - p.SetState(2049) + p.SetState(2059) p.FunctionCall() } @@ -35195,6 +35248,298 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } +// IRelationColumnCompareFunctionContext is an interface to support dynamic dispatch. +type IRelationColumnCompareFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + CompareOperator() ICompareOperatorContext + FunctionCall() IFunctionCallContext + + // IsRelationColumnCompareFunctionContext differentiates from other interfaces. + IsRelationColumnCompareFunctionContext() +} + +type RelationColumnCompareFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationColumnCompareFunctionContext() *RelationColumnCompareFunctionContext { + var p = new(RelationColumnCompareFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationColumnCompareFunction + return p +} + +func InitEmptyRelationColumnCompareFunctionContext(p *RelationColumnCompareFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationColumnCompareFunction +} + +func (*RelationColumnCompareFunctionContext) IsRelationColumnCompareFunctionContext() {} + +func NewRelationColumnCompareFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationColumnCompareFunctionContext { + var p = new(RelationColumnCompareFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relationColumnCompareFunction + + return p +} + +func (s *RelationColumnCompareFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationColumnCompareFunctionContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *RelationColumnCompareFunctionContext) CompareOperator() ICompareOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompareOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompareOperatorContext) +} + +func (s *RelationColumnCompareFunctionContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *RelationColumnCompareFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationColumnCompareFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationColumnCompareFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelationColumnCompareFunction(s) + } +} + +func (s *RelationColumnCompareFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelationColumnCompareFunction(s) + } +} + +func (p *CqlParser) RelationColumnCompareFunction() (localctx IRelationColumnCompareFunctionContext) { + localctx = NewRelationColumnCompareFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, CqlParserRULE_relationColumnCompareFunction) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2061) + p.Column() + } + { + p.SetState(2062) + p.CompareOperator() + } + { + p.SetState(2063) + p.FunctionCall() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationFunctionCompareColumnContext is an interface to support dynamic dispatch. +type IRelationFunctionCompareColumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FunctionCall() IFunctionCallContext + CompareOperator() ICompareOperatorContext + Column() IColumnContext + + // IsRelationFunctionCompareColumnContext differentiates from other interfaces. + IsRelationFunctionCompareColumnContext() +} + +type RelationFunctionCompareColumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationFunctionCompareColumnContext() *RelationFunctionCompareColumnContext { + var p = new(RelationFunctionCompareColumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationFunctionCompareColumn + return p +} + +func InitEmptyRelationFunctionCompareColumnContext(p *RelationFunctionCompareColumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationFunctionCompareColumn +} + +func (*RelationFunctionCompareColumnContext) IsRelationFunctionCompareColumnContext() {} + +func NewRelationFunctionCompareColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationFunctionCompareColumnContext { + var p = new(RelationFunctionCompareColumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relationFunctionCompareColumn + + return p +} + +func (s *RelationFunctionCompareColumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationFunctionCompareColumnContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *RelationFunctionCompareColumnContext) CompareOperator() ICompareOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompareOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompareOperatorContext) +} + +func (s *RelationFunctionCompareColumnContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *RelationFunctionCompareColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationFunctionCompareColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationFunctionCompareColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelationFunctionCompareColumn(s) + } +} + +func (s *RelationFunctionCompareColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelationFunctionCompareColumn(s) + } +} + +func (p *CqlParser) RelationFunctionCompareColumn() (localctx IRelationFunctionCompareColumnContext) { + localctx = NewRelationFunctionCompareColumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, CqlParserRULE_relationFunctionCompareColumn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2065) + p.FunctionCall() + } + { + p.SetState(2066) + p.CompareOperator() + } + { + p.SetState(2067) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + // IRelationBetweenContext is an interface to support dynamic dispatch. type IRelationBetweenContext interface { antlr.ParserRuleContext @@ -35205,8 +35550,8 @@ type IRelationBetweenContext interface { // Getter signatures Column() IColumnContext KwBetween() IKwBetweenContext - AllConstant() []IConstantContext - Constant(i int) IConstantContext + AllValueAny() []IValueAnyContext + ValueAny(i int) IValueAnyContext KwAnd() IKwAndContext // IsRelationBetweenContext differentiates from other interfaces. @@ -35277,20 +35622,20 @@ func (s *RelationBetweenContext) KwBetween() IKwBetweenContext { return t.(IKwBetweenContext) } -func (s *RelationBetweenContext) AllConstant() []IConstantContext { +func (s *RelationBetweenContext) AllValueAny() []IValueAnyContext { children := s.GetChildren() len := 0 for _, ctx := range children { - if _, ok := ctx.(IConstantContext); ok { + if _, ok := ctx.(IValueAnyContext); ok { len++ } } - tst := make([]IConstantContext, len) + tst := make([]IValueAnyContext, len) i := 0 for _, ctx := range children { - if t, ok := ctx.(IConstantContext); ok { - tst[i] = t.(IConstantContext) + if t, ok := ctx.(IValueAnyContext); ok { + tst[i] = t.(IValueAnyContext) i++ } } @@ -35298,11 +35643,11 @@ func (s *RelationBetweenContext) AllConstant() []IConstantContext { return tst } -func (s *RelationBetweenContext) Constant(i int) IConstantContext { +func (s *RelationBetweenContext) ValueAny(i int) IValueAnyContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { - if _, ok := ctx.(IConstantContext); ok { + if _, ok := ctx.(IValueAnyContext); ok { if j == i { t = ctx.(antlr.RuleContext) break @@ -35315,7 +35660,7 @@ func (s *RelationBetweenContext) Constant(i int) IConstantContext { return nil } - return t.(IConstantContext) + return t.(IValueAnyContext) } func (s *RelationBetweenContext) KwAnd() IKwAndContext { @@ -35356,27 +35701,27 @@ func (s *RelationBetweenContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RelationBetween() (localctx IRelationBetweenContext) { localctx = NewRelationBetweenContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 332, CqlParserRULE_relationBetween) + p.EnterRule(localctx, 336, CqlParserRULE_relationBetween) p.EnterOuterAlt(localctx, 1) { - p.SetState(2051) + p.SetState(2069) p.Column() } { - p.SetState(2052) + p.SetState(2070) p.KwBetween() } { - p.SetState(2053) - p.Constant() + p.SetState(2071) + p.ValueAny() } { - p.SetState(2054) + p.SetState(2072) p.KwAnd() } { - p.SetState(2055) - p.Constant() + p.SetState(2073) + p.ValueAny() } errorExit: @@ -35510,18 +35855,18 @@ func (s *RelationCompareContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RelationCompare() (localctx IRelationCompareContext) { localctx = NewRelationCompareContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 334, CqlParserRULE_relationCompare) + p.EnterRule(localctx, 338, CqlParserRULE_relationCompare) p.EnterOuterAlt(localctx, 1) { - p.SetState(2057) + p.SetState(2075) p.Column() } { - p.SetState(2058) + p.SetState(2076) p.CompareOperator() } { - p.SetState(2059) + p.SetState(2077) p.Constant() } @@ -35656,18 +36001,18 @@ func (s *RelationLikeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RelationLike() (localctx IRelationLikeContext) { localctx = NewRelationLikeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 336, CqlParserRULE_relationLike) + p.EnterRule(localctx, 340, CqlParserRULE_relationLike) p.EnterOuterAlt(localctx, 1) { - p.SetState(2061) + p.SetState(2079) p.Column() } { - p.SetState(2062) + p.SetState(2080) p.KwLike() } { - p.SetState(2063) + p.SetState(2081) p.Constant() } @@ -35761,12 +36106,12 @@ func (s *MarkerContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Marker() (localctx IMarkerContext) { localctx = NewMarkerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 338, CqlParserRULE_marker) + p.EnterRule(localctx, 342, CqlParserRULE_marker) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2065) + p.SetState(2083) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserQUESTION_MARK || _la == CqlParserNAMED_MARK) { @@ -35901,8 +36246,8 @@ func (s *TupleValueContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) TupleValue() (localctx ITupleValueContext) { localctx = NewTupleValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 340, CqlParserRULE_tupleValue) - p.SetState(2072) + p.EnterRule(localctx, 344, CqlParserRULE_tupleValue) + p.SetState(2090) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -35912,14 +36257,14 @@ func (p *CqlParser) TupleValue() (localctx ITupleValueContext) { case CqlParserQUESTION_MARK, CqlParserNAMED_MARK: p.EnterOuterAlt(localctx, 1) { - p.SetState(2067) + p.SetState(2085) p.Marker() } case CqlParserLR_BRACKET: p.EnterOuterAlt(localctx, 2) { - p.SetState(2068) + p.SetState(2086) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -35927,11 +36272,11 @@ func (p *CqlParser) TupleValue() (localctx ITupleValueContext) { } } { - p.SetState(2069) + p.SetState(2087) p.FunctionArgs() } { - p.SetState(2070) + p.SetState(2088) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -36075,18 +36420,18 @@ func (s *RelationInContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RelationIn() (localctx IRelationInContext) { localctx = NewRelationInContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 342, CqlParserRULE_relationIn) + p.EnterRule(localctx, 346, CqlParserRULE_relationIn) p.EnterOuterAlt(localctx, 1) { - p.SetState(2074) + p.SetState(2092) p.Column() } { - p.SetState(2075) + p.SetState(2093) p.KwIn() } { - p.SetState(2076) + p.SetState(2094) p.TupleValue() } @@ -36221,18 +36566,18 @@ func (s *RelationContainsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) RelationContains() (localctx IRelationContainsContext) { localctx = NewRelationContainsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 344, CqlParserRULE_relationContains) + p.EnterRule(localctx, 348, CqlParserRULE_relationContains) p.EnterOuterAlt(localctx, 1) { - p.SetState(2078) + p.SetState(2096) p.Column() } { - p.SetState(2079) + p.SetState(2097) p.KwContains() } { - p.SetState(2080) + p.SetState(2098) p.Constant() } @@ -36384,24 +36729,24 @@ func (s *RelationContainsKeyContext) ExitRule(listener antlr.ParseTreeListener) func (p *CqlParser) RelationContainsKey() (localctx IRelationContainsKeyContext) { localctx = NewRelationContainsKeyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 346, CqlParserRULE_relationContainsKey) + p.EnterRule(localctx, 350, CqlParserRULE_relationContainsKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(2082) + p.SetState(2100) p.Column() } { - p.SetState(2083) + p.SetState(2101) p.KwContains() } { - p.SetState(2084) + p.SetState(2102) p.KwKey() } { - p.SetState(2086) + p.SetState(2104) p.Constant() } @@ -36426,13 +36771,10 @@ type IFunctionCallContext interface { GetParser() antlr.Parser // Getter signatures - OBJECT_NAME() antlr.TerminalNode + FunctionName() IFunctionNameContext LR_BRACKET() antlr.TerminalNode - STAR() antlr.TerminalNode RR_BRACKET() antlr.TerminalNode FunctionArgs() IFunctionArgsContext - K_UUID() antlr.TerminalNode - K_WRITETIME() antlr.TerminalNode // IsFunctionCallContext differentiates from other interfaces. IsFunctionCallContext() @@ -36470,18 +36812,26 @@ func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *FunctionCallContext) GetParser() antlr.Parser { return s.parser } -func (s *FunctionCallContext) OBJECT_NAME() antlr.TerminalNode { - return s.GetToken(CqlParserOBJECT_NAME, 0) +func (s *FunctionCallContext) FunctionName() IFunctionNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionNameContext) } func (s *FunctionCallContext) LR_BRACKET() antlr.TerminalNode { return s.GetToken(CqlParserLR_BRACKET, 0) } -func (s *FunctionCallContext) STAR() antlr.TerminalNode { - return s.GetToken(CqlParserSTAR, 0) -} - func (s *FunctionCallContext) RR_BRACKET() antlr.TerminalNode { return s.GetToken(CqlParserRR_BRACKET, 0) } @@ -36502,14 +36852,6 @@ func (s *FunctionCallContext) FunctionArgs() IFunctionArgsContext { return t.(IFunctionArgsContext) } -func (s *FunctionCallContext) K_UUID() antlr.TerminalNode { - return s.GetToken(CqlParserK_UUID, 0) -} - -func (s *FunctionCallContext) K_WRITETIME() antlr.TerminalNode { - return s.GetToken(CqlParserK_WRITETIME, 0) -} - func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext { return s } @@ -36532,162 +36874,154 @@ func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) FunctionCall() (localctx IFunctionCallContext) { localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 348, CqlParserRULE_functionCall) + p.EnterRule(localctx, 352, CqlParserRULE_functionCall) var _la int - p.SetState(2107) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2106) + p.FunctionName() + } + { + p.SetState(2107) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2109) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } + _la = p.GetTokenStream().LA(1) - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 170, p.GetParserRuleContext()) { - case 1: - p.EnterOuterAlt(localctx, 1) + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&144115188075989034) != 0) || ((int64((_la-76)) & ^0x3f) == 0 && ((int64(1)<<(_la-76))&612489549322911745) != 0) || ((int64((_la-141)) & ^0x3f) == 0 && ((int64(1)<<(_la-141))&133009768481) != 0) { { - p.SetState(2088) - p.Match(CqlParserOBJECT_NAME) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2089) - p.Match(CqlParserLR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2090) - p.Match(CqlParserSTAR) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2091) - p.Match(CqlParserRR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(2108) + p.FunctionArgs() } - case 2: - p.EnterOuterAlt(localctx, 2) - { - p.SetState(2092) - p.Match(CqlParserOBJECT_NAME) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2093) - p.Match(CqlParserLR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - p.SetState(2095) - p.GetErrorHandler().Sync(p) + } + { + p.SetState(2111) + p.Match(CqlParserRR_BRACKET) if p.HasError() { + // Recognition error - abort rule goto errorExit } - _la = p.GetTokenStream().LA(1) + } - if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&136202002924545) != 0) { - { - p.SetState(2094) - p.FunctionArgs() - } +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} - } - { - p.SetState(2097) - p.Match(CqlParserRR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } +// IFunctionNameContext is an interface to support dynamic dispatch. +type IFunctionNameContext interface { + antlr.ParserRuleContext - case 3: - p.EnterOuterAlt(localctx, 3) - { - p.SetState(2098) - p.Match(CqlParserK_UUID) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2099) - p.Match(CqlParserLR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2100) - p.Match(CqlParserRR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } + // GetParser returns the parser. + GetParser() antlr.Parser - case 4: - p.EnterOuterAlt(localctx, 4) - { - p.SetState(2101) - p.Match(CqlParserK_WRITETIME) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - { - p.SetState(2102) - p.Match(CqlParserLR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } - p.SetState(2104) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit - } - _la = p.GetTokenStream().LA(1) + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + K_UUID() antlr.TerminalNode + K_WRITETIME() antlr.TerminalNode - if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-131)) & ^0x3f) == 0 && ((int64(1)<<(_la-131))&136202002924545) != 0) { - { - p.SetState(2103) - p.FunctionArgs() - } + // IsFunctionNameContext differentiates from other interfaces. + IsFunctionNameContext() +} - } - { - p.SetState(2106) - p.Match(CqlParserRR_BRACKET) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } +type FunctionNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} - case antlr.ATNInvalidAltNumber: - goto errorExit +func NewEmptyFunctionNameContext() *FunctionNameContext { + var p = new(FunctionNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionName + return p +} + +func InitEmptyFunctionNameContext(p *FunctionNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionName +} + +func (*FunctionNameContext) IsFunctionNameContext() {} + +func NewFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameContext { + var p = new(FunctionNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_functionName + + return p +} + +func (s *FunctionNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionNameContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *FunctionNameContext) K_UUID() antlr.TerminalNode { + return s.GetToken(CqlParserK_UUID, 0) +} + +func (s *FunctionNameContext) K_WRITETIME() antlr.TerminalNode { + return s.GetToken(CqlParserK_WRITETIME, 0) +} + +func (s *FunctionNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFunctionName(s) + } +} + +func (s *FunctionNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFunctionName(s) + } +} + +func (p *CqlParser) FunctionName() (localctx IFunctionNameContext) { + localctx = NewFunctionNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, CqlParserRULE_functionName) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2113) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-141)) & ^0x3f) == 0 && ((int64(1)<<(_la-141))&8589934625) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } } errorExit: @@ -36711,12 +37045,8 @@ type IFunctionArgsContext interface { GetParser() antlr.Parser // Getter signatures - AllConstant() []IConstantContext - Constant(i int) IConstantContext - AllOBJECT_NAME() []antlr.TerminalNode - OBJECT_NAME(i int) antlr.TerminalNode - AllFunctionCall() []IFunctionCallContext - FunctionCall(i int) IFunctionCallContext + AllFunctionArg() []IFunctionArgContext + FunctionArg(i int) IFunctionArgContext AllSyntaxComma() []ISyntaxCommaContext SyntaxComma(i int) ISyntaxCommaContext @@ -36756,69 +37086,20 @@ func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *FunctionArgsContext) GetParser() antlr.Parser { return s.parser } -func (s *FunctionArgsContext) AllConstant() []IConstantContext { - children := s.GetChildren() - len := 0 - for _, ctx := range children { - if _, ok := ctx.(IConstantContext); ok { - len++ - } - } - - tst := make([]IConstantContext, len) - i := 0 - for _, ctx := range children { - if t, ok := ctx.(IConstantContext); ok { - tst[i] = t.(IConstantContext) - i++ - } - } - - return tst -} - -func (s *FunctionArgsContext) Constant(i int) IConstantContext { - var t antlr.RuleContext - j := 0 - for _, ctx := range s.GetChildren() { - if _, ok := ctx.(IConstantContext); ok { - if j == i { - t = ctx.(antlr.RuleContext) - break - } - j++ - } - } - - if t == nil { - return nil - } - - return t.(IConstantContext) -} - -func (s *FunctionArgsContext) AllOBJECT_NAME() []antlr.TerminalNode { - return s.GetTokens(CqlParserOBJECT_NAME) -} - -func (s *FunctionArgsContext) OBJECT_NAME(i int) antlr.TerminalNode { - return s.GetToken(CqlParserOBJECT_NAME, i) -} - -func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext { +func (s *FunctionArgsContext) AllFunctionArg() []IFunctionArgContext { children := s.GetChildren() len := 0 for _, ctx := range children { - if _, ok := ctx.(IFunctionCallContext); ok { + if _, ok := ctx.(IFunctionArgContext); ok { len++ } } - tst := make([]IFunctionCallContext, len) + tst := make([]IFunctionArgContext, len) i := 0 for _, ctx := range children { - if t, ok := ctx.(IFunctionCallContext); ok { - tst[i] = t.(IFunctionCallContext) + if t, ok := ctx.(IFunctionArgContext); ok { + tst[i] = t.(IFunctionArgContext) i++ } } @@ -36826,11 +37107,11 @@ func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext { return tst } -func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext { +func (s *FunctionArgsContext) FunctionArg(i int) IFunctionArgContext { var t antlr.RuleContext j := 0 for _, ctx := range s.GetChildren() { - if _, ok := ctx.(IFunctionCallContext); ok { + if _, ok := ctx.(IFunctionArgContext); ok { if j == i { t = ctx.(antlr.RuleContext) break @@ -36843,7 +37124,7 @@ func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext { return nil } - return t.(IFunctionCallContext) + return t.(IFunctionArgContext) } func (s *FunctionArgsContext) AllSyntaxComma() []ISyntaxCommaContext { @@ -36909,93 +37190,194 @@ func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) FunctionArgs() (localctx IFunctionArgsContext) { localctx = NewFunctionArgsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 350, CqlParserRULE_functionArgs) + p.EnterRule(localctx, 356, CqlParserRULE_functionArgs) var _la int p.EnterOuterAlt(localctx, 1) - p.SetState(2112) + { + p.SetState(2115) + p.FunctionArg() + } + + p.SetState(2121) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } + _la = p.GetTokenStream().LA(1) - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 171, p.GetParserRuleContext()) { - case 1: + for _la == CqlParserCOMMA { { - p.SetState(2109) - p.Constant() + p.SetState(2116) + p.SyntaxComma() } - - case 2: { - p.SetState(2110) - p.Match(CqlParserOBJECT_NAME) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } + p.SetState(2117) + p.FunctionArg() } - case 3: - { - p.SetState(2111) - p.FunctionCall() + p.SetState(2123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit } + _la = p.GetTokenStream().LA(1) + } - case antlr.ATNInvalidAltNumber: - goto errorExit +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) } - p.SetState(2122) + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionArgContext is an interface to support dynamic dispatch. +type IFunctionArgContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ValueAny() IValueAnyContext + Column() IColumnContext + STAR() antlr.TerminalNode + + // IsFunctionArgContext differentiates from other interfaces. + IsFunctionArgContext() +} + +type FunctionArgContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionArgContext() *FunctionArgContext { + var p = new(FunctionArgContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionArg + return p +} + +func InitEmptyFunctionArgContext(p *FunctionArgContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionArg +} + +func (*FunctionArgContext) IsFunctionArgContext() {} + +func NewFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgContext { + var p = new(FunctionArgContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_functionArg + + return p +} + +func (s *FunctionArgContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionArgContext) ValueAny() IValueAnyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueAnyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueAnyContext) +} + +func (s *FunctionArgContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *FunctionArgContext) STAR() antlr.TerminalNode { + return s.GetToken(CqlParserSTAR, 0) +} + +func (s *FunctionArgContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionArgContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFunctionArg(s) + } +} + +func (s *FunctionArgContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFunctionArg(s) + } +} + +func (p *CqlParser) FunctionArg() (localctx IFunctionArgContext) { + localctx = NewFunctionArgContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, CqlParserRULE_functionArg) + p.SetState(2127) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - _la = p.GetTokenStream().LA(1) - for _la == CqlParserCOMMA { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 170, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) { - p.SetState(2114) - p.SyntaxComma() - } - p.SetState(2118) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit + p.SetState(2124) + p.ValueAny() } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) { - case 1: - { - p.SetState(2115) - p.Constant() - } - - case 2: - { - p.SetState(2116) - p.Match(CqlParserOBJECT_NAME) - if p.HasError() { - // Recognition error - abort rule - goto errorExit - } - } + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2125) + p.Column() + } - case 3: - { - p.SetState(2117) - p.FunctionCall() + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2126) + p.Match(CqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit } - - case antlr.ATNInvalidAltNumber: - goto errorExit } - p.SetState(2124) - p.GetErrorHandler().Sync(p) - if p.HasError() { - goto errorExit - } - _la = p.GetTokenStream().LA(1) + case antlr.ATNInvalidAltNumber: + goto errorExit } errorExit: @@ -37197,60 +37579,60 @@ func (s *ValueAnyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) ValueAny() (localctx IValueAnyContext) { localctx = NewValueAnyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 352, CqlParserRULE_valueAny) - p.SetState(2132) + p.EnterRule(localctx, 360, CqlParserRULE_valueAny) + p.SetState(2136) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 174, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 171, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2125) + p.SetState(2129) p.Marker() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2126) + p.SetState(2130) p.Constant() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2127) + p.SetState(2131) p.FunctionCall() } case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(2128) + p.SetState(2132) p.ValueMap() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(2129) + p.SetState(2133) p.ValueSet() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(2130) + p.SetState(2134) p.ValueList() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(2131) + p.SetState(2135) p.AssignmentTuple() } @@ -37479,32 +37861,32 @@ func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Constant() (localctx IConstantContext) { localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 354, CqlParserRULE_constant) - p.SetState(2143) + p.EnterRule(localctx, 362, CqlParserRULE_constant) + p.SetState(2147) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit } - switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 175, p.GetParserRuleContext()) { + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) { case 1: p.EnterOuterAlt(localctx, 1) { - p.SetState(2134) + p.SetState(2138) p.Marker() } case 2: p.EnterOuterAlt(localctx, 2) { - p.SetState(2135) + p.SetState(2139) p.KwNull() } case 3: p.EnterOuterAlt(localctx, 3) { - p.SetState(2136) + p.SetState(2140) p.Match(CqlParserUUID) if p.HasError() { // Recognition error - abort rule @@ -37515,42 +37897,42 @@ func (p *CqlParser) Constant() (localctx IConstantContext) { case 4: p.EnterOuterAlt(localctx, 4) { - p.SetState(2137) + p.SetState(2141) p.StringLiteral() } case 5: p.EnterOuterAlt(localctx, 5) { - p.SetState(2138) + p.SetState(2142) p.DecimalLiteral() } case 6: p.EnterOuterAlt(localctx, 6) { - p.SetState(2139) + p.SetState(2143) p.FloatLiteral() } case 7: p.EnterOuterAlt(localctx, 7) { - p.SetState(2140) + p.SetState(2144) p.HexadecimalLiteral() } case 8: p.EnterOuterAlt(localctx, 8) { - p.SetState(2141) + p.SetState(2145) p.BooleanLiteral() } case 9: p.EnterOuterAlt(localctx, 9) { - p.SetState(2142) + p.SetState(2146) p.CodeBlock() } @@ -37643,10 +38025,10 @@ func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) DecimalLiteral() (localctx IDecimalLiteralContext) { localctx = NewDecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 356, CqlParserRULE_decimalLiteral) + p.EnterRule(localctx, 364, CqlParserRULE_decimalLiteral) p.EnterOuterAlt(localctx, 1) { - p.SetState(2145) + p.SetState(2149) p.Match(CqlParserDECIMAL_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -37744,12 +38126,12 @@ func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) FloatLiteral() (localctx IFloatLiteralContext) { localctx = NewFloatLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 358, CqlParserRULE_floatLiteral) + p.EnterRule(localctx, 366, CqlParserRULE_floatLiteral) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2147) + p.SetState(2151) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserDECIMAL_LITERAL || _la == CqlParserFLOAT_LITERAL) { @@ -37845,10 +38227,10 @@ func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) StringLiteral() (localctx IStringLiteralContext) { localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 360, CqlParserRULE_stringLiteral) + p.EnterRule(localctx, 368, CqlParserRULE_stringLiteral) p.EnterOuterAlt(localctx, 1) { - p.SetState(2149) + p.SetState(2153) p.Match(CqlParserSTRING_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -37946,12 +38328,12 @@ func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) BooleanLiteral() (localctx IBooleanLiteralContext) { localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 362, CqlParserRULE_booleanLiteral) + p.EnterRule(localctx, 370, CqlParserRULE_booleanLiteral) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2151) + p.SetState(2155) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserK_FALSE || _la == CqlParserK_TRUE) { @@ -38047,10 +38429,10 @@ func (s *HexadecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext) { localctx = NewHexadecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 364, CqlParserRULE_hexadecimalLiteral) + p.EnterRule(localctx, 372, CqlParserRULE_hexadecimalLiteral) p.EnterOuterAlt(localctx, 1) { - p.SetState(2153) + p.SetState(2157) p.Match(CqlParserHEXADECIMAL_LITERAL) if p.HasError() { // Recognition error - abort rule @@ -38153,8 +38535,8 @@ func (s *KeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { localctx = NewKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 366, CqlParserRULE_keyspace) - p.SetState(2159) + p.EnterRule(localctx, 374, CqlParserRULE_keyspace) + p.SetState(2163) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38164,7 +38546,7 @@ func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { case CqlParserOBJECT_NAME: p.EnterOuterAlt(localctx, 1) { - p.SetState(2155) + p.SetState(2159) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38175,7 +38557,7 @@ func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { case CqlParserDQUOTE: p.EnterOuterAlt(localctx, 2) { - p.SetState(2156) + p.SetState(2160) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38183,7 +38565,7 @@ func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { } } { - p.SetState(2157) + p.SetState(2161) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38191,7 +38573,7 @@ func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { } } { - p.SetState(2158) + p.SetState(2162) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38314,8 +38696,8 @@ func (s *TableContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Table() (localctx ITableContext) { localctx = NewTableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 368, CqlParserRULE_table) - p.SetState(2168) + p.EnterRule(localctx, 376, CqlParserRULE_table) + p.SetState(2172) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38325,7 +38707,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { case CqlParserOBJECT_NAME: p.EnterOuterAlt(localctx, 1) { - p.SetState(2161) + p.SetState(2165) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38336,7 +38718,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { case CqlParserK_KEYSPACES: p.EnterOuterAlt(localctx, 2) { - p.SetState(2162) + p.SetState(2166) p.Match(CqlParserK_KEYSPACES) if p.HasError() { // Recognition error - abort rule @@ -38347,7 +38729,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { case CqlParserK_TABLES: p.EnterOuterAlt(localctx, 3) { - p.SetState(2163) + p.SetState(2167) p.Match(CqlParserK_TABLES) if p.HasError() { // Recognition error - abort rule @@ -38358,7 +38740,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { case CqlParserK_FUNCTIONS: p.EnterOuterAlt(localctx, 4) { - p.SetState(2164) + p.SetState(2168) p.Match(CqlParserK_FUNCTIONS) if p.HasError() { // Recognition error - abort rule @@ -38369,7 +38751,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { case CqlParserDQUOTE: p.EnterOuterAlt(localctx, 5) { - p.SetState(2165) + p.SetState(2169) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38377,7 +38759,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { } } { - p.SetState(2166) + p.SetState(2170) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38385,7 +38767,7 @@ func (p *CqlParser) Table() (localctx ITableContext) { } } { - p.SetState(2167) + p.SetState(2171) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38515,8 +38897,8 @@ func (s *ColumnContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Column() (localctx IColumnContext) { localctx = NewColumnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 370, CqlParserRULE_column) - p.SetState(2176) + p.EnterRule(localctx, 378, CqlParserRULE_column) + p.SetState(2180) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38526,7 +38908,7 @@ func (p *CqlParser) Column() (localctx IColumnContext) { case CqlParserOBJECT_NAME: p.EnterOuterAlt(localctx, 1) { - p.SetState(2170) + p.SetState(2174) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38537,14 +38919,14 @@ func (p *CqlParser) Column() (localctx IColumnContext) { case CqlParserK_TYPE: p.EnterOuterAlt(localctx, 2) { - p.SetState(2171) + p.SetState(2175) p.KwType() } case CqlParserK_KEY: p.EnterOuterAlt(localctx, 3) { - p.SetState(2172) + p.SetState(2176) p.Match(CqlParserK_KEY) if p.HasError() { // Recognition error - abort rule @@ -38555,7 +38937,7 @@ func (p *CqlParser) Column() (localctx IColumnContext) { case CqlParserDQUOTE: p.EnterOuterAlt(localctx, 4) { - p.SetState(2173) + p.SetState(2177) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38563,7 +38945,7 @@ func (p *CqlParser) Column() (localctx IColumnContext) { } } { - p.SetState(2174) + p.SetState(2178) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -38571,7 +38953,7 @@ func (p *CqlParser) Column() (localctx IColumnContext) { } } { - p.SetState(2175) + p.SetState(2179) p.Match(CqlParserDQUOTE) if p.HasError() { // Recognition error - abort rule @@ -38698,15 +39080,15 @@ func (s *DataTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) DataType() (localctx IDataTypeContext) { localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 372, CqlParserRULE_dataType) + p.EnterRule(localctx, 380, CqlParserRULE_dataType) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2178) + p.SetState(2182) p.DataTypeName() } - p.SetState(2180) + p.SetState(2184) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -38715,7 +39097,7 @@ func (p *CqlParser) DataType() (localctx IDataTypeContext) { if _la == CqlParserOPERATOR_LT { { - p.SetState(2179) + p.SetState(2183) p.DataTypeDefinition() } @@ -38931,12 +39313,12 @@ func (s *DataTypeNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) DataTypeName() (localctx IDataTypeNameContext) { localctx = NewDataTypeNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 374, CqlParserRULE_dataTypeName) + p.EnterRule(localctx, 382, CqlParserRULE_dataTypeName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2182) + p.SetState(2186) _la = p.GetTokenStream().LA(1) if !(((int64((_la-84)) & ^0x3f) == 0 && ((int64(1)<<(_la-84))&-9079248035506028543) != 0) || ((int64((_la-148)) & ^0x3f) == 0 && ((int64(1)<<(_la-148))&68157439) != 0)) { @@ -39147,19 +39529,19 @@ func (s *DataTypeDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) DataTypeDefinition() (localctx IDataTypeDefinitionContext) { localctx = NewDataTypeDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 376, CqlParserRULE_dataTypeDefinition) + p.EnterRule(localctx, 384, CqlParserRULE_dataTypeDefinition) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2184) + p.SetState(2188) p.SyntaxBracketLa() } { - p.SetState(2185) + p.SetState(2189) p.DataType() } - p.SetState(2191) + p.SetState(2195) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -39168,15 +39550,15 @@ func (p *CqlParser) DataTypeDefinition() (localctx IDataTypeDefinitionContext) { for _la == CqlParserCOMMA { { - p.SetState(2186) + p.SetState(2190) p.SyntaxComma() } { - p.SetState(2187) + p.SetState(2191) p.DataType() } - p.SetState(2193) + p.SetState(2197) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -39184,7 +39566,7 @@ func (p *CqlParser) DataTypeDefinition() (localctx IDataTypeDefinitionContext) { _la = p.GetTokenStream().LA(1) } { - p.SetState(2194) + p.SetState(2198) p.SyntaxBracketRa() } @@ -39302,8 +39684,8 @@ func (s *OrderDirectionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) OrderDirection() (localctx IOrderDirectionContext) { localctx = NewOrderDirectionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 378, CqlParserRULE_orderDirection) - p.SetState(2198) + p.EnterRule(localctx, 386, CqlParserRULE_orderDirection) + p.SetState(2202) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -39313,14 +39695,14 @@ func (p *CqlParser) OrderDirection() (localctx IOrderDirectionContext) { case CqlParserK_ASC: p.EnterOuterAlt(localctx, 1) { - p.SetState(2196) + p.SetState(2200) p.KwAsc() } case CqlParserK_DESC: p.EnterOuterAlt(localctx, 2) { - p.SetState(2197) + p.SetState(2201) p.KwDesc() } @@ -39414,10 +39796,10 @@ func (s *RoleContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Role() (localctx IRoleContext) { localctx = NewRoleContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 380, CqlParserRULE_role) + p.EnterRule(localctx, 388, CqlParserRULE_role) p.EnterOuterAlt(localctx, 1) { - p.SetState(2200) + p.SetState(2204) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -39510,10 +39892,10 @@ func (s *TriggerContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Trigger() (localctx ITriggerContext) { localctx = NewTriggerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 382, CqlParserRULE_trigger) + p.EnterRule(localctx, 390, CqlParserRULE_trigger) p.EnterOuterAlt(localctx, 1) { - p.SetState(2202) + p.SetState(2206) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -39618,10 +40000,10 @@ func (s *TriggerClassContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) TriggerClass() (localctx ITriggerClassContext) { localctx = NewTriggerClassContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 384, CqlParserRULE_triggerClass) + p.EnterRule(localctx, 392, CqlParserRULE_triggerClass) p.EnterOuterAlt(localctx, 1) { - p.SetState(2204) + p.SetState(2208) p.StringLiteral() } @@ -39710,10 +40092,10 @@ func (s *MaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) MaterializedView() (localctx IMaterializedViewContext) { localctx = NewMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 386, CqlParserRULE_materializedView) + p.EnterRule(localctx, 394, CqlParserRULE_materializedView) p.EnterOuterAlt(localctx, 1) { - p.SetState(2206) + p.SetState(2210) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -39806,10 +40188,10 @@ func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Type_() (localctx IType_Context) { localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 388, CqlParserRULE_type_) + p.EnterRule(localctx, 396, CqlParserRULE_type_) p.EnterOuterAlt(localctx, 1) { - p.SetState(2208) + p.SetState(2212) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -39902,10 +40284,10 @@ func (s *AggregateContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Aggregate() (localctx IAggregateContext) { localctx = NewAggregateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 390, CqlParserRULE_aggregate) + p.EnterRule(localctx, 398, CqlParserRULE_aggregate) p.EnterOuterAlt(localctx, 1) { - p.SetState(2210) + p.SetState(2214) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -39998,10 +40380,10 @@ func (s *Function_Context) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Function_() (localctx IFunction_Context) { localctx = NewFunction_Context(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 392, CqlParserRULE_function_) + p.EnterRule(localctx, 400, CqlParserRULE_function_) p.EnterOuterAlt(localctx, 1) { - p.SetState(2212) + p.SetState(2216) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -40094,10 +40476,10 @@ func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Language() (localctx ILanguageContext) { localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 394, CqlParserRULE_language) + p.EnterRule(localctx, 402, CqlParserRULE_language) p.EnterOuterAlt(localctx, 1) { - p.SetState(2214) + p.SetState(2218) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -40190,10 +40572,10 @@ func (s *UserContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) User() (localctx IUserContext) { localctx = NewUserContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 396, CqlParserRULE_user) + p.EnterRule(localctx, 404, CqlParserRULE_user) p.EnterOuterAlt(localctx, 1) { - p.SetState(2216) + p.SetState(2220) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -40298,10 +40680,10 @@ func (s *PasswordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Password() (localctx IPasswordContext) { localctx = NewPasswordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 398, CqlParserRULE_password) + p.EnterRule(localctx, 406, CqlParserRULE_password) p.EnterOuterAlt(localctx, 1) { - p.SetState(2218) + p.SetState(2222) p.StringLiteral() } @@ -40390,10 +40772,10 @@ func (s *HashKeyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) HashKey() (localctx IHashKeyContext) { localctx = NewHashKeyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 400, CqlParserRULE_hashKey) + p.EnterRule(localctx, 408, CqlParserRULE_hashKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(2220) + p.SetState(2224) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule @@ -40515,14 +40897,14 @@ func (s *ParamContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) Param() (localctx IParamContext) { localctx = NewParamContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 402, CqlParserRULE_param) + p.EnterRule(localctx, 410, CqlParserRULE_param) p.EnterOuterAlt(localctx, 1) { - p.SetState(2222) + p.SetState(2226) p.ParamName() } { - p.SetState(2223) + p.SetState(2227) p.DataType() } @@ -40616,12 +40998,12 @@ func (s *ParamNameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) ParamName() (localctx IParamNameContext) { localctx = NewParamNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 404, CqlParserRULE_paramName) + p.EnterRule(localctx, 412, CqlParserRULE_paramName) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2225) + p.SetState(2229) _la = p.GetTokenStream().LA(1) if !(_la == CqlParserK_INPUT || _la == CqlParserOBJECT_NAME) { @@ -40717,10 +41099,10 @@ func (s *KwAddContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAdd() (localctx IKwAddContext) { localctx = NewKwAddContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 406, CqlParserRULE_kwAdd) + p.EnterRule(localctx, 414, CqlParserRULE_kwAdd) p.EnterOuterAlt(localctx, 1) { - p.SetState(2227) + p.SetState(2231) p.Match(CqlParserK_ADD) if p.HasError() { // Recognition error - abort rule @@ -40813,10 +41195,10 @@ func (s *KwAggregateContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAggregate() (localctx IKwAggregateContext) { localctx = NewKwAggregateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 408, CqlParserRULE_kwAggregate) + p.EnterRule(localctx, 416, CqlParserRULE_kwAggregate) p.EnterOuterAlt(localctx, 1) { - p.SetState(2229) + p.SetState(2233) p.Match(CqlParserK_AGGREGATE) if p.HasError() { // Recognition error - abort rule @@ -40909,10 +41291,10 @@ func (s *KwAllContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAll() (localctx IKwAllContext) { localctx = NewKwAllContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 410, CqlParserRULE_kwAll) + p.EnterRule(localctx, 418, CqlParserRULE_kwAll) p.EnterOuterAlt(localctx, 1) { - p.SetState(2231) + p.SetState(2235) p.Match(CqlParserK_ALL) if p.HasError() { // Recognition error - abort rule @@ -41010,10 +41392,10 @@ func (s *KwAllPermissionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAllPermissions() (localctx IKwAllPermissionsContext) { localctx = NewKwAllPermissionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 412, CqlParserRULE_kwAllPermissions) + p.EnterRule(localctx, 420, CqlParserRULE_kwAllPermissions) p.EnterOuterAlt(localctx, 1) { - p.SetState(2233) + p.SetState(2237) p.Match(CqlParserK_ALL) if p.HasError() { // Recognition error - abort rule @@ -41021,7 +41403,7 @@ func (p *CqlParser) KwAllPermissions() (localctx IKwAllPermissionsContext) { } } { - p.SetState(2234) + p.SetState(2238) p.Match(CqlParserK_PERMISSIONS) if p.HasError() { // Recognition error - abort rule @@ -41114,10 +41496,10 @@ func (s *KwAllowContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAllow() (localctx IKwAllowContext) { localctx = NewKwAllowContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 414, CqlParserRULE_kwAllow) + p.EnterRule(localctx, 422, CqlParserRULE_kwAllow) p.EnterOuterAlt(localctx, 1) { - p.SetState(2236) + p.SetState(2240) p.Match(CqlParserK_ALLOW) if p.HasError() { // Recognition error - abort rule @@ -41210,10 +41592,10 @@ func (s *KwAlterContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAlter() (localctx IKwAlterContext) { localctx = NewKwAlterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 416, CqlParserRULE_kwAlter) + p.EnterRule(localctx, 424, CqlParserRULE_kwAlter) p.EnterOuterAlt(localctx, 1) { - p.SetState(2238) + p.SetState(2242) p.Match(CqlParserK_ALTER) if p.HasError() { // Recognition error - abort rule @@ -41306,10 +41688,10 @@ func (s *KwAndContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAnd() (localctx IKwAndContext) { localctx = NewKwAndContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 418, CqlParserRULE_kwAnd) + p.EnterRule(localctx, 426, CqlParserRULE_kwAnd) p.EnterOuterAlt(localctx, 1) { - p.SetState(2240) + p.SetState(2244) p.Match(CqlParserK_AND) if p.HasError() { // Recognition error - abort rule @@ -41402,10 +41784,10 @@ func (s *KwApplyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwApply() (localctx IKwApplyContext) { localctx = NewKwApplyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 420, CqlParserRULE_kwApply) + p.EnterRule(localctx, 428, CqlParserRULE_kwApply) p.EnterOuterAlt(localctx, 1) { - p.SetState(2242) + p.SetState(2246) p.Match(CqlParserK_APPLY) if p.HasError() { // Recognition error - abort rule @@ -41498,10 +41880,10 @@ func (s *KwAsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAs() (localctx IKwAsContext) { localctx = NewKwAsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 422, CqlParserRULE_kwAs) + p.EnterRule(localctx, 430, CqlParserRULE_kwAs) p.EnterOuterAlt(localctx, 1) { - p.SetState(2244) + p.SetState(2248) p.Match(CqlParserK_AS) if p.HasError() { // Recognition error - abort rule @@ -41594,10 +41976,10 @@ func (s *KwAscContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAsc() (localctx IKwAscContext) { localctx = NewKwAscContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 424, CqlParserRULE_kwAsc) + p.EnterRule(localctx, 432, CqlParserRULE_kwAsc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2246) + p.SetState(2250) p.Match(CqlParserK_ASC) if p.HasError() { // Recognition error - abort rule @@ -41690,10 +42072,10 @@ func (s *KwAuthorizeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwAuthorize() (localctx IKwAuthorizeContext) { localctx = NewKwAuthorizeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 426, CqlParserRULE_kwAuthorize) + p.EnterRule(localctx, 434, CqlParserRULE_kwAuthorize) p.EnterOuterAlt(localctx, 1) { - p.SetState(2248) + p.SetState(2252) p.Match(CqlParserK_AUTHORIZE) if p.HasError() { // Recognition error - abort rule @@ -41786,10 +42168,10 @@ func (s *KwBatchContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwBatch() (localctx IKwBatchContext) { localctx = NewKwBatchContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 428, CqlParserRULE_kwBatch) + p.EnterRule(localctx, 436, CqlParserRULE_kwBatch) p.EnterOuterAlt(localctx, 1) { - p.SetState(2250) + p.SetState(2254) p.Match(CqlParserK_BATCH) if p.HasError() { // Recognition error - abort rule @@ -41882,10 +42264,10 @@ func (s *KwBetweenContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwBetween() (localctx IKwBetweenContext) { localctx = NewKwBetweenContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 430, CqlParserRULE_kwBetween) + p.EnterRule(localctx, 438, CqlParserRULE_kwBetween) p.EnterOuterAlt(localctx, 1) { - p.SetState(2252) + p.SetState(2256) p.Match(CqlParserK_BETWEEN) if p.HasError() { // Recognition error - abort rule @@ -41978,10 +42360,10 @@ func (s *KwBeginContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwBegin() (localctx IKwBeginContext) { localctx = NewKwBeginContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 432, CqlParserRULE_kwBegin) + p.EnterRule(localctx, 440, CqlParserRULE_kwBegin) p.EnterOuterAlt(localctx, 1) { - p.SetState(2254) + p.SetState(2258) p.Match(CqlParserK_BEGIN) if p.HasError() { // Recognition error - abort rule @@ -42074,10 +42456,10 @@ func (s *KwByContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwBy() (localctx IKwByContext) { localctx = NewKwByContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 434, CqlParserRULE_kwBy) + p.EnterRule(localctx, 442, CqlParserRULE_kwBy) p.EnterOuterAlt(localctx, 1) { - p.SetState(2256) + p.SetState(2260) p.Match(CqlParserK_BY) if p.HasError() { // Recognition error - abort rule @@ -42170,10 +42552,10 @@ func (s *KwCalledContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwCalled() (localctx IKwCalledContext) { localctx = NewKwCalledContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 436, CqlParserRULE_kwCalled) + p.EnterRule(localctx, 444, CqlParserRULE_kwCalled) p.EnterOuterAlt(localctx, 1) { - p.SetState(2258) + p.SetState(2262) p.Match(CqlParserK_CALLED) if p.HasError() { // Recognition error - abort rule @@ -42266,10 +42648,10 @@ func (s *KwClusteringContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwClustering() (localctx IKwClusteringContext) { localctx = NewKwClusteringContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 438, CqlParserRULE_kwClustering) + p.EnterRule(localctx, 446, CqlParserRULE_kwClustering) p.EnterOuterAlt(localctx, 1) { - p.SetState(2260) + p.SetState(2264) p.Match(CqlParserK_CLUSTERING) if p.HasError() { // Recognition error - abort rule @@ -42362,10 +42744,10 @@ func (s *KwCompactContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwCompact() (localctx IKwCompactContext) { localctx = NewKwCompactContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 440, CqlParserRULE_kwCompact) + p.EnterRule(localctx, 448, CqlParserRULE_kwCompact) p.EnterOuterAlt(localctx, 1) { - p.SetState(2262) + p.SetState(2266) p.Match(CqlParserK_COMPACT) if p.HasError() { // Recognition error - abort rule @@ -42458,10 +42840,10 @@ func (s *KwContainsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwContains() (localctx IKwContainsContext) { localctx = NewKwContainsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 442, CqlParserRULE_kwContains) + p.EnterRule(localctx, 450, CqlParserRULE_kwContains) p.EnterOuterAlt(localctx, 1) { - p.SetState(2264) + p.SetState(2268) p.Match(CqlParserK_CONTAINS) if p.HasError() { // Recognition error - abort rule @@ -42554,10 +42936,10 @@ func (s *KwCreateContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwCreate() (localctx IKwCreateContext) { localctx = NewKwCreateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 444, CqlParserRULE_kwCreate) + p.EnterRule(localctx, 452, CqlParserRULE_kwCreate) p.EnterOuterAlt(localctx, 1) { - p.SetState(2266) + p.SetState(2270) p.Match(CqlParserK_CREATE) if p.HasError() { // Recognition error - abort rule @@ -42650,10 +43032,10 @@ func (s *KwDeleteContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDelete() (localctx IKwDeleteContext) { localctx = NewKwDeleteContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 446, CqlParserRULE_kwDelete) + p.EnterRule(localctx, 454, CqlParserRULE_kwDelete) p.EnterOuterAlt(localctx, 1) { - p.SetState(2268) + p.SetState(2272) p.Match(CqlParserK_DELETE) if p.HasError() { // Recognition error - abort rule @@ -42746,10 +43128,10 @@ func (s *KwDescContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDesc() (localctx IKwDescContext) { localctx = NewKwDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 448, CqlParserRULE_kwDesc) + p.EnterRule(localctx, 456, CqlParserRULE_kwDesc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2270) + p.SetState(2274) p.Match(CqlParserK_DESC) if p.HasError() { // Recognition error - abort rule @@ -42842,10 +43224,10 @@ func (s *KwDescibeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDescibe() (localctx IKwDescibeContext) { localctx = NewKwDescibeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 450, CqlParserRULE_kwDescibe) + p.EnterRule(localctx, 458, CqlParserRULE_kwDescibe) p.EnterOuterAlt(localctx, 1) { - p.SetState(2272) + p.SetState(2276) p.Match(CqlParserK_DESCRIBE) if p.HasError() { // Recognition error - abort rule @@ -42938,10 +43320,10 @@ func (s *KwDistinctContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDistinct() (localctx IKwDistinctContext) { localctx = NewKwDistinctContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 452, CqlParserRULE_kwDistinct) + p.EnterRule(localctx, 460, CqlParserRULE_kwDistinct) p.EnterOuterAlt(localctx, 1) { - p.SetState(2274) + p.SetState(2278) p.Match(CqlParserK_DISTINCT) if p.HasError() { // Recognition error - abort rule @@ -43034,10 +43416,10 @@ func (s *KwDropContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDrop() (localctx IKwDropContext) { localctx = NewKwDropContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 454, CqlParserRULE_kwDrop) + p.EnterRule(localctx, 462, CqlParserRULE_kwDrop) p.EnterOuterAlt(localctx, 1) { - p.SetState(2276) + p.SetState(2280) p.Match(CqlParserK_DROP) if p.HasError() { // Recognition error - abort rule @@ -43130,10 +43512,10 @@ func (s *KwDurableWritesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwDurableWrites() (localctx IKwDurableWritesContext) { localctx = NewKwDurableWritesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 456, CqlParserRULE_kwDurableWrites) + p.EnterRule(localctx, 464, CqlParserRULE_kwDurableWrites) p.EnterOuterAlt(localctx, 1) { - p.SetState(2278) + p.SetState(2282) p.Match(CqlParserK_DURABLE_WRITES) if p.HasError() { // Recognition error - abort rule @@ -43226,10 +43608,10 @@ func (s *KwEntriesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwEntries() (localctx IKwEntriesContext) { localctx = NewKwEntriesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 458, CqlParserRULE_kwEntries) + p.EnterRule(localctx, 466, CqlParserRULE_kwEntries) p.EnterOuterAlt(localctx, 1) { - p.SetState(2280) + p.SetState(2284) p.Match(CqlParserK_ENTRIES) if p.HasError() { // Recognition error - abort rule @@ -43322,10 +43704,10 @@ func (s *KwExecuteContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwExecute() (localctx IKwExecuteContext) { localctx = NewKwExecuteContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 460, CqlParserRULE_kwExecute) + p.EnterRule(localctx, 468, CqlParserRULE_kwExecute) p.EnterOuterAlt(localctx, 1) { - p.SetState(2282) + p.SetState(2286) p.Match(CqlParserK_EXECUTE) if p.HasError() { // Recognition error - abort rule @@ -43418,10 +43800,10 @@ func (s *KwExistsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwExists() (localctx IKwExistsContext) { localctx = NewKwExistsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 462, CqlParserRULE_kwExists) + p.EnterRule(localctx, 470, CqlParserRULE_kwExists) p.EnterOuterAlt(localctx, 1) { - p.SetState(2284) + p.SetState(2288) p.Match(CqlParserK_EXISTS) if p.HasError() { // Recognition error - abort rule @@ -43514,10 +43896,10 @@ func (s *KwFilteringContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFiltering() (localctx IKwFilteringContext) { localctx = NewKwFilteringContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 464, CqlParserRULE_kwFiltering) + p.EnterRule(localctx, 472, CqlParserRULE_kwFiltering) p.EnterOuterAlt(localctx, 1) { - p.SetState(2286) + p.SetState(2290) p.Match(CqlParserK_FILTERING) if p.HasError() { // Recognition error - abort rule @@ -43610,10 +43992,10 @@ func (s *KwFinalfuncContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFinalfunc() (localctx IKwFinalfuncContext) { localctx = NewKwFinalfuncContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 466, CqlParserRULE_kwFinalfunc) + p.EnterRule(localctx, 474, CqlParserRULE_kwFinalfunc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2288) + p.SetState(2292) p.Match(CqlParserK_FINALFUNC) if p.HasError() { // Recognition error - abort rule @@ -43706,10 +44088,10 @@ func (s *KwFromContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFrom() (localctx IKwFromContext) { localctx = NewKwFromContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 468, CqlParserRULE_kwFrom) + p.EnterRule(localctx, 476, CqlParserRULE_kwFrom) p.EnterOuterAlt(localctx, 1) { - p.SetState(2290) + p.SetState(2294) p.Match(CqlParserK_FROM) if p.HasError() { // Recognition error - abort rule @@ -43802,10 +44184,10 @@ func (s *KwFullContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFull() (localctx IKwFullContext) { localctx = NewKwFullContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 470, CqlParserRULE_kwFull) + p.EnterRule(localctx, 478, CqlParserRULE_kwFull) p.EnterOuterAlt(localctx, 1) { - p.SetState(2292) + p.SetState(2296) p.Match(CqlParserK_FULL) if p.HasError() { // Recognition error - abort rule @@ -43898,10 +44280,10 @@ func (s *KwFunctionContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFunction() (localctx IKwFunctionContext) { localctx = NewKwFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 472, CqlParserRULE_kwFunction) + p.EnterRule(localctx, 480, CqlParserRULE_kwFunction) p.EnterOuterAlt(localctx, 1) { - p.SetState(2294) + p.SetState(2298) p.Match(CqlParserK_FUNCTION) if p.HasError() { // Recognition error - abort rule @@ -43994,10 +44376,10 @@ func (s *KwFunctionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwFunctions() (localctx IKwFunctionsContext) { localctx = NewKwFunctionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 474, CqlParserRULE_kwFunctions) + p.EnterRule(localctx, 482, CqlParserRULE_kwFunctions) p.EnterOuterAlt(localctx, 1) { - p.SetState(2296) + p.SetState(2300) p.Match(CqlParserK_FUNCTIONS) if p.HasError() { // Recognition error - abort rule @@ -44090,10 +44472,10 @@ func (s *KwGrantContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwGrant() (localctx IKwGrantContext) { localctx = NewKwGrantContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 476, CqlParserRULE_kwGrant) + p.EnterRule(localctx, 484, CqlParserRULE_kwGrant) p.EnterOuterAlt(localctx, 1) { - p.SetState(2298) + p.SetState(2302) p.Match(CqlParserK_GRANT) if p.HasError() { // Recognition error - abort rule @@ -44186,10 +44568,10 @@ func (s *KwIfContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwIf() (localctx IKwIfContext) { localctx = NewKwIfContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 478, CqlParserRULE_kwIf) + p.EnterRule(localctx, 486, CqlParserRULE_kwIf) p.EnterOuterAlt(localctx, 1) { - p.SetState(2300) + p.SetState(2304) p.Match(CqlParserK_IF) if p.HasError() { // Recognition error - abort rule @@ -44282,10 +44664,10 @@ func (s *KwInContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwIn() (localctx IKwInContext) { localctx = NewKwInContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 480, CqlParserRULE_kwIn) + p.EnterRule(localctx, 488, CqlParserRULE_kwIn) p.EnterOuterAlt(localctx, 1) { - p.SetState(2302) + p.SetState(2306) p.Match(CqlParserK_IN) if p.HasError() { // Recognition error - abort rule @@ -44378,10 +44760,10 @@ func (s *KwIndexContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwIndex() (localctx IKwIndexContext) { localctx = NewKwIndexContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 482, CqlParserRULE_kwIndex) + p.EnterRule(localctx, 490, CqlParserRULE_kwIndex) p.EnterOuterAlt(localctx, 1) { - p.SetState(2304) + p.SetState(2308) p.Match(CqlParserK_INDEX) if p.HasError() { // Recognition error - abort rule @@ -44474,10 +44856,10 @@ func (s *KwInitcondContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwInitcond() (localctx IKwInitcondContext) { localctx = NewKwInitcondContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 484, CqlParserRULE_kwInitcond) + p.EnterRule(localctx, 492, CqlParserRULE_kwInitcond) p.EnterOuterAlt(localctx, 1) { - p.SetState(2306) + p.SetState(2310) p.Match(CqlParserK_INITCOND) if p.HasError() { // Recognition error - abort rule @@ -44570,10 +44952,10 @@ func (s *KwInputContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwInput() (localctx IKwInputContext) { localctx = NewKwInputContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 486, CqlParserRULE_kwInput) + p.EnterRule(localctx, 494, CqlParserRULE_kwInput) p.EnterOuterAlt(localctx, 1) { - p.SetState(2308) + p.SetState(2312) p.Match(CqlParserK_INPUT) if p.HasError() { // Recognition error - abort rule @@ -44666,10 +45048,10 @@ func (s *KwInsertContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwInsert() (localctx IKwInsertContext) { localctx = NewKwInsertContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 488, CqlParserRULE_kwInsert) + p.EnterRule(localctx, 496, CqlParserRULE_kwInsert) p.EnterOuterAlt(localctx, 1) { - p.SetState(2310) + p.SetState(2314) p.Match(CqlParserK_INSERT) if p.HasError() { // Recognition error - abort rule @@ -44762,10 +45144,10 @@ func (s *KwIntoContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwInto() (localctx IKwIntoContext) { localctx = NewKwIntoContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 490, CqlParserRULE_kwInto) + p.EnterRule(localctx, 498, CqlParserRULE_kwInto) p.EnterOuterAlt(localctx, 1) { - p.SetState(2312) + p.SetState(2316) p.Match(CqlParserK_INTO) if p.HasError() { // Recognition error - abort rule @@ -44858,10 +45240,10 @@ func (s *KwIsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwIs() (localctx IKwIsContext) { localctx = NewKwIsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 492, CqlParserRULE_kwIs) + p.EnterRule(localctx, 500, CqlParserRULE_kwIs) p.EnterOuterAlt(localctx, 1) { - p.SetState(2314) + p.SetState(2318) p.Match(CqlParserK_IS) if p.HasError() { // Recognition error - abort rule @@ -44954,10 +45336,10 @@ func (s *KwJsonContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwJson() (localctx IKwJsonContext) { localctx = NewKwJsonContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 494, CqlParserRULE_kwJson) + p.EnterRule(localctx, 502, CqlParserRULE_kwJson) p.EnterOuterAlt(localctx, 1) { - p.SetState(2316) + p.SetState(2320) p.Match(CqlParserK_JSON) if p.HasError() { // Recognition error - abort rule @@ -45050,10 +45432,10 @@ func (s *KwKeyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwKey() (localctx IKwKeyContext) { localctx = NewKwKeyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 496, CqlParserRULE_kwKey) + p.EnterRule(localctx, 504, CqlParserRULE_kwKey) p.EnterOuterAlt(localctx, 1) { - p.SetState(2318) + p.SetState(2322) p.Match(CqlParserK_KEY) if p.HasError() { // Recognition error - abort rule @@ -45146,10 +45528,10 @@ func (s *KwKeysContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwKeys() (localctx IKwKeysContext) { localctx = NewKwKeysContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 498, CqlParserRULE_kwKeys) + p.EnterRule(localctx, 506, CqlParserRULE_kwKeys) p.EnterOuterAlt(localctx, 1) { - p.SetState(2320) + p.SetState(2324) p.Match(CqlParserK_KEYS) if p.HasError() { // Recognition error - abort rule @@ -45242,10 +45624,10 @@ func (s *KwKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwKeyspace() (localctx IKwKeyspaceContext) { localctx = NewKwKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 500, CqlParserRULE_kwKeyspace) + p.EnterRule(localctx, 508, CqlParserRULE_kwKeyspace) p.EnterOuterAlt(localctx, 1) { - p.SetState(2322) + p.SetState(2326) p.Match(CqlParserK_KEYSPACE) if p.HasError() { // Recognition error - abort rule @@ -45338,10 +45720,10 @@ func (s *KwKeyspacesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwKeyspaces() (localctx IKwKeyspacesContext) { localctx = NewKwKeyspacesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 502, CqlParserRULE_kwKeyspaces) + p.EnterRule(localctx, 510, CqlParserRULE_kwKeyspaces) p.EnterOuterAlt(localctx, 1) { - p.SetState(2324) + p.SetState(2328) p.Match(CqlParserK_KEYSPACES) if p.HasError() { // Recognition error - abort rule @@ -45434,10 +45816,10 @@ func (s *KwLanguageContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwLanguage() (localctx IKwLanguageContext) { localctx = NewKwLanguageContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 504, CqlParserRULE_kwLanguage) + p.EnterRule(localctx, 512, CqlParserRULE_kwLanguage) p.EnterOuterAlt(localctx, 1) { - p.SetState(2326) + p.SetState(2330) p.Match(CqlParserK_LANGUAGE) if p.HasError() { // Recognition error - abort rule @@ -45530,10 +45912,10 @@ func (s *KwLimitContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwLimit() (localctx IKwLimitContext) { localctx = NewKwLimitContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 506, CqlParserRULE_kwLimit) + p.EnterRule(localctx, 514, CqlParserRULE_kwLimit) p.EnterOuterAlt(localctx, 1) { - p.SetState(2328) + p.SetState(2332) p.Match(CqlParserK_LIMIT) if p.HasError() { // Recognition error - abort rule @@ -45626,10 +46008,10 @@ func (s *KwListContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwList() (localctx IKwListContext) { localctx = NewKwListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 508, CqlParserRULE_kwList) + p.EnterRule(localctx, 516, CqlParserRULE_kwList) p.EnterOuterAlt(localctx, 1) { - p.SetState(2330) + p.SetState(2334) p.Match(CqlParserK_LIST) if p.HasError() { // Recognition error - abort rule @@ -45722,10 +46104,10 @@ func (s *KwLoggedContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwLogged() (localctx IKwLoggedContext) { localctx = NewKwLoggedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 510, CqlParserRULE_kwLogged) + p.EnterRule(localctx, 518, CqlParserRULE_kwLogged) p.EnterOuterAlt(localctx, 1) { - p.SetState(2332) + p.SetState(2336) p.Match(CqlParserK_LOGGED) if p.HasError() { // Recognition error - abort rule @@ -45818,10 +46200,10 @@ func (s *KwLoginContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwLogin() (localctx IKwLoginContext) { localctx = NewKwLoginContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 512, CqlParserRULE_kwLogin) + p.EnterRule(localctx, 520, CqlParserRULE_kwLogin) p.EnterOuterAlt(localctx, 1) { - p.SetState(2334) + p.SetState(2338) p.Match(CqlParserK_LOGIN) if p.HasError() { // Recognition error - abort rule @@ -45914,10 +46296,10 @@ func (s *KwMaterializedContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwMaterialized() (localctx IKwMaterializedContext) { localctx = NewKwMaterializedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 514, CqlParserRULE_kwMaterialized) + p.EnterRule(localctx, 522, CqlParserRULE_kwMaterialized) p.EnterOuterAlt(localctx, 1) { - p.SetState(2336) + p.SetState(2340) p.Match(CqlParserK_MATERIALIZED) if p.HasError() { // Recognition error - abort rule @@ -46010,10 +46392,10 @@ func (s *KwModifyContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwModify() (localctx IKwModifyContext) { localctx = NewKwModifyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 516, CqlParserRULE_kwModify) + p.EnterRule(localctx, 524, CqlParserRULE_kwModify) p.EnterOuterAlt(localctx, 1) { - p.SetState(2338) + p.SetState(2342) p.Match(CqlParserK_MODIFY) if p.HasError() { // Recognition error - abort rule @@ -46106,10 +46488,10 @@ func (s *KwNosuperuserContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwNosuperuser() (localctx IKwNosuperuserContext) { localctx = NewKwNosuperuserContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 518, CqlParserRULE_kwNosuperuser) + p.EnterRule(localctx, 526, CqlParserRULE_kwNosuperuser) p.EnterOuterAlt(localctx, 1) { - p.SetState(2340) + p.SetState(2344) p.Match(CqlParserK_NOSUPERUSER) if p.HasError() { // Recognition error - abort rule @@ -46202,10 +46584,10 @@ func (s *KwNorecursiveContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwNorecursive() (localctx IKwNorecursiveContext) { localctx = NewKwNorecursiveContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 520, CqlParserRULE_kwNorecursive) + p.EnterRule(localctx, 528, CqlParserRULE_kwNorecursive) p.EnterOuterAlt(localctx, 1) { - p.SetState(2342) + p.SetState(2346) p.Match(CqlParserK_NORECURSIVE) if p.HasError() { // Recognition error - abort rule @@ -46298,10 +46680,10 @@ func (s *KwNotContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwNot() (localctx IKwNotContext) { localctx = NewKwNotContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 522, CqlParserRULE_kwNot) + p.EnterRule(localctx, 530, CqlParserRULE_kwNot) p.EnterOuterAlt(localctx, 1) { - p.SetState(2344) + p.SetState(2348) p.Match(CqlParserK_NOT) if p.HasError() { // Recognition error - abort rule @@ -46394,10 +46776,10 @@ func (s *KwNullContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwNull() (localctx IKwNullContext) { localctx = NewKwNullContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 524, CqlParserRULE_kwNull) + p.EnterRule(localctx, 532, CqlParserRULE_kwNull) p.EnterOuterAlt(localctx, 1) { - p.SetState(2346) + p.SetState(2350) p.Match(CqlParserK_NULL) if p.HasError() { // Recognition error - abort rule @@ -46490,10 +46872,10 @@ func (s *KwOfContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwOf() (localctx IKwOfContext) { localctx = NewKwOfContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 526, CqlParserRULE_kwOf) + p.EnterRule(localctx, 534, CqlParserRULE_kwOf) p.EnterOuterAlt(localctx, 1) { - p.SetState(2348) + p.SetState(2352) p.Match(CqlParserK_OF) if p.HasError() { // Recognition error - abort rule @@ -46586,10 +46968,10 @@ func (s *KwOnContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwOn() (localctx IKwOnContext) { localctx = NewKwOnContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 528, CqlParserRULE_kwOn) + p.EnterRule(localctx, 536, CqlParserRULE_kwOn) p.EnterOuterAlt(localctx, 1) { - p.SetState(2350) + p.SetState(2354) p.Match(CqlParserK_ON) if p.HasError() { // Recognition error - abort rule @@ -46682,10 +47064,10 @@ func (s *KwOptionsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwOptions() (localctx IKwOptionsContext) { localctx = NewKwOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 530, CqlParserRULE_kwOptions) + p.EnterRule(localctx, 538, CqlParserRULE_kwOptions) p.EnterOuterAlt(localctx, 1) { - p.SetState(2352) + p.SetState(2356) p.Match(CqlParserK_OPTIONS) if p.HasError() { // Recognition error - abort rule @@ -46778,10 +47160,10 @@ func (s *KwOrContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwOr() (localctx IKwOrContext) { localctx = NewKwOrContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 532, CqlParserRULE_kwOr) + p.EnterRule(localctx, 540, CqlParserRULE_kwOr) p.EnterOuterAlt(localctx, 1) { - p.SetState(2354) + p.SetState(2358) p.Match(CqlParserK_OR) if p.HasError() { // Recognition error - abort rule @@ -46874,10 +47256,10 @@ func (s *KwOrderContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwOrder() (localctx IKwOrderContext) { localctx = NewKwOrderContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 534, CqlParserRULE_kwOrder) + p.EnterRule(localctx, 542, CqlParserRULE_kwOrder) p.EnterOuterAlt(localctx, 1) { - p.SetState(2356) + p.SetState(2360) p.Match(CqlParserK_ORDER) if p.HasError() { // Recognition error - abort rule @@ -46970,10 +47352,10 @@ func (s *KwPasswordContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwPassword() (localctx IKwPasswordContext) { localctx = NewKwPasswordContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 536, CqlParserRULE_kwPassword) + p.EnterRule(localctx, 544, CqlParserRULE_kwPassword) p.EnterOuterAlt(localctx, 1) { - p.SetState(2358) + p.SetState(2362) p.Match(CqlParserK_PASSWORD) if p.HasError() { // Recognition error - abort rule @@ -47066,10 +47448,10 @@ func (s *KwPrimaryContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwPrimary() (localctx IKwPrimaryContext) { localctx = NewKwPrimaryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 538, CqlParserRULE_kwPrimary) + p.EnterRule(localctx, 546, CqlParserRULE_kwPrimary) p.EnterOuterAlt(localctx, 1) { - p.SetState(2360) + p.SetState(2364) p.Match(CqlParserK_PRIMARY) if p.HasError() { // Recognition error - abort rule @@ -47162,10 +47544,10 @@ func (s *KwRenameContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwRename() (localctx IKwRenameContext) { localctx = NewKwRenameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 540, CqlParserRULE_kwRename) + p.EnterRule(localctx, 548, CqlParserRULE_kwRename) p.EnterOuterAlt(localctx, 1) { - p.SetState(2362) + p.SetState(2366) p.Match(CqlParserK_RENAME) if p.HasError() { // Recognition error - abort rule @@ -47258,10 +47640,10 @@ func (s *KwReplaceContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwReplace() (localctx IKwReplaceContext) { localctx = NewKwReplaceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 542, CqlParserRULE_kwReplace) + p.EnterRule(localctx, 550, CqlParserRULE_kwReplace) p.EnterOuterAlt(localctx, 1) { - p.SetState(2364) + p.SetState(2368) p.Match(CqlParserK_REPLACE) if p.HasError() { // Recognition error - abort rule @@ -47354,10 +47736,10 @@ func (s *KwReplicationContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwReplication() (localctx IKwReplicationContext) { localctx = NewKwReplicationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 544, CqlParserRULE_kwReplication) + p.EnterRule(localctx, 552, CqlParserRULE_kwReplication) p.EnterOuterAlt(localctx, 1) { - p.SetState(2366) + p.SetState(2370) p.Match(CqlParserK_REPLICATION) if p.HasError() { // Recognition error - abort rule @@ -47450,10 +47832,10 @@ func (s *KwReturnsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwReturns() (localctx IKwReturnsContext) { localctx = NewKwReturnsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 546, CqlParserRULE_kwReturns) + p.EnterRule(localctx, 554, CqlParserRULE_kwReturns) p.EnterOuterAlt(localctx, 1) { - p.SetState(2368) + p.SetState(2372) p.Match(CqlParserK_RETURNS) if p.HasError() { // Recognition error - abort rule @@ -47546,10 +47928,10 @@ func (s *KwRoleContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwRole() (localctx IKwRoleContext) { localctx = NewKwRoleContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 548, CqlParserRULE_kwRole) + p.EnterRule(localctx, 556, CqlParserRULE_kwRole) p.EnterOuterAlt(localctx, 1) { - p.SetState(2370) + p.SetState(2374) p.Match(CqlParserK_ROLE) if p.HasError() { // Recognition error - abort rule @@ -47642,10 +48024,10 @@ func (s *KwRolesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwRoles() (localctx IKwRolesContext) { localctx = NewKwRolesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 550, CqlParserRULE_kwRoles) + p.EnterRule(localctx, 558, CqlParserRULE_kwRoles) p.EnterOuterAlt(localctx, 1) { - p.SetState(2372) + p.SetState(2376) p.Match(CqlParserK_ROLES) if p.HasError() { // Recognition error - abort rule @@ -47738,10 +48120,10 @@ func (s *KwSelectContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwSelect() (localctx IKwSelectContext) { localctx = NewKwSelectContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 552, CqlParserRULE_kwSelect) + p.EnterRule(localctx, 560, CqlParserRULE_kwSelect) p.EnterOuterAlt(localctx, 1) { - p.SetState(2374) + p.SetState(2378) p.Match(CqlParserK_SELECT) if p.HasError() { // Recognition error - abort rule @@ -47834,10 +48216,10 @@ func (s *KwSetContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwSet() (localctx IKwSetContext) { localctx = NewKwSetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 554, CqlParserRULE_kwSet) + p.EnterRule(localctx, 562, CqlParserRULE_kwSet) p.EnterOuterAlt(localctx, 1) { - p.SetState(2376) + p.SetState(2380) p.Match(CqlParserK_SET) if p.HasError() { // Recognition error - abort rule @@ -47930,10 +48312,10 @@ func (s *KwSfuncContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwSfunc() (localctx IKwSfuncContext) { localctx = NewKwSfuncContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 556, CqlParserRULE_kwSfunc) + p.EnterRule(localctx, 564, CqlParserRULE_kwSfunc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2378) + p.SetState(2382) p.Match(CqlParserK_SFUNC) if p.HasError() { // Recognition error - abort rule @@ -48026,10 +48408,10 @@ func (s *KwStorageContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwStorage() (localctx IKwStorageContext) { localctx = NewKwStorageContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 558, CqlParserRULE_kwStorage) + p.EnterRule(localctx, 566, CqlParserRULE_kwStorage) p.EnterOuterAlt(localctx, 1) { - p.SetState(2380) + p.SetState(2384) p.Match(CqlParserK_STORAGE) if p.HasError() { // Recognition error - abort rule @@ -48122,10 +48504,10 @@ func (s *KwStypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwStype() (localctx IKwStypeContext) { localctx = NewKwStypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 560, CqlParserRULE_kwStype) + p.EnterRule(localctx, 568, CqlParserRULE_kwStype) p.EnterOuterAlt(localctx, 1) { - p.SetState(2382) + p.SetState(2386) p.Match(CqlParserK_STYPE) if p.HasError() { // Recognition error - abort rule @@ -48218,10 +48600,10 @@ func (s *KwSuperuserContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwSuperuser() (localctx IKwSuperuserContext) { localctx = NewKwSuperuserContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 562, CqlParserRULE_kwSuperuser) + p.EnterRule(localctx, 570, CqlParserRULE_kwSuperuser) p.EnterOuterAlt(localctx, 1) { - p.SetState(2384) + p.SetState(2388) p.Match(CqlParserK_SUPERUSER) if p.HasError() { // Recognition error - abort rule @@ -48314,10 +48696,10 @@ func (s *KwTableContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTable() (localctx IKwTableContext) { localctx = NewKwTableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 564, CqlParserRULE_kwTable) + p.EnterRule(localctx, 572, CqlParserRULE_kwTable) p.EnterOuterAlt(localctx, 1) { - p.SetState(2386) + p.SetState(2390) p.Match(CqlParserK_TABLE) if p.HasError() { // Recognition error - abort rule @@ -48410,10 +48792,10 @@ func (s *KwTablesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTables() (localctx IKwTablesContext) { localctx = NewKwTablesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 566, CqlParserRULE_kwTables) + p.EnterRule(localctx, 574, CqlParserRULE_kwTables) p.EnterOuterAlt(localctx, 1) { - p.SetState(2388) + p.SetState(2392) p.Match(CqlParserK_TABLES) if p.HasError() { // Recognition error - abort rule @@ -48506,10 +48888,10 @@ func (s *KwTimestampContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTimestamp() (localctx IKwTimestampContext) { localctx = NewKwTimestampContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 568, CqlParserRULE_kwTimestamp) + p.EnterRule(localctx, 576, CqlParserRULE_kwTimestamp) p.EnterOuterAlt(localctx, 1) { - p.SetState(2390) + p.SetState(2394) p.Match(CqlParserK_TIMESTAMP) if p.HasError() { // Recognition error - abort rule @@ -48602,10 +48984,10 @@ func (s *KwToContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTo() (localctx IKwToContext) { localctx = NewKwToContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 570, CqlParserRULE_kwTo) + p.EnterRule(localctx, 578, CqlParserRULE_kwTo) p.EnterOuterAlt(localctx, 1) { - p.SetState(2392) + p.SetState(2396) p.Match(CqlParserK_TO) if p.HasError() { // Recognition error - abort rule @@ -48698,10 +49080,10 @@ func (s *KwTriggerContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTrigger() (localctx IKwTriggerContext) { localctx = NewKwTriggerContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 572, CqlParserRULE_kwTrigger) + p.EnterRule(localctx, 580, CqlParserRULE_kwTrigger) p.EnterOuterAlt(localctx, 1) { - p.SetState(2394) + p.SetState(2398) p.Match(CqlParserK_TRIGGER) if p.HasError() { // Recognition error - abort rule @@ -48794,10 +49176,10 @@ func (s *KwTruncateContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTruncate() (localctx IKwTruncateContext) { localctx = NewKwTruncateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 574, CqlParserRULE_kwTruncate) + p.EnterRule(localctx, 582, CqlParserRULE_kwTruncate) p.EnterOuterAlt(localctx, 1) { - p.SetState(2396) + p.SetState(2400) p.Match(CqlParserK_TRUNCATE) if p.HasError() { // Recognition error - abort rule @@ -48890,10 +49272,10 @@ func (s *KwTtlContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwTtl() (localctx IKwTtlContext) { localctx = NewKwTtlContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 576, CqlParserRULE_kwTtl) + p.EnterRule(localctx, 584, CqlParserRULE_kwTtl) p.EnterOuterAlt(localctx, 1) { - p.SetState(2398) + p.SetState(2402) p.Match(CqlParserK_TTL) if p.HasError() { // Recognition error - abort rule @@ -48986,10 +49368,10 @@ func (s *KwTypeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwType() (localctx IKwTypeContext) { localctx = NewKwTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 578, CqlParserRULE_kwType) + p.EnterRule(localctx, 586, CqlParserRULE_kwType) p.EnterOuterAlt(localctx, 1) { - p.SetState(2400) + p.SetState(2404) p.Match(CqlParserK_TYPE) if p.HasError() { // Recognition error - abort rule @@ -49082,10 +49464,10 @@ func (s *KwUnloggedContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwUnlogged() (localctx IKwUnloggedContext) { localctx = NewKwUnloggedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 580, CqlParserRULE_kwUnlogged) + p.EnterRule(localctx, 588, CqlParserRULE_kwUnlogged) p.EnterOuterAlt(localctx, 1) { - p.SetState(2402) + p.SetState(2406) p.Match(CqlParserK_UNLOGGED) if p.HasError() { // Recognition error - abort rule @@ -49178,10 +49560,10 @@ func (s *KwUpdateContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwUpdate() (localctx IKwUpdateContext) { localctx = NewKwUpdateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 582, CqlParserRULE_kwUpdate) + p.EnterRule(localctx, 590, CqlParserRULE_kwUpdate) p.EnterOuterAlt(localctx, 1) { - p.SetState(2404) + p.SetState(2408) p.Match(CqlParserK_UPDATE) if p.HasError() { // Recognition error - abort rule @@ -49274,10 +49656,10 @@ func (s *KwUseContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwUse() (localctx IKwUseContext) { localctx = NewKwUseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 584, CqlParserRULE_kwUse) + p.EnterRule(localctx, 592, CqlParserRULE_kwUse) p.EnterOuterAlt(localctx, 1) { - p.SetState(2406) + p.SetState(2410) p.Match(CqlParserK_USE) if p.HasError() { // Recognition error - abort rule @@ -49370,10 +49752,10 @@ func (s *KwUserContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwUser() (localctx IKwUserContext) { localctx = NewKwUserContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 586, CqlParserRULE_kwUser) + p.EnterRule(localctx, 594, CqlParserRULE_kwUser) p.EnterOuterAlt(localctx, 1) { - p.SetState(2408) + p.SetState(2412) p.Match(CqlParserK_USER) if p.HasError() { // Recognition error - abort rule @@ -49466,10 +49848,10 @@ func (s *KwUsingContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwUsing() (localctx IKwUsingContext) { localctx = NewKwUsingContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 588, CqlParserRULE_kwUsing) + p.EnterRule(localctx, 596, CqlParserRULE_kwUsing) p.EnterOuterAlt(localctx, 1) { - p.SetState(2410) + p.SetState(2414) p.Match(CqlParserK_USING) if p.HasError() { // Recognition error - abort rule @@ -49562,10 +49944,10 @@ func (s *KwValuesContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwValues() (localctx IKwValuesContext) { localctx = NewKwValuesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 590, CqlParserRULE_kwValues) + p.EnterRule(localctx, 598, CqlParserRULE_kwValues) p.EnterOuterAlt(localctx, 1) { - p.SetState(2412) + p.SetState(2416) p.Match(CqlParserK_VALUES) if p.HasError() { // Recognition error - abort rule @@ -49658,10 +50040,10 @@ func (s *KwViewContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwView() (localctx IKwViewContext) { localctx = NewKwViewContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 592, CqlParserRULE_kwView) + p.EnterRule(localctx, 600, CqlParserRULE_kwView) p.EnterOuterAlt(localctx, 1) { - p.SetState(2414) + p.SetState(2418) p.Match(CqlParserK_VIEW) if p.HasError() { // Recognition error - abort rule @@ -49754,10 +50136,10 @@ func (s *KwWhereContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwWhere() (localctx IKwWhereContext) { localctx = NewKwWhereContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 594, CqlParserRULE_kwWhere) + p.EnterRule(localctx, 602, CqlParserRULE_kwWhere) p.EnterOuterAlt(localctx, 1) { - p.SetState(2416) + p.SetState(2420) p.Match(CqlParserK_WHERE) if p.HasError() { // Recognition error - abort rule @@ -49850,10 +50232,10 @@ func (s *KwWithContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwWith() (localctx IKwWithContext) { localctx = NewKwWithContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 596, CqlParserRULE_kwWith) + p.EnterRule(localctx, 604, CqlParserRULE_kwWith) p.EnterOuterAlt(localctx, 1) { - p.SetState(2418) + p.SetState(2422) p.Match(CqlParserK_WITH) if p.HasError() { // Recognition error - abort rule @@ -49946,10 +50328,10 @@ func (s *KwRevokeContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwRevoke() (localctx IKwRevokeContext) { localctx = NewKwRevokeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 598, CqlParserRULE_kwRevoke) + p.EnterRule(localctx, 606, CqlParserRULE_kwRevoke) p.EnterOuterAlt(localctx, 1) { - p.SetState(2420) + p.SetState(2424) p.Match(CqlParserK_REVOKE) if p.HasError() { // Recognition error - abort rule @@ -50042,10 +50424,10 @@ func (s *KwGroupContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) KwGroup() (localctx IKwGroupContext) { localctx = NewKwGroupContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 600, CqlParserRULE_kwGroup) + p.EnterRule(localctx, 608, CqlParserRULE_kwGroup) p.EnterOuterAlt(localctx, 1) { - p.SetState(2422) + p.SetState(2426) p.Match(CqlParserK_GROUP) if p.HasError() { // Recognition error - abort rule @@ -50138,10 +50520,10 @@ func (s *SyntaxBracketLrContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketLr() (localctx ISyntaxBracketLrContext) { localctx = NewSyntaxBracketLrContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 602, CqlParserRULE_syntaxBracketLr) + p.EnterRule(localctx, 610, CqlParserRULE_syntaxBracketLr) p.EnterOuterAlt(localctx, 1) { - p.SetState(2424) + p.SetState(2428) p.Match(CqlParserLR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50234,10 +50616,10 @@ func (s *SyntaxBracketRrContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketRr() (localctx ISyntaxBracketRrContext) { localctx = NewSyntaxBracketRrContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 604, CqlParserRULE_syntaxBracketRr) + p.EnterRule(localctx, 612, CqlParserRULE_syntaxBracketRr) p.EnterOuterAlt(localctx, 1) { - p.SetState(2426) + p.SetState(2430) p.Match(CqlParserRR_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50330,10 +50712,10 @@ func (s *SyntaxBracketLcContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketLc() (localctx ISyntaxBracketLcContext) { localctx = NewSyntaxBracketLcContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 606, CqlParserRULE_syntaxBracketLc) + p.EnterRule(localctx, 614, CqlParserRULE_syntaxBracketLc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2428) + p.SetState(2432) p.Match(CqlParserLC_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50426,10 +50808,10 @@ func (s *SyntaxBracketRcContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketRc() (localctx ISyntaxBracketRcContext) { localctx = NewSyntaxBracketRcContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 608, CqlParserRULE_syntaxBracketRc) + p.EnterRule(localctx, 616, CqlParserRULE_syntaxBracketRc) p.EnterOuterAlt(localctx, 1) { - p.SetState(2430) + p.SetState(2434) p.Match(CqlParserRC_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50522,10 +50904,10 @@ func (s *SyntaxBracketLaContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketLa() (localctx ISyntaxBracketLaContext) { localctx = NewSyntaxBracketLaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 610, CqlParserRULE_syntaxBracketLa) + p.EnterRule(localctx, 618, CqlParserRULE_syntaxBracketLa) p.EnterOuterAlt(localctx, 1) { - p.SetState(2432) + p.SetState(2436) p.Match(CqlParserOPERATOR_LT) if p.HasError() { // Recognition error - abort rule @@ -50618,10 +51000,10 @@ func (s *SyntaxBracketRaContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketRa() (localctx ISyntaxBracketRaContext) { localctx = NewSyntaxBracketRaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 612, CqlParserRULE_syntaxBracketRa) + p.EnterRule(localctx, 620, CqlParserRULE_syntaxBracketRa) p.EnterOuterAlt(localctx, 1) { - p.SetState(2434) + p.SetState(2438) p.Match(CqlParserOPERATOR_GT) if p.HasError() { // Recognition error - abort rule @@ -50714,10 +51096,10 @@ func (s *SyntaxBracketLsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketLs() (localctx ISyntaxBracketLsContext) { localctx = NewSyntaxBracketLsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 614, CqlParserRULE_syntaxBracketLs) + p.EnterRule(localctx, 622, CqlParserRULE_syntaxBracketLs) p.EnterOuterAlt(localctx, 1) { - p.SetState(2436) + p.SetState(2440) p.Match(CqlParserLS_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50810,10 +51192,10 @@ func (s *SyntaxBracketRsContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxBracketRs() (localctx ISyntaxBracketRsContext) { localctx = NewSyntaxBracketRsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 616, CqlParserRULE_syntaxBracketRs) + p.EnterRule(localctx, 624, CqlParserRULE_syntaxBracketRs) p.EnterOuterAlt(localctx, 1) { - p.SetState(2438) + p.SetState(2442) p.Match(CqlParserRS_BRACKET) if p.HasError() { // Recognition error - abort rule @@ -50906,10 +51288,10 @@ func (s *SyntaxCommaContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxComma() (localctx ISyntaxCommaContext) { localctx = NewSyntaxCommaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 618, CqlParserRULE_syntaxComma) + p.EnterRule(localctx, 626, CqlParserRULE_syntaxComma) p.EnterOuterAlt(localctx, 1) { - p.SetState(2440) + p.SetState(2444) p.Match(CqlParserCOMMA) if p.HasError() { // Recognition error - abort rule @@ -51002,10 +51384,10 @@ func (s *SyntaxColonContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) SyntaxColon() (localctx ISyntaxColonContext) { localctx = NewSyntaxColonContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 620, CqlParserRULE_syntaxColon) + p.EnterRule(localctx, 628, CqlParserRULE_syntaxColon) p.EnterOuterAlt(localctx, 1) { - p.SetState(2442) + p.SetState(2446) p.Match(CqlParserCOLON) if p.HasError() { // Recognition error - abort rule @@ -51213,23 +51595,23 @@ func (s *GroupSpecContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) GroupSpec() (localctx IGroupSpecContext) { localctx = NewGroupSpecContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 622, CqlParserRULE_groupSpec) + p.EnterRule(localctx, 630, CqlParserRULE_groupSpec) var _la int p.EnterOuterAlt(localctx, 1) { - p.SetState(2444) + p.SetState(2448) p.KwGroup() } { - p.SetState(2445) + p.SetState(2449) p.KwBy() } { - p.SetState(2446) + p.SetState(2450) p.GroupSpecElement() } - p.SetState(2452) + p.SetState(2456) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51238,15 +51620,15 @@ func (p *CqlParser) GroupSpec() (localctx IGroupSpecContext) { for _la == CqlParserCOMMA { { - p.SetState(2447) + p.SetState(2451) p.SyntaxComma() } { - p.SetState(2448) + p.SetState(2452) p.GroupSpecElement() } - p.SetState(2454) + p.SetState(2458) p.GetErrorHandler().Sync(p) if p.HasError() { goto errorExit @@ -51339,10 +51721,10 @@ func (s *GroupSpecElementContext) ExitRule(listener antlr.ParseTreeListener) { func (p *CqlParser) GroupSpecElement() (localctx IGroupSpecElementContext) { localctx = NewGroupSpecElementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 624, CqlParserRULE_groupSpecElement) + p.EnterRule(localctx, 632, CqlParserRULE_groupSpecElement) p.EnterOuterAlt(localctx, 1) { - p.SetState(2455) + p.SetState(2459) p.Match(CqlParserOBJECT_NAME) if p.HasError() { // Recognition error - abort rule diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_base_listener.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_base_listener.go index a5c7b8f2..9c4c0616 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_base_listener.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_base_listener.go @@ -1030,6 +1030,22 @@ func (s *BaseCqlParserListener) EnterRelationFunctionCompareFunction(ctx *Relati func (s *BaseCqlParserListener) ExitRelationFunctionCompareFunction(ctx *RelationFunctionCompareFunctionContext) { } +// EnterRelationColumnCompareFunction is called when production relationColumnCompareFunction is entered. +func (s *BaseCqlParserListener) EnterRelationColumnCompareFunction(ctx *RelationColumnCompareFunctionContext) { +} + +// ExitRelationColumnCompareFunction is called when production relationColumnCompareFunction is exited. +func (s *BaseCqlParserListener) ExitRelationColumnCompareFunction(ctx *RelationColumnCompareFunctionContext) { +} + +// EnterRelationFunctionCompareColumn is called when production relationFunctionCompareColumn is entered. +func (s *BaseCqlParserListener) EnterRelationFunctionCompareColumn(ctx *RelationFunctionCompareColumnContext) { +} + +// ExitRelationFunctionCompareColumn is called when production relationFunctionCompareColumn is exited. +func (s *BaseCqlParserListener) ExitRelationFunctionCompareColumn(ctx *RelationFunctionCompareColumnContext) { +} + // EnterRelationBetween is called when production relationBetween is entered. func (s *BaseCqlParserListener) EnterRelationBetween(ctx *RelationBetweenContext) {} @@ -1084,12 +1100,24 @@ func (s *BaseCqlParserListener) EnterFunctionCall(ctx *FunctionCallContext) {} // ExitFunctionCall is called when production functionCall is exited. func (s *BaseCqlParserListener) ExitFunctionCall(ctx *FunctionCallContext) {} +// EnterFunctionName is called when production functionName is entered. +func (s *BaseCqlParserListener) EnterFunctionName(ctx *FunctionNameContext) {} + +// ExitFunctionName is called when production functionName is exited. +func (s *BaseCqlParserListener) ExitFunctionName(ctx *FunctionNameContext) {} + // EnterFunctionArgs is called when production functionArgs is entered. func (s *BaseCqlParserListener) EnterFunctionArgs(ctx *FunctionArgsContext) {} // ExitFunctionArgs is called when production functionArgs is exited. func (s *BaseCqlParserListener) ExitFunctionArgs(ctx *FunctionArgsContext) {} +// EnterFunctionArg is called when production functionArg is entered. +func (s *BaseCqlParserListener) EnterFunctionArg(ctx *FunctionArgContext) {} + +// ExitFunctionArg is called when production functionArg is exited. +func (s *BaseCqlParserListener) ExitFunctionArg(ctx *FunctionArgContext) {} + // EnterValueAny is called when production valueAny is entered. func (s *BaseCqlParserListener) EnterValueAny(ctx *ValueAnyContext) {} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_listener.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_listener.go index 92a9f262..49188653 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_listener.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser/cqlparser_listener.go @@ -505,6 +505,12 @@ type CqlParserListener interface { // EnterRelationFunctionCompareFunction is called when entering the relationFunctionCompareFunction production. EnterRelationFunctionCompareFunction(c *RelationFunctionCompareFunctionContext) + // EnterRelationColumnCompareFunction is called when entering the relationColumnCompareFunction production. + EnterRelationColumnCompareFunction(c *RelationColumnCompareFunctionContext) + + // EnterRelationFunctionCompareColumn is called when entering the relationFunctionCompareColumn production. + EnterRelationFunctionCompareColumn(c *RelationFunctionCompareColumnContext) + // EnterRelationBetween is called when entering the relationBetween production. EnterRelationBetween(c *RelationBetweenContext) @@ -532,9 +538,15 @@ type CqlParserListener interface { // EnterFunctionCall is called when entering the functionCall production. EnterFunctionCall(c *FunctionCallContext) + // EnterFunctionName is called when entering the functionName production. + EnterFunctionName(c *FunctionNameContext) + // EnterFunctionArgs is called when entering the functionArgs production. EnterFunctionArgs(c *FunctionArgsContext) + // EnterFunctionArg is called when entering the functionArg production. + EnterFunctionArg(c *FunctionArgContext) + // EnterValueAny is called when entering the valueAny production. EnterValueAny(c *ValueAnyContext) @@ -1444,6 +1456,12 @@ type CqlParserListener interface { // ExitRelationFunctionCompareFunction is called when exiting the relationFunctionCompareFunction production. ExitRelationFunctionCompareFunction(c *RelationFunctionCompareFunctionContext) + // ExitRelationColumnCompareFunction is called when exiting the relationColumnCompareFunction production. + ExitRelationColumnCompareFunction(c *RelationColumnCompareFunctionContext) + + // ExitRelationFunctionCompareColumn is called when exiting the relationFunctionCompareColumn production. + ExitRelationFunctionCompareColumn(c *RelationFunctionCompareColumnContext) + // ExitRelationBetween is called when exiting the relationBetween production. ExitRelationBetween(c *RelationBetweenContext) @@ -1471,9 +1489,15 @@ type CqlParserListener interface { // ExitFunctionCall is called when exiting the functionCall production. ExitFunctionCall(c *FunctionCallContext) + // ExitFunctionName is called when exiting the functionName production. + ExitFunctionName(c *FunctionNameContext) + // ExitFunctionArgs is called when exiting the functionArgs production. ExitFunctionArgs(c *FunctionArgsContext) + // ExitFunctionArg is called when exiting the functionArg production. + ExitFunctionArg(c *FunctionArgContext) + // ExitValueAny is called when exiting the valueAny production. ExitValueAny(c *ValueAnyContext) diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/binding.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/binding.go index e17f45df..82bbad69 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/binding.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/binding.go @@ -5,7 +5,6 @@ import ( "fmt" "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types" schemaMapping "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/metadata" - "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities" "github.com/datastax/go-cassandra-native-protocol/primitive" "github.com/google/uuid" "strconv" @@ -20,7 +19,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV } switch v := assignment.(type) { case *types.AssignmentCounterIncrement: - value, err := utilities.GetValueInt64(v.Value(), values) + value, err := values.GetValueInt64(v.Value()) if err != nil { return err } @@ -43,7 +42,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV if colType == types.LIST { lt := v.Column().CQLType.(*types.ListType) if v.Operator == types.PLUS { - value, err := utilities.GetValueSlice(v.Value(), values) + value, err := values.GetValueSlice(v.Value()) if err != nil { return err } @@ -53,7 +52,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV } b.AddMutations(mutations...) } else if v.Operator == types.MINUS { - value, err := utilities.GetValueSlice(v.Value(), values) + value, err := values.GetValueSlice(v.Value()) if err != nil { return err } @@ -71,7 +70,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV } } else if colType == types.SET { if v.Operator == types.PLUS { - value, err := utilities.GetValueSlice(v.Value(), values) + value, err := values.GetValueSlice(v.Value()) if err != nil { return err } @@ -81,7 +80,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV } b.AddMutations(ops...) } else if v.Operator == types.MINUS { - value, err := utilities.GetValueSlice(v.Value(), values) + value, err := values.GetValueSlice(v.Value()) if err != nil { return err } @@ -95,7 +94,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV } else if colType == types.MAP { mt := v.Column().CQLType.(*types.MapType) if v.Operator == types.PLUS { - value, err := utilities.GetValueMap(v.Value(), values) + value, err := values.GetValueMap(v.Value()) if err != nil { return err } @@ -104,7 +103,7 @@ func BindMutations(assignments []types.Assignment, usingTimestamp types.DynamicV return err } } else if v.Operator == types.MINUS { - value, err := utilities.GetValueSlice(v.Value(), values) + value, err := values.GetValueSlice(v.Value()) if err != nil { return err } @@ -190,7 +189,7 @@ func encodeSetValue(assignment *types.ComplexAssignmentSet, values *types.QueryP if col.CQLType.Code() == types.MAP { mt := col.CQLType.(*types.MapType) - mv, err := utilities.GetValueMap(assignment.Value(), values) + mv, err := values.GetValueMap(assignment.Value()) if err != nil { return nil, err } @@ -207,7 +206,7 @@ func encodeSetValue(assignment *types.ComplexAssignmentSet, values *types.QueryP } } else if col.CQLType.Code() == types.LIST { lt := col.CQLType.(*types.ListType) - lv, err := utilities.GetValueSlice(assignment.Value(), values) + lv, err := values.GetValueSlice(assignment.Value()) if err != nil { return nil, err } @@ -217,7 +216,7 @@ func encodeSetValue(assignment *types.ComplexAssignmentSet, values *types.QueryP } results = append(results, mutations...) } else if col.CQLType.Code() == types.SET { - lv, err := utilities.GetValueSlice(assignment.Value(), values) + lv, err := values.GetValueSlice(assignment.Value()) if err != nil { return nil, err } @@ -420,11 +419,11 @@ func BindQueryParams(params *types.QueryParameters, positionalValues []*primitiv } func bindPositionalParams(params *types.QueryParameters, values []*primitive.Value, pv primitive.ProtocolVersion) (*types.QueryParameterValues, error) { - if params.Count() != len(values) { - return nil, fmt.Errorf("expected %d prepared positional values but got %d", params.Count(), len(values)) + if params.CountUserParameters() != len(values) { + return nil, fmt.Errorf("expected %d prepared positional values but got %d", params.CountUserParameters(), len(values)) } result := types.NewQueryParameterValues(params, time.Now()) - for i, param := range params.Ordered() { + for i, param := range params.OrderedUserParams() { goVal, err := cassandraValueToGoValue(param.Type, values[i], pv) if err != nil { return nil, err @@ -438,8 +437,8 @@ func bindPositionalParams(params *types.QueryParameters, values []*primitive.Val } func bindNamedParams(params *types.QueryParameters, values map[string]*primitive.Value, pv primitive.ProtocolVersion) (*types.QueryParameterValues, error) { - if params.Count() != len(values) { - return nil, fmt.Errorf("expected %d prepared named values but got %d", params.Count(), len(values)) + if params.CountUserParameters() != len(values) { + return nil, fmt.Errorf("expected %d prepared named values but got %d", params.CountUserParameters(), len(values)) } result := types.NewQueryParameterValues(params, time.Now()) for param, value := range values { @@ -466,16 +465,12 @@ func BindSelectColumns(table *schemaMapping.TableSchema, selectedColumns []types var boundColumns []types.BoundSelectColumn for _, selectedColumn := range selectedColumns { var bc types.BoundSelectColumn - col, err := table.GetColumn(selectedColumn.ColumnName) - if err != nil { - return nil, err - } - if selectedColumn.ListIndex != -1 { - bc = types.NewBoundIndexColumn(col, int(selectedColumn.ListIndex)) - } else if selectedColumn.MapKey != "" { - bc = types.NewBoundKeyColumn(col, selectedColumn.MapKey) + if li, ok := selectedColumn.Value.(*types.ListElementValue); ok { + bc = types.NewBoundIndexColumn(li.Column, int(li.ListIndex)) + } else if mk, ok := selectedColumn.Value.(*types.MapAccessValue); ok { + bc = types.NewBoundKeyColumn(mk.Column, mk.MapKey) } else { - return nil, fmt.Errorf("unhandled select column type found binding") + return nil, fmt.Errorf("unhandled select column type found binding: %T", selectedColumn) } boundColumns = append(boundColumns, bc) } @@ -491,7 +486,7 @@ func BindUsingTimestamp(value types.DynamicValue, values *types.QueryParameterVa }, nil } - t, err := utilities.GetValueInt64(value, values) + t, err := values.GetValueInt64(value) if err != nil { return nil, err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/btql_functions.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/btql_functions.go deleted file mode 100644 index 2f722281..00000000 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/btql_functions.go +++ /dev/null @@ -1,40 +0,0 @@ -package common - -import ( - "fmt" - "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types" - cql "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/third_party/cqlparser" - "strings" -) - -func ParseCqlFunc(f cql.IFunctionCallContext) (types.CqlFuncCode, error) { - if f.K_UUID() != nil { - return types.FuncCodeUnknown, fmt.Errorf("unknown function: 'UUID'") - } - // writetime is a reserved word, so we have to handle that case separately - if f.K_WRITETIME() != nil { - return types.FuncCodeWriteTime, nil - } - - functionName := strings.ToLower(f.OBJECT_NAME().GetText()) - switch functionName { - case "writetime": - return types.FuncCodeWriteTime, nil - case "count": - return types.FuncCodeCount, nil - case "avg": - return types.FuncCodeAvg, nil - case "sum": - return types.FuncCodeSum, nil - case "min": - return types.FuncCodeMin, nil - case "max": - return types.FuncCodeMax, nil - case "now": - return types.FuncCodeNow, nil - case "totimestamp": - return types.FuncCodeToTimestamp, nil - default: - return types.FuncCodeUnknown, fmt.Errorf("unknown function: '%s'", functionName) - } -} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/rowkeys_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/rowkeys_test.go index 2998efde..c3a1e6d8 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/rowkeys_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/rowkeys_test.go @@ -15,10 +15,10 @@ func TestBindRowKeyTimestampPrecision(t *testing.T) { millis := time.UnixMilli(1767727307246) table := mockdata.GetTableOrDie("test_keyspace", "timestamp_key") - rowKeyMicro, err := BindRowKey(table, []types.DynamicValue{types.NewLiteralValue(micro)}, types.NewQueryParameterValues(types.NewEmptyQueryParameters(), time.Now())) + rowKeyMicro, err := BindRowKey(table, []types.DynamicValue{types.NewLiteralValue(micro, types.TypeTimestamp)}, types.NewQueryParameterValues(types.NewEmptyQueryParameters(), time.Now())) require.NoError(t, err) - rowKeyMillis, err := BindRowKey(table, []types.DynamicValue{types.NewLiteralValue(millis)}, types.NewQueryParameterValues(types.NewEmptyQueryParameters(), time.Now())) + rowKeyMillis, err := BindRowKey(table, []types.DynamicValue{types.NewLiteralValue(millis, types.TypeTimestamp)}, types.NewQueryParameterValues(types.NewEmptyQueryParameters(), time.Now())) require.NoError(t, err) // ensure microseconds are truncated because Bigtable uses microseconds for keys but Cassandra uses milliseconds @@ -72,8 +72,13 @@ func TestBindRowKey(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var values []types.DynamicValue - for _, v := range tt.values { - values = append(values, types.NewLiteralValue(v)) + for i, v := range tt.values { + if i < len(tt.table.PrimaryKeys) { + values = append(values, types.NewLiteralValue(v, tt.table.PrimaryKeys[i].CQLType)) + } else { + // Fallback for cases where we might have more values than primary keys (to test error handling) + values = append(values, types.NewLiteralValue(v, types.TypeVarchar)) + } } rowKey, err := BindRowKey(tt.table, values, types.NewQueryParameterValues(types.NewEmptyQueryParameters(), time.Now())) if tt.err != "" { diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils.go index d26e80f5..e6a85cb6 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils.go @@ -12,6 +12,7 @@ import ( "github.com/datastax/go-cassandra-native-protocol/primitive" "github.com/google/uuid" "regexp" + "slices" "strings" "time" ) @@ -40,7 +41,7 @@ func ExtractDecimalLiteral(d cql.IDecimalLiteralContext, cqlType types.CqlDataTy if err != nil { return nil, err } - return types.NewLiteralValue(val), err + return types.NewLiteralValue(val, cqlType), err } func ParseMarker(m cql.IMarkerContext, dt types.CqlDataType, params *types.QueryParameterBuilder, col *types.Column) (types.DynamicValue, error) { @@ -56,7 +57,7 @@ func ParseMarker(m cql.IMarkerContext, dt types.CqlDataType, params *types.Query if err != nil { return nil, err } - return types.NewParameterizedValue(marker), nil + return types.NewParameterizedValue(marker, dt), nil } func GetDecimalLiteral(d cql.IDecimalLiteralContext, cqlType types.CqlDataType) (types.GoValue, error) { @@ -110,6 +111,12 @@ func ParseWhereClause(input cql.IWhereSpecContext, tableConfig *schemaMapping.Ta condition, err = parseWhereLike(val.RelationLike(), tableConfig, params) } else if val.RelationContainsKey() != nil { condition, err = parseWhereContainsKey(val.RelationContainsKey(), tableConfig, params) + } else if val.RelationFunctionCompareColumn() != nil { + compareFn := val.RelationFunctionCompareColumn() + condition, err = parseColumnCompareFunction(compareFn.Column(), compareFn.CompareOperator(), compareFn.FunctionCall(), true, tableConfig, params) + } else if val.RelationColumnCompareFunction() != nil { + compareFn := val.RelationColumnCompareFunction() + condition, err = parseColumnCompareFunction(compareFn.Column(), compareFn.CompareOperator(), compareFn.FunctionCall(), false, tableConfig, params) } else if val.RelationContains() != nil { condition, err = parseWhereContains(val.RelationContains(), tableConfig, params) } else if val.RelationBetween() != nil { @@ -149,6 +156,30 @@ func parseWhereCompare(compare cql.IRelationCompareContext, tableConfig *schemaM Value: value, }, nil } + +func parseColumnCompareFunction(col cql.IColumnContext, op cql.ICompareOperatorContext, f cql.IFunctionCallContext, flip bool, tableConfig *schemaMapping.TableSchema, params *types.QueryParameterBuilder) (types.Condition, error) { + column, err := ParseColumnContext(tableConfig, col) + if err != nil { + return types.Condition{}, err + } + operator, err := ParseOperator(op) + if err != nil { + return types.Condition{}, err + } + if flip { + operator = types.FlipOperator(operator) + } + fn, err := ParseFunctionCall(f, tableConfig, types.QueryClauseWhere, params) + if err != nil { + return types.Condition{}, err + } + return types.Condition{ + Column: column, + Operator: operator, + Value: fn, + }, nil +} + func parseWhereLike(like cql.IRelationLikeContext, tableConfig *schemaMapping.TableSchema, params *types.QueryParameterBuilder) (types.Condition, error) { column, err := ParseColumnContext(tableConfig, like.Column()) if err != nil { @@ -215,15 +246,15 @@ func parseWhereBetween(between cql.IRelationBetweenContext, tableConfig *schemaM return types.Condition{}, err } - if len(between.AllConstant()) != 2 { + if len(between.AllValueAny()) != 2 { return types.Condition{}, fmt.Errorf("BETWEEN condition must have exactly 2 values") } - v1, err := ParseConstantValue(between.Constant(0), column.CQLType, params, column) + v1, err := ParseValueAny(between.ValueAny(0), tableConfig, column.CQLType, types.QueryClauseWhere, params, column) if err != nil { return types.Condition{}, err } - v2, err := ParseConstantValue(between.Constant(1), column.CQLType, params, column) + v2, err := ParseValueAny(between.ValueAny(1), tableConfig, column.CQLType, types.QueryClauseWhere, params, column) if err != nil { return types.Condition{}, err } @@ -257,7 +288,7 @@ func ParseTupleValue(tuple cql.ITupleValueContext, lt *types.ListType, params *t } valueFn := tuple.FunctionArgs() - all := valueFn.AllConstant() + all := valueFn.AllFunctionArg() if all == nil || len(all) == 0 { return nil, errors.New("failed to parse values for IN operator") } @@ -269,10 +300,10 @@ func ParseTupleValue(tuple cql.ITupleValueContext, lt *types.ListType, params *t } inValues = append(inValues, parsed) } - return types.NewLiteralValue(inValues), nil + return types.NewLiteralValue(inValues, lt), nil } -func ParseValueAny(v cql.IValueAnyContext, dt types.CqlDataType, params *types.QueryParameterBuilder, column *types.Column) (types.DynamicValue, error) { +func ParseValueAny(v cql.IValueAnyContext, table *schemaMapping.TableSchema, dt types.CqlDataType, clause types.QueryClause, params *types.QueryParameterBuilder, column *types.Column) (types.DynamicValue, error) { if v.Marker() != nil { return ParseMarker(v.Marker(), dt, params, column) } @@ -285,40 +316,127 @@ func ParseValueAny(v cql.IValueAnyContext, dt types.CqlDataType, params *types.Q if err != nil { return nil, err } - return types.NewLiteralValue(value), nil + return types.NewLiteralValue(value, dt), nil } if v.ValueMap() != nil { value, err := ParseCqlMapAssignment(v.ValueMap(), dt) if err != nil { return nil, err } - return types.NewLiteralValue(value), nil + return types.NewLiteralValue(value, dt), nil } if v.ValueSet() != nil { value, err := ParseCqlSetAssignment(v.ValueSet(), dt) if err != nil { return nil, err } - return types.NewLiteralValue(value), nil + return types.NewLiteralValue(value, dt), nil } // todo more robust function handling if v.FunctionCall() != nil { - functionName := strings.ToLower(v.FunctionCall().OBJECT_NAME().GetText()) - if functionName == "totimestamp" { - fnArgs := v.FunctionCall().FunctionArgs().AllFunctionCall() - if len(fnArgs) == 1 { - innerFn := strings.ToLower(fnArgs[0].OBJECT_NAME().GetText()) - if innerFn == "now" { - return types.NewTimestampNowValue(), nil - } - } + return ParseFunctionCall(v.FunctionCall(), table, clause, params) + } + return nil, fmt.Errorf("unhandled value set `%s`", v.GetText()) +} + +func ParseFunctionCall(functionCall cql.IFunctionCallContext, table *schemaMapping.TableSchema, clause types.QueryClause, params *types.QueryParameterBuilder) (*types.FunctionValue, error) { + funcSpec, err := ParseFunctionName(functionCall.FunctionName()) + if err != nil { + return nil, err + } + if !slices.Contains(funcSpec.GetValidClauses(), clause) { + return nil, fmt.Errorf("function '%s' cannot be called in %s clause", funcSpec.GetName(), clause.String()) + } + + var allFunctionArgs []cql.IFunctionArgContext + if functionCall.FunctionArgs() == nil { + allFunctionArgs = nil + } else { + allFunctionArgs = functionCall.FunctionArgs().AllFunctionArg() + } + + if len(allFunctionArgs) != len(funcSpec.GetParameterTypes()) { + return nil, fmt.Errorf("expected %d args for function %s but got %d", len(funcSpec.GetParameterTypes()), funcSpec.GetName(), len(allFunctionArgs)) + } + var args []types.DynamicValue + for i, arg := range allFunctionArgs { + argSpec := funcSpec.GetParameterTypes()[i] + value, err := parseFunctionArg(table, arg, argSpec, clause, params) + if err != nil { + return nil, err } - if functionName == "now" && dt.Code() == types.TIMEUUID { - return types.NewTimeuuidNowValue(), nil + args = append(args, value) + } + var p types.Parameter + if clause == types.QueryClauseSelect { + // we can't use functions here so don't assign a parameter + p = "" + } else { + p, err = params.AddInternalParam(funcSpec.GetReturnType(args)) + if err != nil { + return nil, err } - return nil, fmt.Errorf("unsupported function call: `%s`", v.GetText()) } - return nil, fmt.Errorf("unhandled value set `%s`", v.GetText()) + fv := types.NewFunctionValue(p, funcSpec, args...) + err = types.ValidateFunctionArgs(fv) + if err != nil { + return nil, err + } + return fv, nil +} + +func ParseFunctionName(f cql.IFunctionNameContext) (types.CqlFunc, error) { + functionName := strings.ToLower(f.GetText()) + switch functionName { + case "writetime": + return types.WriteTime, nil + case "count": + return types.Count, nil + case "avg": + return types.Avg, nil + case "sum": + return types.Sum, nil + case "min": + return types.Min, nil + case "max": + return types.Max, nil + case "now": + return types.Now, nil + case "totimestamp": + return types.ToTimestamp, nil + case "mintimeuuid": + return types.MinTimeuuid, nil + case "maxtimeuuid": + return types.MaxTimeuuid, nil + default: + return nil, fmt.Errorf("unknown function: '%s'", functionName) + } +} + +func parseFunctionArg(table *schemaMapping.TableSchema, arg cql.IFunctionArgContext, argSpec types.CqlFuncParameter, clause types.QueryClause, params *types.QueryParameterBuilder) (types.DynamicValue, error) { + if arg.ValueAny() != nil { + value, err := ParseValueAny(arg.ValueAny(), table, argSpec.Types[0], clause, params, nil) + if err != nil { + return nil, err + } + return value, nil + } else if arg.Column() != nil { + if clause != types.QueryClauseSelect { + return nil, fmt.Errorf("function calls on columns are not supported outside of the SELECT clause") + } + col, err := ParseColumnContext(table, arg.Column()) + if err != nil { + return nil, err + } + return types.NewColumnValue(col), nil + } else if arg.STAR() != nil { + if clause != types.QueryClauseSelect { + return nil, fmt.Errorf("function calls on '*' are not supported outside of the SELECT clause") + } + return types.NewSelectStarValue(), nil + } else { + return nil, fmt.Errorf("unsupported function argument: `%s`", arg.GetText()) + } } func ParseConstantValue(v cql.IConstantContext, dt types.CqlDataType, params *types.QueryParameterBuilder, col *types.Column) (types.DynamicValue, error) { @@ -330,7 +448,7 @@ func ParseConstantValue(v cql.IConstantContext, dt types.CqlDataType, params *ty return nil, err } - return types.NewLiteralValue(goValue), nil + return types.NewLiteralValue(goValue, dt), nil } func ParseColumnContext(table *schemaMapping.TableSchema, r cql.IColumnContext) (*types.Column, error) { @@ -859,14 +977,14 @@ func ParseSelectIndex(si cql.ISelectIndexContext, alias string, table *schemaMap if err != nil { return types.SelectedColumn{}, err } - return *types.NewSelectedColumnMapElement(si.GetText(), col.Name, alias, mt.ValueType(), colQualifier), nil + return types.NewSelectedColumn(si.GetText(), types.NewMapAccessValue(col, mt, colQualifier), alias), nil } else if col.CQLType.Code() == types.LIST { index, err := ParseBigInt(si.Constant().DecimalLiteral()) if err != nil { return types.SelectedColumn{}, err } lt := col.CQLType.(*types.ListType) - return *types.NewSelectedColumnListElement(si.GetText(), col.Name, alias, lt.ElementType(), index), nil + return types.NewSelectedColumn(si.GetText(), types.NewListElementValue(col, lt, index), alias), nil } else { return types.SelectedColumn{}, fmt.Errorf("cannot access index/key of column type %s", col.CQLType.String()) } @@ -877,92 +995,19 @@ func ParseSelectColumn(si cql.ISelectColumnContext, alias string, table *schemaM if err != nil { return types.SelectedColumn{}, err } - return *types.NewSelectedColumn(string(col.Name), col.Name, alias, col.CQLType), nil + return types.NewSelectedColumn(string(col.Name), types.NewColumnValue(col), alias), nil } -func ParseSelectFunction(sf cql.ISelectFunctionContext, alias string, table *schemaMapping.TableSchema) (types.SelectedColumn, error) { - f, err := ParseCqlFunc(sf.FunctionCall()) +func ParseSelectFunction(sf cql.ISelectFunctionContext, alias string, table *schemaMapping.TableSchema, params *types.QueryParameterBuilder) (types.SelectedColumn, error) { + f, err := ParseFunctionCall(sf.FunctionCall(), table, types.QueryClauseSelect, params) if err != nil { return types.SelectedColumn{}, err } - switch f { - case types.FuncCodeWriteTime: - col, err := parseSingleColumnFunctionArg(sf.FunctionCall(), table) - if err != nil { - return types.SelectedColumn{}, err - } - return *types.NewSelectedColumnFunction(sf.FunctionCall().GetText(), col.Name, alias, types.TypeBigInt, f), nil - case types.FuncCodeCount: - value, err := parseStarOrColumnFunctionArg(sf.FunctionCall(), table) - if err != nil { - return types.SelectedColumn{}, err - } - sql := fmt.Sprintf("system.count(%s)", value) - return *types.NewSelectedColumnFunction(sql, types.ColumnName(value), alias, types.TypeBigInt, f), nil - case types.FuncCodeAvg, types.FuncCodeSum, types.FuncCodeMin, types.FuncCodeMax: - col, err := parseSingleColumnFunctionArg(sf.FunctionCall(), table) - if err != nil { - return types.SelectedColumn{}, err - } - - if !isNumericType(col.CQLType) { - return types.SelectedColumn{}, fmt.Errorf("invalid aggregate type: %s", col.CQLType.String()) - } - - resultType := col.CQLType - // integer type columns need to have result a result type that captures decimal positionalValues - if f == types.FuncCodeAvg && (col.CQLType.Code() == types.BIGINT || col.CQLType.Code() == types.INT || col.CQLType.Code() == types.COUNTER) { - resultType = types.TypeDouble - } - - // example: system.avg(price) - sql := fmt.Sprintf("system.%s(%s)", strings.ToLower(f.String()), col.Name) - return *types.NewSelectedColumnFunction(sql, col.Name, alias, resultType, f), nil - case types.FuncCodeNow: - return *types.NewSelectedColumnFunction("now()", "", alias, types.TypeTimeuuid, f), nil - case types.FuncCodeToTimestamp: - col, err := parseSingleColumnFunctionArg(sf.FunctionCall(), table) - if err != nil { - return types.SelectedColumn{}, err - } - if col.CQLType.Code() != types.TIMEUUID { - return types.SelectedColumn{}, fmt.Errorf("totimestamp() argument must be a timeuuid, not %s", col.CQLType.String()) - } - sql := string(col.Name) - return *types.NewSelectedColumnFunction(sql, col.Name, alias, types.TypeTimestamp, f), nil - default: - return types.SelectedColumn{}, fmt.Errorf("unhandled function type `%s`", sf.FunctionCall().GetText()) - } -} - -func isNumericType(t types.CqlDataType) bool { - return t.Code() == types.BIGINT || t.Code() == types.INT || t.Code() == types.FLOAT || t.Code() == types.DOUBLE || t.Code() == types.COUNTER -} - -func parseSingleColumnFunctionArg(fn cql.IFunctionCallContext, table *schemaMapping.TableSchema) (*types.Column, error) { - if fn.FunctionArgs() == nil || len(fn.FunctionArgs().AllOBJECT_NAME()) != 1 { - return nil, fmt.Errorf("expected 1 column argument for `%s`", fn.GetText()) - } - if len(fn.FunctionArgs().AllFunctionCall()) != 0 { - return nil, fmt.Errorf("expected 1 column argument for `%s`", fn.GetText()) - } - arg := fn.FunctionArgs().OBJECT_NAME(0).GetText() - col, err := table.GetColumn(types.ColumnName(arg)) - if err != nil { - return nil, fmt.Errorf("expected valid column in function arguments `%s`", fn.GetText()) - } - return col, nil -} - -func parseStarOrColumnFunctionArg(fn cql.IFunctionCallContext, table *schemaMapping.TableSchema) (string, error) { - if fn.STAR() != nil { - return "*", nil - } - col, err := parseSingleColumnFunctionArg(fn, table) - if err != nil { - return "", err + cqlText := sf.GetText() + if f.Func.GetCode() == types.FuncCodeCount || f.Func.GetCode() == types.FuncCodeAvg || f.Func.GetCode() == types.FuncCodeMin || f.Func.GetCode() == types.FuncCodeMax || f.Func.GetCode() == types.FuncCodeSum { + cqlText = "system." + strings.ToLower(cqlText) } - return string(col.Name), nil + return types.NewSelectedColumn(cqlText, f, alias), nil } func ParseAs(a cql.IAsSpecContext) (string, error) { diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils_test.go index fe8ac00f..411c39b2 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common/utils_test.go @@ -102,8 +102,8 @@ func Test_validateRequiredPrimaryKeys(t *testing.T) { name: "success", table: mockdata.GetTableOrDie("test_keyspace", "test_table"), assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value2")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value2", types.TypeVarchar)), }, err: "", }, @@ -111,7 +111,7 @@ func Test_validateRequiredPrimaryKeys(t *testing.T) { name: "missing pk2", table: mockdata.GetTableOrDie("test_keyspace", "test_table"), assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1", types.TypeVarchar)), }, err: "missing primary key: 'pk2'", }, @@ -119,9 +119,9 @@ func Test_validateRequiredPrimaryKeys(t *testing.T) { name: "extra columns ok", table: mockdata.GetTableOrDie("test_keyspace", "test_table"), assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value2")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value3")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value1", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value2", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value3", types.TypeBlob)), }, err: "", }, @@ -129,9 +129,9 @@ func Test_validateRequiredPrimaryKeys(t *testing.T) { name: "out of order ok", table: mockdata.GetTableOrDie("test_keyspace", "test_table"), assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value2")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0", types.TypeBlob)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value2", types.TypeVarchar)), }, err: "", }, @@ -139,8 +139,8 @@ func Test_validateRequiredPrimaryKeys(t *testing.T) { name: "mixed types ok", table: mockdata.GetTableOrDie("test_keyspace", "user_info"), assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "user_info", "age"), types.NewParameterizedValue("value1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "user_info", "name"), types.NewParameterizedValue("value2")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "user_info", "age"), types.NewParameterizedValue("value1", types.TypeBigInt)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "user_info", "name"), types.NewParameterizedValue("value2", types.TypeVarchar)), }, err: "", }, @@ -179,7 +179,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeVarchar, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue("user1", types.TypeVarchar)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeVarchar)}, want: "user1", }, { @@ -188,7 +188,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(1), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x81", }, { @@ -197,7 +197,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int32(1), types.TypeInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeInt)}, want: "\x81", }, { @@ -206,7 +206,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int32(1), types.TypeInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeInt)}, want: "\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x01", }, { @@ -215,7 +215,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(2147483647), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x00\xff\x00\xff\x00\xff\x00\xff\x7f\xff\xff\xff", }, { @@ -224,7 +224,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(9223372036854775807), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x7f\xff\xff\xff\xff\xff\xff\xff", }, { @@ -233,7 +233,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(-1), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x7f", }, { @@ -242,7 +242,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(-1), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "", wantErr: "row keys with big endian encoding cannot contain negative integer values", }, @@ -252,7 +252,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(0), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x80", }, { @@ -261,7 +261,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(math.MinInt64), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x00\xff\x3f\x80\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff", }, { @@ -270,7 +270,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(-922337203685473), types.TypeBigInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeBigInt)}, want: "\x00\xff\xfc\xb9\x23\xa2\x9c\x77\x9f", }, { @@ -279,7 +279,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), values: []*types.TypedGoValue{types.NewTypedGoValue(int64(math.MinInt32), types.TypeInt)}, - rowKey: []types.DynamicValue{types.NewParameterizedValue("value0")}, + rowKey: []types.DynamicValue{types.NewParameterizedValue("value0", types.TypeInt)}, want: "\x07\x80\x00\xff\x00\xff\x00\xff", }, { @@ -295,9 +295,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { types.NewTypedGoValue("id123", types.TypeVarchar), }, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), + types.NewParameterizedValue("value0", types.TypeBigInt), + types.NewParameterizedValue("value1", types.TypeInt), + types.NewParameterizedValue("value2", types.TypeVarchar), }, want: "\x00\xff\x3f\x80\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\x01\x07\x80\x00\xff\x00\xff\x00\xff\x00\x01\x69\x64\x31\x32\x33", }, @@ -308,8 +308,8 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "other_id", CQLType: types.TypeInt, KeyType: types.KeyTypePartition, PkPrecedence: 2}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue(int64(-43232545)), - types.NewLiteralValue(int64(-12451)), + types.NewLiteralValue(int64(-43232545), types.TypeBigInt), + types.NewLiteralValue(int64(-12451), types.TypeInt), }, want: "\x0d\x6c\x52\xdf\x00\x01\x1f\xcf\x5d", }, @@ -319,7 +319,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBigInt, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue(int64(0)), + types.NewLiteralValue(int64(0), types.TypeBigInt), }, want: "\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff", }, @@ -336,9 +336,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { types.NewTypedGoValue("new york", types.TypeVarchar), }, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), + types.NewParameterizedValue("value0", types.TypeVarchar), + types.NewParameterizedValue("value1", types.TypeBigInt), + types.NewParameterizedValue("value2", types.TypeVarchar), }, want: "user1\x00\x01\x81\x00\x01new york", }, @@ -350,9 +350,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "city", CQLType: types.TypeVarchar, KeyType: types.KeyTypeClustering, PkPrecedence: 3}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("user1"), - types.NewLiteralValue(int64(1)), - types.NewLiteralValue("new york"), + types.NewLiteralValue("user1", types.TypeVarchar), + types.NewLiteralValue(int64(1), types.TypeBigInt), + types.NewLiteralValue("new york", types.TypeVarchar), }, want: "user1\x00\x01\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x01\x00\x01new york", }, @@ -364,9 +364,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "city", CQLType: types.TypeVarchar, KeyType: types.KeyTypeClustering, PkPrecedence: 3}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("user1"), - types.NewLiteralValue(int64(1)), - types.NewLiteralValue("new york"), + types.NewLiteralValue("user1", types.TypeVarchar), + types.NewLiteralValue(int64(1), types.TypeBigInt), + types.NewLiteralValue("new york", types.TypeVarchar), }, want: "", wantErr: "unhandled int encoding type", @@ -386,10 +386,10 @@ func TestCreateOrderedCodeKey(t *testing.T) { types.NewTypedGoValue("", types.TypeVarchar), }, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), - types.NewParameterizedValue("value3"), + types.NewParameterizedValue("value0", types.TypeVarchar), + types.NewParameterizedValue("value1", types.TypeBigInt), + types.NewParameterizedValue("value2", types.TypeVarchar), + types.NewParameterizedValue("value3", types.TypeVarchar), }, want: "user3\x00\x01\x83", }, @@ -408,10 +408,10 @@ func TestCreateOrderedCodeKey(t *testing.T) { types.NewTypedGoValue("", types.TypeVarchar), }, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), - types.NewParameterizedValue("value3"), + types.NewParameterizedValue("value0", types.TypeVarchar), + types.NewParameterizedValue("value1", types.TypeBigInt), + types.NewParameterizedValue("value2", types.TypeVarchar), + types.NewParameterizedValue("value3", types.TypeVarchar), }, want: "user3\x00\x01\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x03", }, @@ -428,9 +428,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { types.NewTypedGoValue("\xb7", types.TypeBlob), }, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), + types.NewParameterizedValue("value0", types.TypeBlob), + types.NewParameterizedValue("value1", types.TypeBlob), + types.NewParameterizedValue("value2", types.TypeBlob), }, want: "\xa2\x00\x01\x00\x00\x00\x01\xb7", }, @@ -440,7 +440,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeBlob, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("\x80\x00\x01\x81"), + types.NewLiteralValue("\x80\x00\x01\x81", types.TypeBlob), }, want: "\x80\x00\xff\x01\x81", }, @@ -453,10 +453,10 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "borough", CQLType: types.TypeBlob, KeyType: types.KeyTypeClustering, PkPrecedence: 4}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("\xa2"), - types.NewLiteralValue(""), - types.NewLiteralValue(""), - types.NewLiteralValue("\xb7"), + types.NewLiteralValue("\xa2", types.TypeBlob), + types.NewLiteralValue("", types.TypeBlob), + types.NewLiteralValue("", types.TypeBlob), + types.NewLiteralValue("\xb7", types.TypeBlob), }, want: "\xa2\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\xb7", }, @@ -467,8 +467,8 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "city", CQLType: types.TypeBlob, KeyType: types.KeyTypeClustering, PkPrecedence: 2}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("\xa5"), - types.NewLiteralValue("\x90"), + types.NewLiteralValue("\xa5", types.TypeBlob), + types.NewLiteralValue("\x90", types.TypeBlob), }, want: "\xa5\x00\x01\x90", }, @@ -479,8 +479,8 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "city", CQLType: types.TypeBlob, KeyType: types.KeyTypeClustering, PkPrecedence: 2}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue(""), - types.NewLiteralValue("\xaa"), + types.NewLiteralValue("", types.TypeVarchar), + types.NewLiteralValue("\xaa", types.TypeBlob), }, want: "\x00\x00\x00\x01\xaa", }, @@ -492,9 +492,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "borough", CQLType: types.TypeVarchar, KeyType: types.KeyTypeClustering, PkPrecedence: 3}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("nn"), - types.NewLiteralValue("t\x00t"), - types.NewLiteralValue("end"), + types.NewLiteralValue("nn", types.TypeVarchar), + types.NewLiteralValue("t\x00t", types.TypeVarchar), + types.NewLiteralValue("end", types.TypeVarchar), }, want: "nn\x00\x01t\x00\xfft\x00\x01end", }, @@ -506,9 +506,9 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "city", CQLType: types.TypeVarchar, KeyType: types.KeyTypeClustering, PkPrecedence: 3}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("abcd"), - types.NewLiteralValue(int64(45)), - types.NewLiteralValue("name"), + types.NewLiteralValue("abcd", types.TypeVarchar), + types.NewLiteralValue(int64(45), types.TypeBigInt), + types.NewLiteralValue("name", types.TypeVarchar), }, want: "abcd\x00\x01\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x2d\x00\x01name", }, @@ -518,7 +518,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeVarchar, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue("\x00\x01"), + types.NewLiteralValue("\x00\x01", types.TypeVarchar), }, want: "\x00\xff\x01", }, @@ -529,7 +529,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { }), values: []*types.TypedGoValue{}, rowKey: []types.DynamicValue{ - types.NewParameterizedValue("value1"), + types.NewParameterizedValue("value1", types.TypeVarchar), }, want: "", wantErr: "no query param for value1", @@ -540,7 +540,7 @@ func TestCreateOrderedCodeKey(t *testing.T) { {Name: "user_id", CQLType: types.TypeVarchar, KeyType: types.KeyTypePartition, PkPrecedence: 1}, }), rowKey: []types.DynamicValue{ - types.NewLiteralValue(nil), + types.NewLiteralValue(nil, types.TypeVarchar), }, want: "", wantErr: "value cannot be null for primary key 'user_id'", @@ -550,6 +550,16 @@ func TestCreateOrderedCodeKey(t *testing.T) { t.Run(tt.name, func(t *testing.T) { values, err := mockdata.CreateQueryParams(tt.values) require.NoError(t, err) + + // We need to ensure that literal values in tt.rowKey also have types if they are used + for i, rv := range tt.rowKey { + if lit, ok := rv.(*types.LiteralValue); ok { + if i < len(tt.tableConfig.PrimaryKeys) { + tt.rowKey[i] = types.NewLiteralValue(lit.Value, tt.tableConfig.PrimaryKeys[i].CQLType) + } + } + } + got, err := BindRowKey(tt.tableConfig, tt.rowKey, values) if tt.wantErr != "" { require.Error(t, err) @@ -748,12 +758,12 @@ func TestRelationFragment(t *testing.T) { require.NoError(t, err) param, ok := result.(*types.ParameterizedValue) assert.True(t, ok) - assert.Equal(t, types.Parameter("my_marker_1"), param.Parameter) + assert.Equal(t, types.Parameter("my_marker_1"), param.GetParameter()) builtParams, err := qp.Build() assert.NoError(t, err) - metadata, err := builtParams.GetMetadata(param.Parameter) + metadata, err := builtParams.GetMetadata(param.GetParameter()) require.NoError(t, err) assert.Equal(t, types.Parameter("my_marker_1"), metadata.Key) assert.Equal(t, types.TypeText, metadata.Type) diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/delete_translator/translator_delete_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/delete_translator/translator_delete_test.go index 9bff2dd8..55ac7eb3 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/delete_translator/translator_delete_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/delete_translator/translator_delete_test.go @@ -63,8 +63,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: false, RowKey: []types.DynamicValue{ - types.NewLiteralValue("test"), - types.NewLiteralValue(int64(72)), + types.NewLiteralValue("test", types.TypeVarchar), + types.NewLiteralValue(int64(72), types.TypeBigInt), }, SelectedColumns: nil, }, @@ -78,8 +78,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: false, RowKey: []types.DynamicValue{ - types.NewParameterizedValue("value0"), - types.NewParameterizedValue("value1"), + types.NewParameterizedValue("value0", types.TypeVarchar), + types.NewParameterizedValue("value1", types.TypeBigInt), }, SelectedColumns: nil, }, @@ -93,8 +93,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: false, RowKey: []types.DynamicValue{ - types.NewLiteralValue("test"), - types.NewLiteralValue(int64(72)), + types.NewLiteralValue("test", types.TypeVarchar), + types.NewLiteralValue(int64(72), types.TypeBigInt), }, SelectedColumns: nil, }, @@ -119,8 +119,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: true, RowKey: []types.DynamicValue{ - types.NewLiteralValue("test"), - types.NewLiteralValue(int64(72)), + types.NewLiteralValue("test", types.TypeVarchar), + types.NewLiteralValue(int64(72), types.TypeBigInt), }, SelectedColumns: nil, }, @@ -134,8 +134,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: true, RowKey: []types.DynamicValue{ - types.NewLiteralValue("tes't"), - types.NewLiteralValue(int64(72)), + types.NewLiteralValue("tes't", types.TypeVarchar), + types.NewLiteralValue(int64(72), types.TypeBigInt), }, SelectedColumns: nil, }, @@ -149,8 +149,8 @@ func TestTranslator_TranslateDeleteQuerytoBigtable(t *testing.T) { Table: "user_info", IfExists: false, RowKey: []types.DynamicValue{ - types.NewLiteralValue("test"), - types.NewLiteralValue(int64(72)), + types.NewLiteralValue("test", types.TypeVarchar), + types.NewLiteralValue(int64(72), types.TypeBigInt), }, SelectedColumns: nil, }, diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert.go index 8a80c084..8ef9d1b6 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert.go @@ -48,7 +48,7 @@ func (t *InsertTranslator) Translate(query *types.RawQuery, sessionKeyspace type return nil, err } - values, err := parseInsertValues(insertObj.InsertValuesSpec(), columns, params) + values, err := parseInsertValues(insertObj.InsertValuesSpec(), table, columns, params) if err != nil { return nil, err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert_test.go index 17edb82d..79ee6994 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/translator_insert_test.go @@ -50,8 +50,8 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value0")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value0", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1", types.TypeVarchar)), }, AllParams: []*types.ParameterMetadata{ { @@ -77,8 +77,8 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("v_1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("v_2")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("v_1", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("v_2", types.TypeVarchar)), }, AllParams: []*types.ParameterMetadata{ { @@ -104,9 +104,9 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("pk")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("pk")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewParameterizedValue("i")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("pk", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("pk", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewParameterizedValue("i", types.TypeInt)), }, AllParams: []*types.ParameterMetadata{ { @@ -132,15 +132,15 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value0")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value1")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewParameterizedValue("value2")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "list_text"), types.NewParameterizedValue("value3")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewParameterizedValue("value4")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewParameterizedValue("value5")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value6")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value0", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value1", types.TypeBlob)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewParameterizedValue("value2", types.TypeBoolean)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "list_text"), types.NewParameterizedValue("value3", types.NewListType(types.TypeText))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewParameterizedValue("value4", types.TypeInt)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewParameterizedValue("value5", types.TypeBigInt)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value6", types.TypeVarchar)), }, - UsingTimestamp: types.NewParameterizedValue("value7"), + UsingTimestamp: types.NewParameterizedValue("value7", types.TypeBigInt), AllParams: []*types.ParameterMetadata{ { Key: "value0", @@ -201,16 +201,16 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("u123")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x03})), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewLiteralValue(true)), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "list_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2", "item1"})), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(3))), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewLiteralValue(int64(8242842848))), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("org1")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("u123", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x03}, types.TypeBlob)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewLiteralValue(true, types.TypeBoolean)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "list_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2", "item1"}, types.NewListType(types.TypeText))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(3), types.TypeInt)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewLiteralValue(int64(8242842848), types.TypeBigInt)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("org1", types.TypeVarchar)), }, AllParams: []*types.ParameterMetadata{}, - UsingTimestamp: types.NewLiteralValue(int64(234242424)), + UsingTimestamp: types.NewLiteralValue(int64(234242424), types.TypeBigInt), }, }, { @@ -226,8 +226,8 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", IfNotExists: false, Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value0")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewParameterizedValue("value0", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewParameterizedValue("value1", types.TypeVarchar)), }, AllParams: []*types.ParameterMetadata{ { @@ -253,9 +253,9 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", Keyspace: "test_keyspace", Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkval")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_text"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"foo": "bar", "key:": ":value", "k}": "{v:k}"})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkval", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_text"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"foo": "bar", "key:": ":value", "k}": "{v:k}"}, types.NewMapType(types.TypeText, types.TypeText))), }, AllParams: []*types.ParameterMetadata{}, }, @@ -267,9 +267,9 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", Keyspace: "test_keyspace", Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkva'l")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(3))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkva'l", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(3), types.TypeInt)), }, AllParams: []*types.ParameterMetadata{}, }, @@ -281,9 +281,9 @@ func TestSelectTranslator_Translate(t *testing.T) { Table: "test_table", Keyspace: "test_keyspace", Assignments: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkval")), - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(nil)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), types.NewLiteralValue("abc", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), types.NewLiteralValue("pkval", types.TypeVarchar)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(nil, types.TypeInt)), }, AllParams: []*types.ParameterMetadata{}, }, diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/utils.go index 632a2d3c..e2c58ae5 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/insert_translator/utils.go @@ -49,7 +49,7 @@ func parseInsertColumns(input cql.IInsertColumnSpecContext, tableConfig *schemaM return result, nil } -func parseInsertValues(input cql.IInsertValuesSpecContext, columns []*types.Column, params *types.QueryParameterBuilder) ([]types.Assignment, error) { +func parseInsertValues(input cql.IInsertValuesSpecContext, table *schemaMapping.TableSchema, columns []*types.Column, params *types.QueryParameterBuilder) ([]types.Assignment, error) { if input == nil { return nil, errors.New("insert values clause missing or malformed") } @@ -71,7 +71,7 @@ func parseInsertValues(input cql.IInsertValuesSpecContext, columns []*types.Colu var assignments []types.Assignment for i, v := range allValues { column := columns[i] - value, err := common.ParseValueAny(v, column.CQLType, params, column) + value, err := common.ParseValueAny(v, table, column.CQLType, types.QueryClauseValues, params, column) if err != nil { return nil, err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/select_query_builder.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/select_query_builder.go index 638b429e..1fb5e990 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/select_query_builder.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/select_query_builder.go @@ -7,147 +7,119 @@ import ( sm "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/metadata" "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities" "github.com/datastax/go-cassandra-native-protocol/datatype" - "github.com/datastax/go-cassandra-native-protocol/primitive" "strings" ) -func createBtqlSelectClause(tableConfig *sm.TableSchema, s *types.SelectClause, isGroupBy bool) (string, error) { +func createBtqlSelectClause(s *types.SelectClause, isGroupBy bool) (string, error) { if s.IsStar { return "*", nil } var columns []string for _, col := range s.Columns { - if col.Func != types.FuncCodeUnknown { - c, err := createBtqlFunc(col, tableConfig) - if err != nil { - return "", err - } - columns = append(columns, c) - } else { - c, err := createBtqlSelectCol(tableConfig, col, isGroupBy) - if err != nil { - return "", err - } - columns = append(columns, c) + c, err := toBtql(col.Value) + if err != nil { + return "", err + } + if col.Alias != "" { + c = fmt.Sprintf("%s AS %s", c, col.Alias) } + columns = append(columns, c) } return strings.Join(columns, ", "), nil } -func createBtqlFunc(col types.SelectedColumn, tableConfig *sm.TableSchema) (string, error) { - if col.Func == types.FuncCodeCount && col.ColumnName == "*" { - if col.Alias != "" { - return "count(*) as " + col.Alias, nil - } - return "count(*)", nil - } - - colMeta, found := tableConfig.Columns[col.ColumnName] - if !found { - // Check if the column is an alias - if aliasMeta, aliasFound := tableConfig.Columns[types.ColumnName(col.Alias)]; aliasFound { - colMeta = aliasMeta - } else { - return "", fmt.Errorf("column metadata not found for column '%s' in table '%s' and keyspace '%s'", col.ColumnName, tableConfig.Name, tableConfig.Keyspace) - } +func toBtql(value types.DynamicValue) (string, error) { + switch v := value.(type) { + case *types.SelectStarValue: + return "*", nil + case *types.ColumnValue: + return processRegularColumn(v) + case *types.MapAccessValue: + return fmt.Sprintf("`%s`['%s']", v.Column.Name, v.MapKey), nil + case *types.FunctionValue: + return createBtqlFunc(v) + case *types.LiteralValue: + return utilities.GoToQueryString(v.Value) + case *types.ParameterizedValue: + return "@" + string(v.GetParameter()), nil + default: + return "", fmt.Errorf("unhandled dynamic value type: %T", v) } +} - if col.Func == types.FuncCodeWriteTime { - // todo what about collections? - if col.Alias != "" { - return fmt.Sprintf("UNIX_MICROS(WRITE_TIMESTAMP(%s, '%s')) AS %s", colMeta.ColumnFamily, colMeta.Name, col.Alias), nil - } - return fmt.Sprintf("UNIX_MICROS(WRITE_TIMESTAMP(%s, '%s'))", colMeta.ColumnFamily, colMeta.Name), nil +func createBtqlFunc(f *types.FunctionValue) (string, error) { + if f.GetParameter() != "" { + return "@" + string(f.GetParameter()), nil } - if col.Func == types.FuncCodeToTimestamp { - castValue, err := castScalarColumn(colMeta) + switch f.Func.GetCode() { + case types.FuncCodeCount: + arg0, err := toBtql(f.Args[0]) if err != nil { return "", err } - if col.Alias != "" { - return fmt.Sprintf("%s AS %s", castValue, col.Alias), nil - } - return castValue, nil - } - - if col.Func == types.FuncCodeNow { - if col.Alias != "" { - return "CURRENT_TIMESTAMP() AS " + col.Alias, nil // CURRENT_TIMESTAMP returns a timestamp, we'll convert it to UUID in result processor if needed, but it's better to return raw bits if we can. + return fmt.Sprintf("COUNT(%s)", arg0), nil + case types.FuncCodeWriteTime: + col, err := getColumnArg(0, f.Args) + if err != nil { + return "", err } - return "CURRENT_TIMESTAMP()", nil - } - - castValue, castErr := castScalarColumn(colMeta) - if castErr != nil { - return "", castErr - } - column := fmt.Sprintf("%s(%s)", col.Func.String(), castValue) - - if col.Alias != "" { - column = column + " as " + col.Alias + return fmt.Sprintf("UNIX_MICROS(WRITE_TIMESTAMP(%s, '%s'))", col.ColumnFamily, col.Name), nil + case types.FuncCodeAvg: + return createSimpleBtqlFunc(f) + case types.FuncCodeSum: + return createSimpleBtqlFunc(f) + case types.FuncCodeMin: + return createSimpleBtqlFunc(f) + case types.FuncCodeMax: + return createSimpleBtqlFunc(f) + default: + return "", fmt.Errorf("unhandled function translation: %s", f.Func.GetName()) } - - return column, nil } -func createBtqlSelectCol(tableConfig *sm.TableSchema, selectedColumn types.SelectedColumn, isGroupBy bool) (string, error) { - colName := selectedColumn.Sql - if selectedColumn.MapKey != "" { - colName = string(selectedColumn.ColumnName) - } - col, err := tableConfig.GetColumn(types.ColumnName(colName)) +func createSimpleBtqlFunc(f *types.FunctionValue) (string, error) { + col, err := getColumnArg(0, f.Args) if err != nil { return "", err } - var sql string - if isGroupBy { - sql, err = castScalarColumn(col) - if err != nil { - return "", err - } - } else { - sql, err = processRegularColumn(selectedColumn, col) - if err != nil { - return "", err - } + castValue, err := castScalarColumn(col) + if err != nil { + return "", err } + return fmt.Sprintf("%s(%s)", f.Func.GetName(), castValue), nil +} - if selectedColumn.Alias != "" { - sql = fmt.Sprintf("%s as %s", sql, selectedColumn.Alias) +func getColumnArgOrStar(index int, args []types.DynamicValue) (types.DynamicValue, error) { + value := args[index] + star, ok := value.(types.SelectStarValue) + if ok { + return star, nil + } + col, ok := value.(types.ColumnValue) + if ok { + return col, nil } - return sql, nil + return nil, fmt.Errorf("invalid argument: %T expected column or *", value) } -/* -processRegularColumn processes the given column based on its metadata and table context. - -It formats the column name differently depending on whether the current table name matches the column metadata's name. -If there is a match, the function qualifies the column name using the table name; otherwise, it formats the column name as standalone. -Additionally, if the column is not a collection, it builds a formatted reference that includes accessing the column within the specified column family; -if the column is a collection, it uses the preformatted column name from the metadata. - -Parameters: - - columnMetadata: Specifies metadata for the selected column, including its name and a field for storing the formatted version. - - tableName: The name of the current table to determine if table-qualified formatting is needed. - - columnFamily: The column family identifier used when constructing the column reference for non-collection types. - - colMeta: A pointer to column configuration containing additional details such as whether the column is a collection. - - columns: A slice of strings that accumulates the formatted column references. - -Returns: +func getColumnArg(index int, args []types.DynamicValue) (*types.Column, error) { + value := args[index] + col, ok := value.(*types.ColumnValue) + if !ok { + return nil, fmt.Errorf("invalid argument: %T expected a column", value) + } + return col.Column, nil +} - An updated slice of strings with the new formatted column reference appended. -*/ -func processRegularColumn(selectedColumn types.SelectedColumn, col *types.Column) (string, error) { - if col.CQLType.DataType().GetDataTypeCode() == primitive.DataTypeCodeList { - return fmt.Sprintf("MAP_VALUES(`%s`)", selectedColumn.Sql), nil - } else if selectedColumn.MapKey != "" { - return fmt.Sprintf("`%s`['%s']", selectedColumn.ColumnName, selectedColumn.MapKey), nil - } else if col.CQLType.IsCollection() { - return fmt.Sprintf("`%s`", selectedColumn.Sql), nil +func processRegularColumn(col *types.ColumnValue) (string, error) { + if col.Column.CQLType.Code() == types.LIST { + return fmt.Sprintf("MAP_VALUES(`%s`)", col.Column.Name), nil + } else if col.Column.CQLType.IsCollection() { + return fmt.Sprintf("`%s`", col.Column.Name), nil } else { - return castScalarColumn(col) + return castScalarColumn(col.Column) } } @@ -167,7 +139,7 @@ func createBigtableSql(t *SelectTranslator, st *types.PreparedSelectQuery) (stri if len(st.GroupByColumns) > 0 { isGroupBy = true } - column, err = createBtqlSelectClause(tableConfig, st.SelectClause, isGroupBy) + column, err = createBtqlSelectClause(st.SelectClause, isGroupBy) if err != nil { return "", err } @@ -182,10 +154,10 @@ func createBigtableSql(t *SelectTranslator, st *types.PreparedSelectQuery) (stri } // Build alias-to-column map - aliasToColumn := make(map[string]string) + aliasToColumn := make(map[string]bool) for _, col := range st.SelectClause.Columns { if col.Alias != "" { - aliasToColumn[col.Alias] = string(col.ColumnName) + aliasToColumn[col.Alias] = true } } @@ -241,7 +213,7 @@ func createBigtableSql(t *SelectTranslator, st *types.PreparedSelectQuery) (stri } if st.LimitValue != nil { - limitString, err := ToBtql(st.LimitValue) + limitString, err := toBtql(st.LimitValue) if err != nil { return "", err } @@ -251,19 +223,6 @@ func createBigtableSql(t *SelectTranslator, st *types.PreparedSelectQuery) (stri return btQuery, nil } -func ToBtql(dynamicValue types.DynamicValue) (string, error) { - switch v := dynamicValue.(type) { - case *types.LiteralValue: - return utilities.GoToString(v.Value) - case *types.ParameterizedValue: - return "@" + string(v.Parameter), nil - case *types.TimestampNowValue: - return "CURRENT_TIMESTAMP()", nil - default: - return "", fmt.Errorf("unhandled value type %T", v) - } -} - // createBtqlWhereClause(): takes a slice of Condition structs and returns a string representing the WHERE clause of a bigtable SQL query. // It iterates over the clauses and constructs the WHERE clause by combining the column name, operator, and value of each clause. // If the operator is "IN", the value is wrapped with the UNNEST function. @@ -285,24 +244,24 @@ func createBtqlWhereClause(conditions []types.Condition, tableConfig *sm.TableSc var btql string if condition.Operator == types.BETWEEN { - v1, err := ToBtql(condition.Value) + v1, err := toBtql(condition.Value) if err != nil { return "", err } - v2, err := ToBtql(condition.Value2) + v2, err := toBtql(condition.Value2) if err != nil { return "", err } btql = fmt.Sprintf("%s BETWEEN %s AND %s", column, v1, v2) } else if condition.Operator == types.IN { - v, err := ToBtql(condition.Value) + v, err := toBtql(condition.Value) if err != nil { return "", err } btql = fmt.Sprintf("%s IN UNNEST(%s)", column, v) } else if condition.Operator == types.CONTAINS || condition.Operator == types.CONTAINS_KEY { - v, err := ToBtql(condition.Value) + v, err := toBtql(condition.Value) if err != nil { return "", err } @@ -312,7 +271,7 @@ func createBtqlWhereClause(conditions []types.Condition, tableConfig *sm.TableSc btql = fmt.Sprintf("ARRAY_INCLUDES(MAP_VALUES(%s), %s)", column, v) } } else { - v, err := ToBtql(condition.Value) + v, err := toBtql(condition.Value) if err != nil { return "", err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select.go index 216333e1..d8297855 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select.go @@ -21,7 +21,6 @@ import ( "fmt" "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/global/types" "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/common" - "github.com/GoogleCloudPlatform/cloud-bigtable-ecosystem/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities" "github.com/datastax/go-cassandra-native-protocol/primitive" ) @@ -41,13 +40,13 @@ func (t *SelectTranslator) Translate(query *types.RawQuery, sessionKeyspace type return nil, err } - selectClause, err := parseSelectClause(selectObj.SelectElements(), tableConfig) + params := types.NewQueryParameterBuilder() + + selectClause, err := parseSelectClause(selectObj.SelectElements(), tableConfig, params) if err != nil { return nil, err } - - params := types.NewQueryParameterBuilder() - + conditions, err := common.ParseWhereClause(selectObj.WhereSpec(), tableConfig, params) if err != nil { return nil, err @@ -102,7 +101,7 @@ func (t *SelectTranslator) Bind(st types.IPreparedQuery, values *types.QueryPara } if sst.LimitValue != nil { - v, err := utilities.GetValueInt32(sst.LimitValue, values) + v, err := values.GetValueInt32(sst.LimitValue) if err != nil { return nil, err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select_test.go index 5f830a3d..92b4bf18 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/translator_select_test.go @@ -40,6 +40,17 @@ type Want struct { AllParams []*types.ParameterMetadata } +func NewSelectedColumnFunction(cql string, columnName string, alias string, funcCode types.CqlFuncCode, k types.Keyspace, t types.TableName) types.SelectedColumn { + f, _ := types.GetFunc(funcCode) + var arg types.DynamicValue + if columnName == "*" { + arg = types.NewSelectStarValue() + } else { + arg = types.NewColumnValue(mockdata.GetColumnOrDie(k, t, types.ColumnName(columnName))) + } + return types.NewSelectedColumn(cql, types.NewFunctionValue("", f, arg), alias) +} + func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { tests := []struct { @@ -61,43 +72,43 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), - *types.NewSelectedColumn("col_bool", "col_bool", "", types.TypeBoolean), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), + types.NewSelectedColumn("col_bool", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: types.EQ, - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), Operator: types.EQ, - Value: types.NewLiteralValue(true), + Value: types.NewLiteralValue(true, types.TypeBoolean), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), Operator: types.LTE, - Value: types.NewLiteralValue(time.UnixMilli(1430659854234).Truncate(time.Nanosecond).UTC()), + Value: types.NewLiteralValue(time.UnixMilli(1430659854234).Truncate(time.Nanosecond).UTC(), types.TypeTimestamp), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: types.GTE, - Value: types.NewLiteralValue(int32(123)), + Value: types.NewLiteralValue(int32(123), types.TypeInt), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: types.GT, - Value: types.NewLiteralValue(int64(-10000000)), + Value: types.NewLiteralValue(int64(-10000000), types.TypeBigInt), }, }, AllParams: []*types.ParameterMetadata{}, OrderBy: types.OrderBy{ IsOrderBy: false, }, - LimitValue: types.NewLiteralValue(int32(20)), + LimitValue: types.NewLiteralValue(int32(20), types.TypeInt), }, sessionKeyspace: "test_keyspace", }, @@ -105,19 +116,19 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { name: "Select query with list contains clause", query: `select col_int as name from test_keyspace.test_table where list_text CONTAINS 'test';`, want: &Want{ - TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) as name FROM test_table WHERE ARRAY_INCLUDES(MAP_VALUES(`list_text`), 'test');", + TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) AS name FROM test_table WHERE ARRAY_INCLUDES(MAP_VALUES(`list_text`), 'test');", Table: "test_table", Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("col_int", "col_int", "name", types.TypeInt), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), "name"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "list_text"), Operator: types.CONTAINS, - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeText), }, }, OrderBy: types.OrderBy{ @@ -131,19 +142,19 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { name: "Select query with map contains key clause", query: `select col_int as name from test_keyspace.test_table where map_text_text CONTAINS KEY 'test';`, want: &Want{ - TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) as name FROM test_table WHERE MAP_CONTAINS_KEY(`map_text_text`, 'test');", + TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) AS name FROM test_table WHERE MAP_CONTAINS_KEY(`map_text_text`, 'test');", Table: "test_table", Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("col_int", "col_int", "name", types.TypeInt), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), "name"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_text"), Operator: types.CONTAINS_KEY, - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeText), }, }, OrderBy: types.OrderBy{ @@ -156,19 +167,19 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { name: "Select query with set contains clause", query: `select col_int as name from test_keyspace.test_table where set_text CONTAINS 'test';`, want: &Want{ - TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) as name FROM test_table WHERE MAP_CONTAINS_KEY(`set_text`, 'test');", + TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) AS name FROM test_table WHERE MAP_CONTAINS_KEY(`set_text`, 'test');", Table: "test_table", Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("col_int", "col_int", "name", types.TypeInt), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), "name"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), Operator: types.CONTAINS, - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeText), }, }, OrderBy: types.OrderBy{ @@ -186,15 +197,15 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumnFunction("WRITETIME(col_int)", "col_int", "", types.TypeBigInt, types.FuncCodeWriteTime), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + NewSelectedColumnFunction("WRITETIME(col_int)", "col_int", "", types.FuncCodeWriteTime, "test_keyspace", "test_table"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, }, OrderBy: types.OrderBy{ @@ -212,14 +223,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewParameterizedValue("pk1"), + Value: types.NewParameterizedValue("pk1", types.TypeVarchar), }, }, OrderBy: types.OrderBy{ @@ -244,14 +255,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewParameterizedValue("x"), + Value: types.NewParameterizedValue("x", types.TypeVarchar), }, }, OrderBy: types.OrderBy{ @@ -276,14 +287,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: "IN", - Value: types.NewLiteralValue([]any{int32(1), int32(2), int32(3)}), + Value: types.NewLiteralValue([]any{int32(1), int32(2), int32(3)}, types.NewListType(types.TypeInt)), }, }, AllParams: []*types.ParameterMetadata{}}, @@ -298,14 +309,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: "IN", - Value: types.NewLiteralValue([]any{int64(1234567890), int64(9876543210)}), + Value: types.NewLiteralValue([]any{int64(1234567890), int64(9876543210)}, types.NewListType(types.TypeBigInt)), }, }, AllParams: []*types.ParameterMetadata{}}, @@ -320,14 +331,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_float"), Operator: "IN", - Value: types.NewLiteralValue([]any{float32(1.5), float32(2.5), float32(3.5)}), + Value: types.NewLiteralValue([]any{float32(1.5), float32(2.5), float32(3.5)}, types.NewListType(types.TypeFloat)), }, }, AllParams: []*types.ParameterMetadata{}}, @@ -342,14 +353,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_double"), Operator: "IN", - Value: types.NewLiteralValue([]any{3.1415926535, 2.7182818284}), + Value: types.NewLiteralValue([]any{3.1415926535, 2.7182818284}, types.NewListType(types.TypeDouble)), }, }, AllParams: []*types.ParameterMetadata{}}, @@ -364,14 +375,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), Operator: "IN", - Value: types.NewLiteralValue([]any{true, false}), + Value: types.NewLiteralValue([]any{true, false}, types.NewListType(types.TypeBoolean)), }, }, AllParams: []*types.ParameterMetadata{}}, @@ -393,7 +404,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -408,7 +419,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeInt)), }, }, }, @@ -429,7 +440,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -444,7 +455,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeBigInt)), }, }, }, @@ -459,7 +470,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -474,7 +485,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_float"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeFloat)), }, }, }, @@ -489,7 +500,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -504,7 +515,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_double"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeDouble)), }, }, }, @@ -519,7 +530,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -534,7 +545,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeBoolean)), }, }, }, @@ -549,7 +560,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -564,7 +575,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), Operator: "IN", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.NewListType(types.TypeBlob)), }, }, }, @@ -586,15 +597,15 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumnFunction("WRITETIME(col_int)", "col_int", "name", types.TypeBigInt, types.FuncCodeWriteTime), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + NewSelectedColumnFunction("WRITETIME(col_int)", "col_int", "name", types.FuncCodeWriteTime, "test_keyspace", "test_table"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, }, OrderBy: types.OrderBy{ @@ -607,19 +618,19 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { name: "As CqlQuery", query: `select col_int as name from test_keyspace.test_table where pk1 = 'test';`, want: &Want{ - TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) as name FROM test_table WHERE pk1 = 'test';", + TranslatedQuery: "SELECT TO_INT64(`cf1`['col_int']) AS name FROM test_table WHERE pk1 = 'test';", Table: "test_table", Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("col_int", "col_int", "name", types.TypeInt), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), "name"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, }, OrderBy: types.OrderBy{ @@ -665,47 +676,47 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), - *types.NewSelectedColumn("col_bool", "col_bool", "", types.TypeBoolean), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), + types.NewSelectedColumn("col_bool", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), Operator: "=", - Value: types.NewParameterizedValue("value1"), + Value: types.NewParameterizedValue("value1", types.TypeBoolean), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), Operator: "<=", - Value: types.NewParameterizedValue("value2"), + Value: types.NewParameterizedValue("value2", types.TypeTimestamp), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: ">=", - Value: types.NewParameterizedValue("value3"), + Value: types.NewParameterizedValue("value3", types.TypeInt), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: ">", - Value: types.NewParameterizedValue("value4"), + Value: types.NewParameterizedValue("value4", types.TypeBigInt), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: "<", - Value: types.NewParameterizedValue("value5"), + Value: types.NewParameterizedValue("value5", types.TypeBigInt), }, }, OrderBy: types.OrderBy{ IsOrderBy: false, }, - LimitValue: types.NewLiteralValue(int32(20000)), + LimitValue: types.NewLiteralValue(int32(20000), types.TypeInt), AllParams: []*types.ParameterMetadata{ { Key: "value0", @@ -756,41 +767,41 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), - *types.NewSelectedColumn("col_bool", "col_bool", "", types.TypeBoolean), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), + types.NewSelectedColumn("col_bool", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: "=", - Value: types.NewParameterizedValue("value1"), + Value: types.NewParameterizedValue("value1", types.TypeInt), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), Operator: "=", - Value: types.NewParameterizedValue("value2"), + Value: types.NewParameterizedValue("value2", types.TypeBoolean), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), Operator: "=", - Value: types.NewParameterizedValue("value3"), + Value: types.NewParameterizedValue("value3", types.TypeTimestamp), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), Operator: "=", - Value: types.NewParameterizedValue("value4"), + Value: types.NewParameterizedValue("value4", types.TypeInt), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), Operator: "=", - Value: types.NewParameterizedValue("value5"), + Value: types.NewParameterizedValue("value5", types.TypeBigInt), }, }, OrderBy: types.OrderBy{ @@ -846,12 +857,12 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), - *types.NewSelectedColumn("col_bool", "col_bool", "", types.TypeBoolean), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), + types.NewSelectedColumn("col_bool", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool")), ""), }, }, - LimitValue: types.NewLiteralValue(int32(20000)), + LimitValue: types.NewLiteralValue(int32(20000), types.TypeInt), AllParams: []*types.ParameterMetadata{}, OrderBy: types.OrderBy{ IsOrderBy: true, @@ -895,8 +906,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{}, @@ -904,12 +915,12 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "IN", - Value: types.NewLiteralValue([]any{"abc", "xyz"}), + Value: types.NewLiteralValue([]any{"abc", "xyz"}, types.NewListType(types.TypeVarchar)), }, }, }, @@ -924,8 +935,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -946,12 +957,12 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "IN", - Value: types.NewParameterizedValue("value1"), + Value: types.NewParameterizedValue("value1", types.NewListType(types.TypeVarchar)), }, }, }, @@ -966,8 +977,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{}, @@ -975,7 +986,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "LIKE", - Value: types.NewLiteralValue("test%"), + Value: types.NewLiteralValue("test%", types.TypeVarchar), }, }, }, @@ -988,8 +999,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{}, @@ -997,8 +1008,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "BETWEEN", - Value: types.NewLiteralValue("te'st"), - Value2: types.NewLiteralValue("test2"), + Value: types.NewLiteralValue("te'st", types.TypeVarchar), + Value2: types.NewLiteralValue("test2", types.TypeVarchar), }, }, }, @@ -1018,8 +1029,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -1034,7 +1045,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "LIKE", - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.TypeVarchar), }, }, }, @@ -1048,8 +1059,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { Table: "test_table", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumn("col_int", "col_int", "", types.TypeInt), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + types.NewSelectedColumn("col_int", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int")), ""), }, }, AllParams: []*types.ParameterMetadata{ @@ -1070,8 +1081,8 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "BETWEEN", - Value: types.NewParameterizedValue("value0"), - Value2: types.NewParameterizedValue("value1"), + Value: types.NewParameterizedValue("value0", types.TypeVarchar), + Value2: types.NewParameterizedValue("value1", types.TypeVarchar), }, }, }, @@ -1120,11 +1131,11 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT pk1 FROM test_table WHERE pk1 = 'abc';", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{}, - Conditions: []types.Condition{{Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", Value: types.NewLiteralValue("abc")}}, + Conditions: []types.Condition{{Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", Value: types.NewLiteralValue("abc", types.TypeVarchar)}}, }, sessionKeyspace: "other_keyspace", }, @@ -1137,11 +1148,11 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT pk1 FROM test_table WHERE pk1 = 'abc';", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, AllParams: []*types.ParameterMetadata{}, - Conditions: []types.Condition{{Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", Value: types.NewLiteralValue("abc")}}, + Conditions: []types.Condition{{Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", Value: types.NewLiteralValue("abc", types.TypeVarchar)}}, }, sessionKeyspace: "test_keyspace", }, @@ -1175,7 +1186,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { name: "CqlQuery with multiple aggregate functions", query: `select pk1, avg(col_int) as avg_col2, max(col_bool) as max_col3, min(col_int) as min_col4 from test_keyspace.test_table GROUP BY pk1;`, - wantErr: "invalid aggregate type: boolean", + wantErr: "parameter 0 doesn't accept type boolean", sessionKeyspace: "test_keyspace", }, { @@ -1187,12 +1198,12 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT pk1 FROM test_table LIMIT @value0;", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), }, }, OrderBy: types.OrderBy{}, GroupByColumns: nil, - LimitValue: types.NewParameterizedValue("value0"), + LimitValue: types.NewParameterizedValue("value0", types.TypeInt), AllParams: []*types.ParameterMetadata{ { Key: "value0", @@ -1213,14 +1224,14 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT MAP_VALUES(`tags`) FROM user_info WHERE ARRAY_INCLUDES(MAP_VALUES(`tags`), @value0);", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("tags", "tags", "", types.NewListType(types.TypeText)), + types.NewSelectedColumn("tags", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "user_info", "tags")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "user_info", "tags"), Operator: types.CONTAINS, - Value: types.NewParameterizedValue("value0"), + Value: types.NewParameterizedValue("value0", types.TypeText), }, }, OrderBy: types.OrderBy{}, @@ -1239,7 +1250,7 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { { name: "where clause comparison functions not supported yet", query: `SELECT count(*) FROM test_table WHERE name = ? AND col_ts < ToTimestamp(now());`, - wantErr: "parsing error", + wantErr: "unknown column 'name' in table test_keyspace.test_table", sessionKeyspace: "test_keyspace", }, { @@ -1248,17 +1259,17 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { want: &Want{ Keyspace: "test_keyspace", Table: "test_table", - TranslatedQuery: "SELECT count(*) FROM test_table WHERE TIMESTAMP_FROM_UNIX_MILLIS(TO_INT64(`cf1`['col_ts'])) < TIMESTAMP_FROM_UNIX_MILLIS(1764671400000);", + TranslatedQuery: "SELECT COUNT(*) FROM test_table WHERE TIMESTAMP_FROM_UNIX_MILLIS(TO_INT64(`cf1`['col_ts'])) < TIMESTAMP_FROM_UNIX_MILLIS(1764671400000);", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumnFunction("system.count(*)", "*", "", types.TypeBigInt, types.FuncCodeCount), + NewSelectedColumnFunction("system.count(*)", "*", "", types.FuncCodeCount, "test_keyspace", "test_table"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), Operator: types.LT, - Value: types.NewLiteralValue(time.Date(2025, 12, 2, 10, 30, 0, 0, time.UTC)), + Value: types.NewLiteralValue(time.Date(2025, 12, 2, 10, 30, 0, 0, time.UTC), types.TypeTimestamp), }, }, OrderBy: types.OrderBy{}, @@ -1273,17 +1284,17 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { want: &Want{ Keyspace: "test_keyspace", Table: "test_table", - TranslatedQuery: "SELECT count(*) FROM test_table WHERE TIMESTAMP_FROM_UNIX_MILLIS(TO_INT64(`cf1`['col_ts'])) < TIMESTAMP_FROM_UNIX_MILLIS(1764671400000);", + TranslatedQuery: "SELECT COUNT(*) FROM test_table WHERE TIMESTAMP_FROM_UNIX_MILLIS(TO_INT64(`cf1`['col_ts'])) < TIMESTAMP_FROM_UNIX_MILLIS(1764671400000);", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumnFunction("system.count(*)", "*", "", types.TypeBigInt, types.FuncCodeCount), + NewSelectedColumnFunction("system.count(*)", "*", "", types.FuncCodeCount, "test_keyspace", "test_table"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), Operator: types.LT, - Value: types.NewLiteralValue(time.Date(2025, 12, 2, 10, 30, 0, 0, time.UTC)), + Value: types.NewLiteralValue(time.Date(2025, 12, 2, 10, 30, 0, 0, time.UTC), types.TypeTimestamp), }, }, OrderBy: types.OrderBy{}, @@ -1301,21 +1312,21 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT pk, name, `cf1`['val'] FROM blob_table WHERE pk = FROM_BASE64('OTgyM2ZqYXMsdm0yZg==') AND `cf1`['val'] = FROM_BASE64('cGtqeHo=');", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk", "pk", "", types.TypeBlob), - *types.NewSelectedColumn("name", "name", "", types.TypeVarchar), - *types.NewSelectedColumn("val", "val", "", types.TypeBlob), + types.NewSelectedColumn("pk", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "pk")), ""), + types.NewSelectedColumn("name", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "name")), ""), + types.NewSelectedColumn("val", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "val")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "blob_table", "pk"), Operator: types.EQ, - Value: types.NewLiteralValue([]byte{0x39, 0x38, 0x32, 0x33, 0x66, 0x6a, 0x61, 0x73, 0x2c, 0x76, 0x6d, 0x32, 0x66}), + Value: types.NewLiteralValue([]byte{0x39, 0x38, 0x32, 0x33, 0x66, 0x6a, 0x61, 0x73, 0x2c, 0x76, 0x6d, 0x32, 0x66}, types.TypeBlob), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "blob_table", "val"), Operator: types.EQ, - Value: types.NewLiteralValue([]byte{0x70, 0x6b, 0x6a, 0x78, 0x7a}), + Value: types.NewLiteralValue([]byte{0x70, 0x6b, 0x6a, 0x78, 0x7a}, types.TypeBlob), }, }, OrderBy: types.OrderBy{}, @@ -1333,24 +1344,24 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT `cf1`['col_ascii'] FROM test_table WHERE pk1 = 'foo' AND pk2 = 'bar' AND `cf1`['col_ascii'] = 'fizz';", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("col_ascii", "col_ascii", "", types.TypeAscii), + types.NewSelectedColumn("col_ascii", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ascii")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: types.EQ, - Value: types.NewLiteralValue("foo"), + Value: types.NewLiteralValue("foo", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk2"), Operator: types.EQ, - Value: types.NewLiteralValue("bar"), + Value: types.NewLiteralValue("bar", types.TypeVarchar), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ascii"), Operator: types.EQ, - Value: types.NewLiteralValue("fizz"), + Value: types.NewLiteralValue("fizz", types.TypeAscii), }, }, OrderBy: types.OrderBy{}, @@ -1374,21 +1385,21 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { TranslatedQuery: "SELECT pk, name, `cf1`['val'] FROM blob_table WHERE pk <= FROM_BASE64('Ag==') AND name = 'blob-comparison-operators';", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk", "pk", "", types.TypeBlob), - *types.NewSelectedColumn("name", "name", "", types.TypeVarchar), - *types.NewSelectedColumn("val", "val", "", types.TypeBlob), + types.NewSelectedColumn("pk", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "pk")), ""), + types.NewSelectedColumn("name", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "name")), ""), + types.NewSelectedColumn("val", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "blob_table", "val")), ""), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "blob_table", "pk"), Operator: types.LTE, - Value: types.NewLiteralValue([]byte{0x02}), + Value: types.NewLiteralValue([]byte{0x02}, types.TypeBlob), }, { Column: mockdata.GetColumnOrDie("test_keyspace", "blob_table", "name"), Operator: types.EQ, - Value: types.NewLiteralValue("blob-comparison-operators"), + Value: types.NewLiteralValue("blob-comparison-operators", types.TypeVarchar), }, }, OrderBy: types.OrderBy{}, @@ -1401,20 +1412,20 @@ func TestTranslator_TranslateSelectQuerytoBigtable(t *testing.T) { name: "Valid GROUP BY with aggregate and ORDER BY", query: `select pk1, count(col_int) from test_keyspace.test_table where pk1 = 'test' GROUP BY pk1 ORDER BY pk1;`, want: &Want{ - TranslatedQuery: "SELECT pk1, count(TO_INT64(`cf1`['col_int'])) FROM test_table WHERE pk1 = 'test' GROUP BY pk1 ORDER BY pk1 asc;", + TranslatedQuery: "SELECT pk1, COUNT(TO_INT64(`cf1`['col_int'])) FROM test_table WHERE pk1 = 'test' GROUP BY pk1 ORDER BY pk1 asc;", Table: "test_table", Keyspace: "test_keyspace", SelectClause: &types.SelectClause{ Columns: []types.SelectedColumn{ - *types.NewSelectedColumn("pk1", "pk1", "", types.TypeVarchar), - *types.NewSelectedColumnFunction("system.count(col_int)", "col_int", "", types.TypeBigInt, types.FuncCodeCount), + types.NewSelectedColumn("pk1", types.NewColumnValue(mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1")), ""), + NewSelectedColumnFunction("system.count(col_int)", "col_int", "", types.FuncCodeCount, "test_keyspace", "test_table"), }, }, Conditions: []types.Condition{ { Column: mockdata.GetColumnOrDie("test_keyspace", "test_table", "pk1"), Operator: "=", - Value: types.NewLiteralValue("test"), + Value: types.NewLiteralValue("test", types.TypeVarchar), }, }, AllParams: []*types.ParameterMetadata{}, diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/utils.go index 355c5492..62ee00b1 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/select_translator/utils.go @@ -17,7 +17,7 @@ import ( // - input: The Select Element context from the antlr Parser. // // Returns: Columns Meta and an error if any. -func parseSelectClause(input cql.ISelectElementsContext, table *sm.TableSchema) (*types.SelectClause, error) { +func parseSelectClause(input cql.ISelectElementsContext, table *sm.TableSchema, params *types.QueryParameterBuilder) (*types.SelectClause, error) { if input == nil { return nil, errors.New("select clause empty") } @@ -40,7 +40,7 @@ func parseSelectClause(input cql.ISelectElementsContext, table *sm.TableSchema) } var selected types.SelectedColumn if val.SelectFunction() != nil { - selected, err = common.ParseSelectFunction(val.SelectFunction(), alias, table) + selected, err = common.ParseSelectFunction(val.SelectFunction(), alias, table, params) } else if val.SelectColumn() != nil { selected, err = common.ParseSelectColumn(val.SelectColumn(), alias, table) } else if val.SelectIndex() != nil { @@ -51,7 +51,7 @@ func parseSelectClause(input cql.ISelectElementsContext, table *sm.TableSchema) if err != nil { return nil, err } - if selected.ResultType == nil { + if selected.GetType() == nil { return nil, fmt.Errorf("unhandled result type") } selectedColumns = append(selectedColumns, selected) @@ -149,7 +149,7 @@ func selectedColumnsToMetadata(table *sm.TableSchema, selectClause *types.Select } var resultColumns []*message.ColumnMetadata for i, c := range selectClause.Columns { - name := c.Sql + name := c.Cql if c.Alias != "" { name = c.Alias } @@ -158,7 +158,7 @@ func selectedColumnsToMetadata(table *sm.TableSchema, selectClause *types.Select Table: string(table.Name), Name: name, Index: int32(i), - Type: c.ResultType.DataType(), + Type: c.GetType().DataType(), } resultColumns = append(resultColumns, &col) } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/translator_update_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/translator_update_test.go index ba2f33a6..08c85122 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/translator_update_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/translator_update_test.go @@ -52,11 +52,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Table: "test_table", IfExists: false, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -69,11 +69,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Table: "test_table", IfExists: true, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -106,11 +106,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { }, }, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0", types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewParameterizedValue("value1"), - types.NewParameterizedValue("value2"), + types.NewParameterizedValue("value1", types.TypeVarchar), + types.NewParameterizedValue("value2", types.TypeVarchar), }, }, }, @@ -142,11 +142,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { }, }, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("v1")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("v1", types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewParameterizedValue("v2"), - types.NewParameterizedValue("v3"), + types.NewParameterizedValue("v2", types.TypeVarchar), + types.NewParameterizedValue("v3", types.TypeVarchar), }, }, }, @@ -178,11 +178,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { }, }, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0")), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewParameterizedValue("value0", types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewParameterizedValue("value2"), - types.NewParameterizedValue("value1"), + types.NewParameterizedValue("value2", types.TypeVarchar), + types.NewParameterizedValue("value1", types.TypeVarchar), }, }, }, @@ -194,11 +194,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Table: "test_table", IfExists: false, Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewLiteralValue(true)), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bool"), types.NewLiteralValue(true, types.TypeBoolean)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -210,11 +210,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), types.NewLiteralValue(time.Date(2024, 8, 12, 12, 34, 56, 0, time.UTC))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_ts"), types.NewLiteralValue(time.Date(2024, 8, 12, 12, 34, 56, 0, time.UTC), types.TypeTimestamp)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -226,11 +226,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(123))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_int"), types.NewLiteralValue(int32(123), types.TypeInt)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -242,11 +242,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"}, types.NewSetType(types.TypeText))), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -258,11 +258,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_bool"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"key1": true, "key2": false})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_bool"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"key1": true, "key2": false}, types.NewMapType(types.TypeText, types.TypeBoolean))), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -274,11 +274,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewLiteralValue(int64(1234567890))), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_bigint"), types.NewLiteralValue(int64(1234567890), types.TypeBigInt)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -290,11 +290,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01}, types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("abc"), - types.NewLiteralValue("pkval"), + types.NewLiteralValue("abc", types.TypeVarchar), + types.NewLiteralValue("pkval", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -306,11 +306,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentAppend(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.PLUS, types.NewLiteralValue([]types.GoValue{"item3"}), false), + types.NewComplexAssignmentAppend(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.PLUS, types.NewLiteralValue([]types.GoValue{"item3"}, types.NewSetType(types.TypeText)), false), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -322,11 +322,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentAppend(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.MINUS, types.NewLiteralValue([]types.GoValue{"item2"}), false), + types.NewComplexAssignmentAppend(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.MINUS, types.NewLiteralValue([]types.GoValue{"item2"}, types.NewSetType(types.TypeText)), false), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -338,11 +338,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.PLUS, types.NewLiteralValue(int64(1))), + types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.PLUS, types.NewLiteralValue(int64(1), types.TypeCounter)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -359,11 +359,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.MINUS, types.NewLiteralValue(int64(9))), + types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.MINUS, types.NewLiteralValue(int64(9), types.TypeCounter)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -375,11 +375,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.PLUS, types.NewLiteralValue(int64(-9))), + types.NewAssignmentCounterIncrement(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_counter"), types.PLUS, types.NewLiteralValue(int64(-9), types.TypeCounter)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -391,11 +391,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01}, types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("abc"), - types.NewLiteralValue("pkval"), + types.NewLiteralValue("abc", types.TypeVarchar), + types.NewLiteralValue("pkval", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -412,11 +412,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"}, types.NewSetType(types.TypeText))), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -428,11 +428,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_bool"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"key1": true, "key2": false})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "map_text_bool"), types.NewLiteralValue(map[types.GoValue]types.GoValue{"key1": true, "key2": false}, types.NewMapType(types.TypeText, types.TypeBoolean))), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -444,11 +444,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "set_text"), types.NewLiteralValue([]types.GoValue{"item1", "item2"}, types.NewSetType(types.TypeText))), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("testText"), - types.NewLiteralValue("pk2"), + types.NewLiteralValue("testText", types.TypeVarchar), + types.NewLiteralValue("pk2", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, @@ -477,11 +477,11 @@ func TestTranslator_TranslateUpdateQuerytoBigtable(t *testing.T) { Keyspace: "test_keyspace", Table: "test_table", Values: []types.Assignment{ - types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01})), + types.NewComplexAssignmentSet(mockdata.GetColumnOrDie("test_keyspace", "test_table", "col_blob"), types.NewLiteralValue([]byte{0x01}, types.TypeBlob)), }, RowKeys: []types.DynamicValue{ - types.NewLiteralValue("abc"), - types.NewLiteralValue("pkval"), + types.NewLiteralValue("abc", types.TypeVarchar), + types.NewLiteralValue("pkval", types.TypeVarchar), }, AllParams: []*types.ParameterMetadata{}, }, diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/utils.go index ce59854a..d21a937b 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translators/update_translator/utils.go @@ -22,7 +22,7 @@ func parseUpdateValues(assignments []cql.IAssignmentElementContext, tableConfig if err != nil { return nil, err } - value, err := common.ParseValueAny(assignment.ValueAny(), col.CQLType, params, col) + value, err := common.ParseValueAny(assignment.ValueAny(), tableConfig, col.CQLType, types.QueryClauseValues, params, col) if err != nil { return nil, err } @@ -108,7 +108,7 @@ func ParseAppend(columnContext cql.IColumnContext, op cql.IArithmeticOperatorCon return nil, fmt.Errorf("cannot append on column type: %s", col.CQLType.String()) } - value, err := common.ParseValueAny(valueAny, valueType, params, col) + value, err := common.ParseValueAny(valueAny, tableConfig, valueType, types.QueryClauseValues, params, col) if err != nil { return nil, err } diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils.go index 796db19f..665e6d26 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils.go @@ -20,7 +20,6 @@ import ( "encoding/base64" "encoding/hex" "fmt" - "reflect" "sort" "strconv" "strings" @@ -264,7 +263,7 @@ func ParseBigInt(value string) (int64, error) { return val, err } -func GoToString(value types.GoValue) (string, error) { +func GoToQueryString(value types.GoValue) (string, error) { if value == nil { return "null", nil } @@ -302,7 +301,7 @@ func GoToString(value types.GoValue) (string, error) { case []interface{}: var values []string for _, vi := range v { - s, err := GoToString(vi) + s, err := GoToQueryString(vi) if err != nil { return "", err } @@ -463,8 +462,7 @@ func parseCqlTimestamp(timestampStr string) (time.Time, error) { func isSupportedCollectionElementType(dt datatype.DataType) bool { switch dt { - // todo support uuid and timeuuid - case datatype.Int, datatype.Bigint, datatype.Varchar, datatype.Float, datatype.Double, datatype.Timestamp, datatype.Boolean, datatype.Ascii: + case datatype.Int, datatype.Bigint, datatype.Varchar, datatype.Float, datatype.Double, datatype.Timestamp, datatype.Boolean, datatype.Ascii, datatype.Uuid, datatype.Timeuuid: return true default: return false @@ -729,103 +727,3 @@ func validateDataTypeDefinition(dt cql.IDataTypeContext, expectedTypeCount int) } return nil } - -func GetValueInt32(value types.DynamicValue, values *types.QueryParameterValues) (int32, error) { - v, err := value.GetValue(values) - if err != nil { - return 0, err - } - intVal, ok := v.(int32) - if !ok { - return 0, fmt.Errorf("query value is a %T, not an int32", v) - } - return intVal, nil -} - -func GetValueInt64(value types.DynamicValue, values *types.QueryParameterValues) (int64, error) { - v, err := value.GetValue(values) - if err != nil { - return 0, err - } - intVal, ok := v.(int64) - if !ok { - return 0, fmt.Errorf("query value is a %T, not an int64", v) - } - return intVal, nil -} - -func GetValueSlice(value types.DynamicValue, values *types.QueryParameterValues) ([]types.GoValue, error) { - v, err := value.GetValue(values) - if err != nil { - return nil, err - } - - if v == nil { - return nil, nil - } - - val := reflect.ValueOf(v) - - if val.Kind() != reflect.Slice { - return nil, fmt.Errorf("query value is a %T, not a slice", v) - } - - length := val.Len() - result := make([]types.GoValue, length) - - for i := 0; i < length; i++ { - anyVal := val.Index(i).Interface() - if anyVal == nil { - // don't allow collections to contain null elements to be consistent with Cassandra - return nil, fmt.Errorf("collection items are not allowed to be null") - } - result[i] = anyVal - } - - return result, nil -} - -func GetValueMap(value types.DynamicValue, values *types.QueryParameterValues) (map[types.GoValue]types.GoValue, error) { - v, err := value.GetValue(values) - if err != nil { - return nil, err - } - - if v == nil { - return nil, nil - } - - val := reflect.ValueOf(v) - - if val.Kind() != reflect.Map { - return nil, fmt.Errorf("value is a %T, not a map", v) - } - - result := make(map[types.GoValue]types.GoValue, val.Len()) - - // 3. Iterate over the keys of the original map - iter := val.MapRange() - for iter.Next() { - // Get the reflection Parameter for the key and the value - keyVal := iter.Key() - valueVal := iter.Value() - - // 4. Use .Interface() to convert the concrete key/value to an any (interface{}) - keyAny := keyVal.Interface() - valueAny := valueVal.Interface() - - if keyAny == nil { - // don't allow collections to contain null elements to be consistent with Cassandra - return nil, fmt.Errorf("map keys cannot be null") - } - - if valueAny == nil { - // don't allow collections to contain null elements to be consistent with Cassandra - return nil, fmt.Errorf("map values cannot be null") - } - - // 5. Add to the new map[any]any - result[keyAny] = valueAny - } - return result, nil -} diff --git a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils_test.go b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils_test.go index bb3a74d3..df47d4a0 100644 --- a/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils_test.go +++ b/cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/utilities/utils_test.go @@ -178,6 +178,8 @@ func TestIsSupportedCollectionElementType(t *testing.T) { {"Supported CQLType - Double", datatype.Double, true}, {"Supported CQLType - Timestamp", datatype.Timestamp, true}, {"Supported CQLType - Boolean", datatype.Boolean, true}, + {"Supported CQLType - UUID", datatype.Uuid, true}, + {"Supported CQLType - TimeUUID", datatype.Timeuuid, true}, {"Unsupported CQLType - Blob", datatype.Blob, false}, {"Unsupported CQLType - Map", datatype.NewMapType(datatype.Varchar, datatype.Int), false}, {"Unsupported CQLType - Set", datatype.NewSetType(datatype.Varchar), false},