diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y
index d4d7f01c..a225e060 100644
--- a/meta/src/meta/grammar.y
+++ b/meta/src/meta/grammar.y
@@ -71,8 +71,9 @@
 %nonterm construct logic.Construct
 %nonterm context transactions.Context
 %nonterm csv_asof String
-%nonterm csv_column logic.CSVColumn
-%nonterm csv_columns Sequence[logic.CSVColumn]
+%nonterm gnf_column logic.GNFColumn
+%nonterm gnf_column_path Sequence[String]
+%nonterm gnf_columns Sequence[logic.GNFColumn]
 %nonterm csv_config logic.CSVConfig
 %nonterm csv_data logic.CSVData
 %nonterm csv_locator_inline_data String
@@ -137,9 +138,9 @@
 %nonterm read transactions.Read
 %nonterm reduce logic.Reduce
 %nonterm rel_atom logic.RelAtom
-%nonterm rel_edb logic.RelEDB
-%nonterm rel_edb_path Sequence[String]
-%nonterm rel_edb_types Sequence[logic.Type]
+%nonterm edb logic.EDB
+%nonterm edb_path Sequence[String]
+%nonterm edb_types Sequence[logic.Type]
 %nonterm rel_term logic.RelTerm
 %nonterm relation_id logic.RelationId
 %nonterm script logic.Script
@@ -147,6 +148,7 @@
 %nonterm string_type logic.StringType
 %nonterm sum_monoid logic.SumMonoid
 %nonterm snapshot transactions.Snapshot
+%nonterm snapshot_mapping transactions.SnapshotMapping
 %nonterm sync transactions.Sync
 %nonterm term logic.Term
 %nonterm terms Sequence[logic.Term]
@@ -899,10 +901,10 @@ functional_dependency_values
     : "(" "values" var* ")"
 
 data
-    : rel_edb
-      construct: $$ = logic.Data(rel_edb=$1)
-      deconstruct if builtin.has_proto_field($$, 'rel_edb'):
-        $1: logic.RelEDB = $$.rel_edb
+    : edb
+      construct: $$ = logic.Data(edb=$1)
+      deconstruct if builtin.has_proto_field($$, 'edb'):
+        $1: logic.EDB = $$.edb
     | betree_relation
       construct: $$ = logic.Data(betree_relation=$1)
       deconstruct if builtin.has_proto_field($$, 'betree_relation'):
@@ -912,15 +914,15 @@ data
       deconstruct if builtin.has_proto_field($$, 'csv_data'):
         $1: logic.CSVData = $$.csv_data
 
-rel_edb_path
+edb_path
     : "[" STRING* "]"
 
-rel_edb_types
+edb_types
     : "[" type* "]"
 
-rel_edb
-    : "(" "rel_edb" relation_id rel_edb_path rel_edb_types ")"
-      construct: $$ = logic.RelEDB(target_id=$3, path=$4, types=$5)
+edb
+    : "(" "edb" relation_id edb_path edb_types ")"
+      construct: $$ = logic.EDB(target_id=$3, path=$4, types=$5)
       deconstruct:
         $3: logic.RelationId = $$.target_id
         $4: Sequence[String] = $$.path
@@ -947,19 +949,19 @@ betree_info_key_types
 betree_info_value_types
     : "(" "value_types" type* ")"
 
-csv_columns
-    : "(" "columns" csv_column* ")"
+gnf_columns
+    : "(" "columns" gnf_column* ")"
 
 csv_asof
     : "(" "asof" STRING ")"
 
 csv_data
-    : "(" "csv_data" csvlocator csv_config csv_columns csv_asof ")"
+    : "(" "csv_data" csvlocator csv_config gnf_columns csv_asof ")"
       construct: $$ = logic.CSVData(locator=$3, config=$4, columns=$5, asof=$6)
       deconstruct:
         $3: logic.CSVLocator = $$.locator
         $4: logic.CSVConfig = $$.config
-        $5: Sequence[logic.CSVColumn] = $$.columns
+        $5: Sequence[logic.GNFColumn] = $$.columns
         $6: String = $$.asof
 
 csv_locator_paths
@@ -980,12 +982,22 @@ csv_config
       construct: $$ = construct_csv_config($3)
       deconstruct: $3: Sequence[Tuple[String, logic.Value]] = deconstruct_csv_config($$)
 
-csv_column
-    : "(" "column" STRING relation_id "[" type* "]" ")"
-      construct: $$ = logic.CSVColumn(column_name=$3, target_id=$4, types=$6)
+gnf_column_path
+    : STRING
+      construct: $$ = [$1]
+      deconstruct if builtin.length($$) == 1:
+        $1: String = $$[0]
+    | "[" STRING* "]"
+      construct: $$ = $2
+      deconstruct if builtin.length($$) != 1:
+        $2: Sequence[String] = $$
+
+gnf_column
+    : "(" "column" gnf_column_path relation_id? "[" type* "]" ")"
+      construct: $$ = logic.GNFColumn(column_path=$3, target_id=$4, types=$6)
       deconstruct:
-        $3: String = $$.column_name
-        $4: logic.RelationId = $$.target_id
+        $3: Sequence[String] = $$.column_path
+        $4: Optional[logic.RelationId] = $$.target_id if builtin.has_proto_field($$, "target_id") else None
         $6: Sequence[logic.Type] = $$.types
 
 undefine
@@ -998,12 +1010,17 @@ context
       construct: $$ = transactions.Context(relations=$3)
       deconstruct: $3: Sequence[logic.RelationId] = $$.relations
 
-snapshot
-    : "(" "snapshot" rel_edb_path relation_id ")"
-      construct: $$ = transactions.Snapshot(destination_path=$3, source_relation=$4)
+snapshot_mapping
+    : edb_path relation_id
+      construct: $$ = transactions.SnapshotMapping(destination_path=$1, source_relation=$2)
       deconstruct:
-        $3: Sequence[String] = $$.destination_path
-        $4: logic.RelationId = $$.source_relation
+        $1: Sequence[String] = $$.destination_path
+        $2: logic.RelationId = $$.source_relation
+
+snapshot
+    : "(" "snapshot" snapshot_mapping* ")"
+      construct: $$ = transactions.Snapshot(mappings=$3)
+      deconstruct: $3: Sequence[transactions.SnapshotMapping] = $$.mappings
 
 epoch_reads
     : "(" "reads" read* ")"
diff --git a/meta/src/meta/yacc_action_parser.py b/meta/src/meta/yacc_action_parser.py
index 1d448e09..33dc765c 100644
--- a/meta/src/meta/yacc_action_parser.py
+++ b/meta/src/meta/yacc_action_parser.py
@@ -169,15 +169,15 @@ def _infer_type(
     elif isinstance(expr, ListExpr):
         return ListType(expr.element_type)
     elif isinstance(expr, GetElement):
-        # Infer tuple element type
-        tuple_type = _infer_type(expr.tuple_expr, line, ctx)
-        if isinstance(tuple_type, TupleType) and 0 <= expr.index < len(
-            tuple_type.elements
+        # Infer element type from tuple or sequence/list indexing
+        container_type = _infer_type(expr.tuple_expr, line, ctx)
+        if isinstance(container_type, TupleType) and 0 <= expr.index < len(
+            container_type.elements
         ):
-            return tuple_type.elements[expr.index]
-        raise YaccGrammarError(
-            f"Cannot infer type of tuple element access: {expr}", line
-        )
+            return container_type.elements[expr.index]
+        if isinstance(container_type, (SequenceType, ListType)):
+            return container_type.element_type
+        raise YaccGrammarError(f"Cannot infer type of element access: {expr}", line)
     elif isinstance(expr, GetField):
         # GetField has field_type from proto schema lookup (or Unknown if not found)
         return expr.field_type
diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto
index a64c4ef5..3ae1c8eb 100644
--- a/proto/relationalai/lqp/v1/logic.proto
+++ b/proto/relationalai/lqp/v1/logic.proto
@@ -232,14 +232,14 @@ message Attribute {
 //
 message Data {
   oneof data_type {
-    RelEDB rel_edb = 1;
+    EDB edb = 1;
     BeTreeRelation betree_relation = 2;
     CSVData csv_data = 3;
-    // IcebergRelation iceberg_relation = 4;
+    // IcebergData iceberg_data = 4;
   }
 }
 
-message RelEDB {
+message EDB {
   RelationId target_id = 1;
   repeated string path = 2;
   repeated Type types = 3;
@@ -277,7 +277,7 @@ message BeTreeLocator {
 message CSVData {
   CSVLocator locator = 1;
   CSVConfig config = 2;
-  repeated CSVColumn columns = 3;
+  repeated GNFColumn columns = 3;
   string asof = 4; // Blob storage timestamp for freshness requirements
 }
 
@@ -311,9 +311,9 @@ message CSVConfig {
   string compression = 11; // "none", "gzip", "zstd", "auto" (default: "auto")
 }
 
-message CSVColumn {
-  string column_name = 1; // Name in CSV file
-  RelationId target_id = 2; // Target relation
+message GNFColumn {
+  repeated string column_path = 1; // Column identifier path (was: string column_name)
+  optional RelationId target_id = 2; // Target relation (now explicit optional)
   repeated Type types = 3; // Relation signature (key types + value types)
 }
 
diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto
index e93725b3..30cdc4c5 100644
--- a/proto/relationalai/lqp/v1/transactions.proto
+++ b/proto/relationalai/lqp/v1/transactions.proto
@@ -64,13 +64,18 @@ message Context {
   repeated RelationId relations = 1;
 }
 
-// Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the
-// given path (specified as a sequence of strings, see RelEDB).
-message Snapshot {
+// A single (destination, source) pair within a Snapshot action.
+message SnapshotMapping {
   repeated string destination_path = 1;
   RelationId source_relation = 2;
 }
 
+// Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the
+// given paths (specified as sequences of strings, see EDB).
+message Snapshot {
+  repeated SnapshotMapping mappings = 1;
+}
+
 //
 // Export config
 //
diff --git a/sdks/go/src/lqp/v1/fragments.pb.go b/sdks/go/src/lqp/v1/fragments.pb.go
index d1c926e4..40051f74 100644
--- a/sdks/go/src/lqp/v1/fragments.pb.go
+++ b/sdks/go/src/lqp/v1/fragments.pb.go
@@ -205,10 +205,12 @@ var file_relationalai_lqp_v1_fragments_proto_rawDesc = string([]byte{
 	0x0a, 0x0a, 0x6f, 0x72, 0x69, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03,
 	0x28, 0x09, 0x52, 0x09, 0x6f, 0x72, 0x69, 0x67, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x1c, 0x0a,
 	0x0a, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x42, 0x1f, 0x5a, 0x1d, 0x6c,
-	0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x42, 0x43, 0x5a, 0x41, 0x67,
+	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71,
+	0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64,
+	0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31,
+	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 })
 
 var (
diff --git a/sdks/go/src/lqp/v1/logic.pb.go b/sdks/go/src/lqp/v1/logic.pb.go
index df23d7e5..6319fe4f 100644
--- a/sdks/go/src/lqp/v1/logic.pb.go
+++ b/sdks/go/src/lqp/v1/logic.pb.go
@@ -2464,7 +2464,7 @@ type Data struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// Types that are valid to be assigned to DataType:
 	//
-	//	*Data_RelEdb
+	//	*Data_Edb
 	//	*Data_BetreeRelation
 	//	*Data_CsvData
 	DataType      isData_DataType `protobuf_oneof:"data_type"`
@@ -2509,10 +2509,10 @@ func (x *Data) GetDataType() isData_DataType {
 	return nil
 }
 
-func (x *Data) GetRelEdb() *RelEDB {
+func (x *Data) GetEdb() *EDB {
 	if x != nil {
-		if x, ok := x.DataType.(*Data_RelEdb); ok {
-			return x.RelEdb
+		if x, ok := x.DataType.(*Data_Edb); ok {
+			return x.Edb
 		}
 	}
 	return nil
@@ -2540,8 +2540,8 @@ type isData_DataType interface {
 	isData_DataType()
 }
 
-type Data_RelEdb struct {
-	RelEdb *RelEDB `protobuf:"bytes,1,opt,name=rel_edb,json=relEdb,proto3,oneof"`
+type Data_Edb struct {
+	Edb *EDB `protobuf:"bytes,1,opt,name=edb,proto3,oneof"`
 }
 
 type Data_BetreeRelation struct {
@@ -2549,16 +2549,16 @@ type Data_BetreeRelation struct {
 }
 
 type Data_CsvData struct {
-	CsvData *CSVData `protobuf:"bytes,3,opt,name=csv_data,json=csvData,proto3,oneof"` // IcebergRelation iceberg_relation = 4;
+	CsvData *CSVData `protobuf:"bytes,3,opt,name=csv_data,json=csvData,proto3,oneof"` // IcebergData iceberg_data = 4;
 }
 
-func (*Data_RelEdb) isData_DataType() {}
+func (*Data_Edb) isData_DataType() {}
 
 func (*Data_BetreeRelation) isData_DataType() {}
 
 func (*Data_CsvData) isData_DataType() {}
 
-type RelEDB struct {
+type EDB struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	TargetId      *RelationId            `protobuf:"bytes,1,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"`
 	Path          []string               `protobuf:"bytes,2,rep,name=path,proto3" json:"path,omitempty"`
@@ -2567,20 +2567,20 @@ type RelEDB struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *RelEDB) Reset() {
-	*x = RelEDB{}
+func (x *EDB) Reset() {
+	*x = EDB{}
 	mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[38]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *RelEDB) String() string {
+func (x *EDB) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*RelEDB) ProtoMessage() {}
+func (*EDB) ProtoMessage() {}
 
-func (x *RelEDB) ProtoReflect() protoreflect.Message {
+func (x *EDB) ProtoReflect() protoreflect.Message {
 	mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[38]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -2592,26 +2592,26 @@ func (x *RelEDB) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use RelEDB.ProtoReflect.Descriptor instead.
-func (*RelEDB) Descriptor() ([]byte, []int) {
+// Deprecated: Use EDB.ProtoReflect.Descriptor instead.
+func (*EDB) Descriptor() ([]byte, []int) {
 	return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{38}
 }
 
-func (x *RelEDB) GetTargetId() *RelationId {
+func (x *EDB) GetTargetId() *RelationId {
 	if x != nil {
 		return x.TargetId
 	}
 	return nil
 }
 
-func (x *RelEDB) GetPath() []string {
+func (x *EDB) GetPath() []string {
 	if x != nil {
 		return x.Path
 	}
 	return nil
 }
 
-func (x *RelEDB) GetTypes() []*Type {
+func (x *EDB) GetTypes() []*Type {
 	if x != nil {
 		return x.Types
 	}
@@ -2908,7 +2908,7 @@ type CSVData struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Locator       *CSVLocator            `protobuf:"bytes,1,opt,name=locator,proto3" json:"locator,omitempty"`
 	Config        *CSVConfig             `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
-	Columns       []*CSVColumn           `protobuf:"bytes,3,rep,name=columns,proto3" json:"columns,omitempty"`
+	Columns       []*GNFColumn           `protobuf:"bytes,3,rep,name=columns,proto3" json:"columns,omitempty"`
 	Asof          string                 `protobuf:"bytes,4,opt,name=asof,proto3" json:"asof,omitempty"` // Blob storage timestamp for freshness requirements
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
@@ -2958,7 +2958,7 @@ func (x *CSVData) GetConfig() *CSVConfig {
 	return nil
 }
 
-func (x *CSVData) GetColumns() []*CSVColumn {
+func (x *CSVData) GetColumns() []*GNFColumn {
 	if x != nil {
 		return x.Columns
 	}
@@ -3154,29 +3154,29 @@ func (x *CSVConfig) GetCompression() string {
 	return ""
 }
 
-type CSVColumn struct {
+type GNFColumn struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
-	ColumnName    string                 `protobuf:"bytes,1,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"` // Name in CSV file
-	TargetId      *RelationId            `protobuf:"bytes,2,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"`       // Target relation
+	ColumnPath    []string               `protobuf:"bytes,1,rep,name=column_path,json=columnPath,proto3" json:"column_path,omitempty"` // Column identifier path (was: string column_name)
+	TargetId      *RelationId            `protobuf:"bytes,2,opt,name=target_id,json=targetId,proto3,oneof" json:"target_id,omitempty"` // Target relation (now explicit optional)
 	Types         []*Type                `protobuf:"bytes,3,rep,name=types,proto3" json:"types,omitempty"`                             // Relation signature (key types + value types)
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *CSVColumn) Reset() {
-	*x = CSVColumn{}
+func (x *GNFColumn) Reset() {
+	*x = GNFColumn{}
 	mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[46]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *CSVColumn) String() string {
+func (x *GNFColumn) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*CSVColumn) ProtoMessage() {}
+func (*GNFColumn) ProtoMessage() {}
 
-func (x *CSVColumn) ProtoReflect() protoreflect.Message {
+func (x *GNFColumn) ProtoReflect() protoreflect.Message {
 	mi := &file_relationalai_lqp_v1_logic_proto_msgTypes[46]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -3188,26 +3188,26 @@ func (x *CSVColumn) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use CSVColumn.ProtoReflect.Descriptor instead.
-func (*CSVColumn) Descriptor() ([]byte, []int) {
+// Deprecated: Use GNFColumn.ProtoReflect.Descriptor instead.
+func (*GNFColumn) Descriptor() ([]byte, []int) {
 	return file_relationalai_lqp_v1_logic_proto_rawDescGZIP(), []int{46}
 }
 
-func (x *CSVColumn) GetColumnName() string {
+func (x *GNFColumn) GetColumnPath() []string {
 	if x != nil {
-		return x.ColumnName
+		return x.ColumnPath
 	}
-	return ""
+	return nil
 }
 
-func (x *CSVColumn) GetTargetId() *RelationId {
+func (x *GNFColumn) GetTargetId() *RelationId {
 	if x != nil {
 		return x.TargetId
 	}
 	return nil
 }
 
-func (x *CSVColumn) GetTypes() []*Type {
+func (x *GNFColumn) GetTypes() []*Type {
 	if x != nil {
 		return x.Types
 	}
@@ -4811,263 +4811,266 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{
 	0x65, 0x12, 0x2e, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
 	0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
 	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x04, 0x61, 0x72, 0x67,
-	0x73, 0x22, 0xd6, 0x01, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x36, 0x0a, 0x07, 0x72, 0x65,
-	0x6c, 0x5f, 0x65, 0x64, 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65,
-	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76,
-	0x31, 0x2e, 0x52, 0x65, 0x6c, 0x45, 0x44, 0x42, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x6c, 0x45,
-	0x64, 0x62, 0x12, 0x4e, 0x0a, 0x0f, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x72, 0x65, 0x6c,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65,
+	0x73, 0x22, 0xcc, 0x01, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x03, 0x65, 0x64,
+	0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x44,
+	0x42, 0x48, 0x00, 0x52, 0x03, 0x65, 0x64, 0x62, 0x12, 0x4e, 0x0a, 0x0f, 0x62, 0x65, 0x74, 0x72,
+	0x65, 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
+	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65,
+	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65,
+	0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x08, 0x63, 0x73, 0x76, 0x5f,
+	0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x07, 0x63, 0x73, 0x76, 0x44,
+	0x61, 0x74, 0x61, 0x42, 0x0b, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x22, 0x88, 0x01, 0x0a, 0x03, 0x45, 0x44, 0x42, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67,
+	0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65,
 	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76,
-	0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x48, 0x00, 0x52, 0x0e, 0x62, 0x65, 0x74, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x08, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
-	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x44, 0x61,
-	0x74, 0x61, 0x48, 0x00, 0x52, 0x07, 0x63, 0x73, 0x76, 0x44, 0x61, 0x74, 0x61, 0x42, 0x0b, 0x0a,
-	0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x06, 0x52,
-	0x65, 0x6c, 0x45, 0x44, 0x42, 0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f,
-	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52,
-	0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65,
-	0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x03, 0x28,
-	0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70,
-	0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x8b, 0x01, 0x0a, 0x0e, 0x42, 0x65, 0x54,
-	0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61,
+	0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61,
+	0x72, 0x67, 0x65, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61,
 	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
-	0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
-	0x12, 0x44, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x66,
-	0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65,
-	0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9f, 0x02, 0x0a, 0x0a, 0x42, 0x65, 0x54, 0x72, 0x65,
-	0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x74, 0x79, 0x70,
-	0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54,
-	0x79, 0x70, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x3a, 0x0a,
-	0x0b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61,
-	0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0e, 0x73, 0x74, 0x6f,
-	0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
-	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x43, 0x6f,
-	0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x12, 0x4d, 0x0a, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
-	0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e,
-	0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70,
-	0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f,
-	0x72, 0x52, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x63, 0x61, 0x74,
-	0x6f, 0x72, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x81, 0x01, 0x0a, 0x0c, 0x42, 0x65, 0x54,
-	0x72, 0x65, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x70, 0x73,
-	0x69, 0x6c, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x65, 0x70, 0x73, 0x69,
-	0x6c, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x69, 0x76, 0x6f, 0x74,
-	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x50, 0x69, 0x76, 0x6f,
-	0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x73,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x74, 0x61,
-	0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x61, 0x66, 0x22, 0xca, 0x01, 0x0a,
-	0x0d, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x44,
-	0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
-	0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32,
-	0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x50, 0x61,
-	0x67, 0x65, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64,
-	0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x6c,
-	0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6c, 0x65, 0x6d, 0x65,
-	0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c,
-	0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
-	0x74, 0x72, 0x65, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x0a, 0x74, 0x72, 0x65, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x0a, 0x0a,
-	0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xca, 0x01, 0x0a, 0x07, 0x43, 0x53,
-	0x56, 0x44, 0x61, 0x74, 0x61, 0x12, 0x39, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56,
-	0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72,
-	0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e,
-	0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
-	0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75,
-	0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
-	0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
-	0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63,
-	0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e,
-	0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x0a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0xe3, 0x02, 0x0a, 0x09,
-	0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x65, 0x61,
-	0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x68,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x19, 0x0a, 0x08,
-	0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6e, 0x65, 0x77, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x69, 0x6d,
-	0x69, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x69,
-	0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68,
-	0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63,
-	0x68, 0x61, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61,
-	0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63,
-	0x68, 0x61, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x27, 0x0a,
-	0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73,
-	0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x5f, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x10, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70, 0x61, 0x72, 0x61,
-	0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x18,
-	0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12,
-	0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f,
-	0x6e, 0x22, 0x9b, 0x01, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12,
-	0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65,
-	0x12, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
-	0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, 0x12, 0x2f,
-	0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e,
-	0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70,
-	0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22,
-	0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x15, 0x0a,
-	0x06, 0x69, 0x64, 0x5f, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x69,
-	0x64, 0x4c, 0x6f, 0x77, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x64, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x06, 0x69, 0x64, 0x48, 0x69, 0x67, 0x68, 0x22, 0x89, 0x06,
-	0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x10, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63,
-	0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e,
-	0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69,
-	0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63,
-	0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72,
-	0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f,
-	0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71,
-	0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48,
-	0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a,
-	0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
-	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52,
-	0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61,
-	0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72,
+	0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0x8b, 0x01, 0x0a, 0x0e,
+	0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33,
+	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72,
 	0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e,
-	0x76, 0x31, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09,
-	0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e,
-	0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
-	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70,
-	0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65,
-	0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
-	0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31,
-	0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38,
-	0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x79, 0x70,
-	0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61,
-	0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74,
-	0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
-	0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c,
-	0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c,
-	0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61,
-	0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67,
-	0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54,
-	0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74,
-	0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
-	0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64,
-	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f,
-	0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e,
-	0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79,
-	0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70,
-	0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x55, 0x6e, 0x73,
-	0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a,
-	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x09, 0x0a, 0x07, 0x49, 0x6e,
-	0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79,
-	0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70,
-	0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22,
-	0x0a, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0e, 0x0a, 0x0c, 0x44,
-	0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x4d,
-	0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x41, 0x0a, 0x0b, 0x44, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65,
-	0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72,
-	0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, 0x0d, 0x0a,
-	0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0xd1, 0x04, 0x0a,
-	0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
-	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b,
-	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69,
-	0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00,
-	0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c,
-	0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48,
-	0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a,
-	0x0d, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04,
+	0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+	0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x9f, 0x02, 0x0a, 0x0a, 0x42, 0x65,
+	0x54, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x36, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f,
+	0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65,
+	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76,
+	0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x73,
+	0x12, 0x3a, 0x0a, 0x0b, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0e,
+	0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x04,
 	0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
-	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31,
-	0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31,
-	0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x31, 0x32,
-	0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e,
-	0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70,
-	0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
-	0x00, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48,
-	0x0a, 0x0d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
-	0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73,
-	0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x69, 0x73, 0x73,
-	0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65,
-	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72,
+	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65,
+	0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x4d, 0x0a, 0x10, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e,
+	0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63,
+	0x61, 0x74, 0x6f, 0x72, 0x52, 0x0f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f,
+	0x63, 0x61, 0x74, 0x6f, 0x72, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x81, 0x01, 0x0a, 0x0c,
+	0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18, 0x0a, 0x07,
+	0x65, 0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x65,
+	0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x69,
+	0x76, 0x6f, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x50,
+	0x69, 0x76, 0x6f, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c,
+	0x74, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x44, 0x65,
+	0x6c, 0x74, 0x61, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x65, 0x61, 0x66,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x4c, 0x65, 0x61, 0x66, 0x22,
+	0xca, 0x01, 0x0a, 0x0d, 0x42, 0x65, 0x54, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f,
+	0x72, 0x12, 0x44, 0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e,
+	0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x72, 0x6f, 0x6f,
+	0x74, 0x50, 0x61, 0x67, 0x65, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e,
+	0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a,
+	0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6c,
+	0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0c, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12,
+	0x1f, 0x0a, 0x0b, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x72, 0x65, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x42, 0x0a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xca, 0x01, 0x0a,
+	0x07, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x12, 0x39, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61,
+	0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
+	0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61,
+	0x74, 0x6f, 0x72, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e,
+	0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63,
+	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72,
 	0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e,
-	0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09,
-	0x64, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4b, 0x0a, 0x0e, 0x64, 0x61, 0x74,
-	0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
-	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65,
-	0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d,
-	0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e,
+	0x76, 0x31, 0x2e, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f,
+	0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56,
+	0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a,
+	0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x0a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0xe3,
+	0x02, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a,
+	0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x09, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73,
+	0x6b, 0x69, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12,
+	0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65,
+	0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64,
+	0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74,
+	0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f,
+	0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65,
+	0x63, 0x68, 0x61, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61,
+	0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
+	0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74,
+	0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69,
+	0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70,
+	0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69,
+	0x6e, 0x67, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69,
+	0x6e, 0x67, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f,
+	0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73,
+	0x73, 0x69, 0x6f, 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75,
+	0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x70, 0x61, 0x74,
+	0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x50,
+	0x61, 0x74, 0x68, 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65,
+	0x74, 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65,
+	0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x74, 0x61, 0x72, 0x67,
+	0x65, 0x74, 0x5f, 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x49, 0x64, 0x12, 0x15, 0x0a, 0x06, 0x69, 0x64, 0x5f, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x05, 0x69, 0x64, 0x4c, 0x6f, 0x77, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x64,
+	0x5f, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x06, 0x69, 0x64, 0x48,
+	0x69, 0x67, 0x68, 0x22, 0x89, 0x06, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x10,
+	0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73,
+	0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f,
+	0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e,
+	0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54,
+	0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f,
+	0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61,
+	0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79,
+	0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74,
+	0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31,
+	0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38,
+	0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65,
+	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76,
+	0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a,
+	0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61,
+	0x74, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e,
 	0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70,
-	0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65,
-	0x48, 0x00, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65,
-	0x12, 0x25, 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65,
-	0x61, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x22, 0x34, 0x0a, 0x0c, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65,
-	0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c,
-	0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06,
-	0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x33, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38,
-	0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d,
-	0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x47, 0x0a, 0x09, 0x44,
-	0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05,
-	0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e,
-	0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
-	0x03, 0x64, 0x61, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d,
-	0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f,
-	0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68,
-	0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64,
-	0x61, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05,
-	0x52, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x12, 0x16,
-	0x0a, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06,
-	0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73,
-	0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63,
-	0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x22, 0x7a, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63,
-	0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65,
-	0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05,
-	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65,
+	0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08,
+	0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65,
+	0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
+	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79,
+	0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79,
+	0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79,
+	0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d,
+	0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69,
+	0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
+	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70,
+	0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65,
+	0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f,
+	0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c,
+	0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22,
+	0x11, 0x0a, 0x0f, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79,
+	0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65,
+	0x22, 0x09, 0x0a, 0x07, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x46,
+	0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74,
+	0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, 0x32,
+	0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0a, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70,
+	0x65, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70,
+	0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65,
+	0x22, 0x41, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a,
+	0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63,
+	0x61, 0x6c, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79,
+	0x70, 0x65, 0x22, 0xd1, 0x04, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c,
+	0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65,
+	0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61,
+	0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76,
+	0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52,
+	0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x45, 0x0a,
+	0x0c, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38,
+	0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56,
+	0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65,
 	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76,
-	0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x42, 0x1f, 0x5a, 0x1d, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d,
-	0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c,
-	0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00,
+	0x52, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3f,
+	0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61,
+	0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12,
+	0x4b, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75,
+	0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61,
+	0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64,
+	0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d,
+	0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+	0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
+	0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
+	0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61,
+	0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52,
+	0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a,
+	0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x34, 0x0a, 0x0c, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32,
+	0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x33, 0x0a, 0x0b,
+	0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c,
+	0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a,
+	0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67,
+	0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75,
+	0x65, 0x22, 0x47, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12,
+	0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65,
+	0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0d, 0x44,
+	0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04,
+	0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72,
+	0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x75, 0x72,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x12, 0x16, 0x0a, 0x06,
+	0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6d, 0x69,
+	0x6e, 0x75, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x12, 0x20, 0x0a, 0x0b,
+	0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x22, 0x7a,
+	0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c,
+	0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05,
+	0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61,
+	0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
+	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61,
+	0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75,
+	0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b,
+	0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 })
 
 var (
@@ -5122,7 +5125,7 @@ var file_relationalai_lqp_v1_logic_proto_goTypes = []any{
 	(*Var)(nil),                  // 35: relationalai.lqp.v1.Var
 	(*Attribute)(nil),            // 36: relationalai.lqp.v1.Attribute
 	(*Data)(nil),                 // 37: relationalai.lqp.v1.Data
-	(*RelEDB)(nil),               // 38: relationalai.lqp.v1.RelEDB
+	(*EDB)(nil),                  // 38: relationalai.lqp.v1.EDB
 	(*BeTreeRelation)(nil),       // 39: relationalai.lqp.v1.BeTreeRelation
 	(*BeTreeInfo)(nil),           // 40: relationalai.lqp.v1.BeTreeInfo
 	(*BeTreeConfig)(nil),         // 41: relationalai.lqp.v1.BeTreeConfig
@@ -5130,7 +5133,7 @@ var file_relationalai_lqp_v1_logic_proto_goTypes = []any{
 	(*CSVData)(nil),              // 43: relationalai.lqp.v1.CSVData
 	(*CSVLocator)(nil),           // 44: relationalai.lqp.v1.CSVLocator
 	(*CSVConfig)(nil),            // 45: relationalai.lqp.v1.CSVConfig
-	(*CSVColumn)(nil),            // 46: relationalai.lqp.v1.CSVColumn
+	(*GNFColumn)(nil),            // 46: relationalai.lqp.v1.GNFColumn
 	(*RelationId)(nil),           // 47: relationalai.lqp.v1.RelationId
 	(*Type)(nil),                 // 48: relationalai.lqp.v1.Type
 	(*UnspecifiedType)(nil),      // 49: relationalai.lqp.v1.UnspecifiedType
@@ -5237,11 +5240,11 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{
 	35,  // 81: relationalai.lqp.v1.Term.var:type_name -> relationalai.lqp.v1.Var
 	60,  // 82: relationalai.lqp.v1.Term.constant:type_name -> relationalai.lqp.v1.Value
 	60,  // 83: relationalai.lqp.v1.Attribute.args:type_name -> relationalai.lqp.v1.Value
-	38,  // 84: relationalai.lqp.v1.Data.rel_edb:type_name -> relationalai.lqp.v1.RelEDB
+	38,  // 84: relationalai.lqp.v1.Data.edb:type_name -> relationalai.lqp.v1.EDB
 	39,  // 85: relationalai.lqp.v1.Data.betree_relation:type_name -> relationalai.lqp.v1.BeTreeRelation
 	43,  // 86: relationalai.lqp.v1.Data.csv_data:type_name -> relationalai.lqp.v1.CSVData
-	47,  // 87: relationalai.lqp.v1.RelEDB.target_id:type_name -> relationalai.lqp.v1.RelationId
-	48,  // 88: relationalai.lqp.v1.RelEDB.types:type_name -> relationalai.lqp.v1.Type
+	47,  // 87: relationalai.lqp.v1.EDB.target_id:type_name -> relationalai.lqp.v1.RelationId
+	48,  // 88: relationalai.lqp.v1.EDB.types:type_name -> relationalai.lqp.v1.Type
 	47,  // 89: relationalai.lqp.v1.BeTreeRelation.name:type_name -> relationalai.lqp.v1.RelationId
 	40,  // 90: relationalai.lqp.v1.BeTreeRelation.relation_info:type_name -> relationalai.lqp.v1.BeTreeInfo
 	48,  // 91: relationalai.lqp.v1.BeTreeInfo.key_types:type_name -> relationalai.lqp.v1.Type
@@ -5251,9 +5254,9 @@ var file_relationalai_lqp_v1_logic_proto_depIdxs = []int32{
 	61,  // 95: relationalai.lqp.v1.BeTreeLocator.root_pageid:type_name -> relationalai.lqp.v1.UInt128Value
 	44,  // 96: relationalai.lqp.v1.CSVData.locator:type_name -> relationalai.lqp.v1.CSVLocator
 	45,  // 97: relationalai.lqp.v1.CSVData.config:type_name -> relationalai.lqp.v1.CSVConfig
-	46,  // 98: relationalai.lqp.v1.CSVData.columns:type_name -> relationalai.lqp.v1.CSVColumn
-	47,  // 99: relationalai.lqp.v1.CSVColumn.target_id:type_name -> relationalai.lqp.v1.RelationId
-	48,  // 100: relationalai.lqp.v1.CSVColumn.types:type_name -> relationalai.lqp.v1.Type
+	46,  // 98: relationalai.lqp.v1.CSVData.columns:type_name -> relationalai.lqp.v1.GNFColumn
+	47,  // 99: relationalai.lqp.v1.GNFColumn.target_id:type_name -> relationalai.lqp.v1.RelationId
+	48,  // 100: relationalai.lqp.v1.GNFColumn.types:type_name -> relationalai.lqp.v1.Type
 	49,  // 101: relationalai.lqp.v1.Type.unspecified_type:type_name -> relationalai.lqp.v1.UnspecifiedType
 	50,  // 102: relationalai.lqp.v1.Type.string_type:type_name -> relationalai.lqp.v1.StringType
 	51,  // 103: relationalai.lqp.v1.Type.int_type:type_name -> relationalai.lqp.v1.IntType
@@ -5332,7 +5335,7 @@ func file_relationalai_lqp_v1_logic_proto_init() {
 		(*Term_Constant)(nil),
 	}
 	file_relationalai_lqp_v1_logic_proto_msgTypes[37].OneofWrappers = []any{
-		(*Data_RelEdb)(nil),
+		(*Data_Edb)(nil),
 		(*Data_BetreeRelation)(nil),
 		(*Data_CsvData)(nil),
 	}
@@ -5340,6 +5343,7 @@ func file_relationalai_lqp_v1_logic_proto_init() {
 		(*BeTreeLocator_RootPageid)(nil),
 		(*BeTreeLocator_InlineData)(nil),
 	}
+	file_relationalai_lqp_v1_logic_proto_msgTypes[46].OneofWrappers = []any{}
 	file_relationalai_lqp_v1_logic_proto_msgTypes[48].OneofWrappers = []any{
 		(*Type_UnspecifiedType)(nil),
 		(*Type_StringType)(nil),
diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go
index a1d58575..73527b07 100644
--- a/sdks/go/src/lqp/v1/transactions.pb.go
+++ b/sdks/go/src/lqp/v1/transactions.pb.go
@@ -571,9 +571,8 @@ func (x *Context) GetRelations() []*RelationId {
 	return nil
 }
 
-// Demand the source IDB, take an immutable snapshot, and turn it into an EDB under the
-// given path (specified as a sequence of strings, see RelEDB).
-type Snapshot struct {
+// A single (destination, source) pair within a Snapshot action.
+type SnapshotMapping struct {
 	state           protoimpl.MessageState `protogen:"open.v1"`
 	DestinationPath []string               `protobuf:"bytes,1,rep,name=destination_path,json=destinationPath,proto3" json:"destination_path,omitempty"`
 	SourceRelation  *RelationId            `protobuf:"bytes,2,opt,name=source_relation,json=sourceRelation,proto3" json:"source_relation,omitempty"`
@@ -581,20 +580,20 @@ type Snapshot struct {
 	sizeCache       protoimpl.SizeCache
 }
 
-func (x *Snapshot) Reset() {
-	*x = Snapshot{}
+func (x *SnapshotMapping) Reset() {
+	*x = SnapshotMapping{}
 	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[9]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *Snapshot) String() string {
+func (x *SnapshotMapping) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*Snapshot) ProtoMessage() {}
+func (*SnapshotMapping) ProtoMessage() {}
 
-func (x *Snapshot) ProtoReflect() protoreflect.Message {
+func (x *SnapshotMapping) ProtoReflect() protoreflect.Message {
 	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[9]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -606,25 +605,71 @@ func (x *Snapshot) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use Snapshot.ProtoReflect.Descriptor instead.
-func (*Snapshot) Descriptor() ([]byte, []int) {
+// Deprecated: Use SnapshotMapping.ProtoReflect.Descriptor instead.
+func (*SnapshotMapping) Descriptor() ([]byte, []int) {
 	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{9}
 }
 
-func (x *Snapshot) GetDestinationPath() []string {
+func (x *SnapshotMapping) GetDestinationPath() []string {
 	if x != nil {
 		return x.DestinationPath
 	}
 	return nil
 }
 
-func (x *Snapshot) GetSourceRelation() *RelationId {
+func (x *SnapshotMapping) GetSourceRelation() *RelationId {
 	if x != nil {
 		return x.SourceRelation
 	}
 	return nil
 }
 
+// Demand the source IDBs, take immutable snapshots, and turn them into EDBs under the
+// given paths (specified as sequences of strings, see EDB).
+type Snapshot struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Mappings      []*SnapshotMapping     `protobuf:"bytes,1,rep,name=mappings,proto3" json:"mappings,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Snapshot) Reset() {
+	*x = Snapshot{}
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Snapshot) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Snapshot) ProtoMessage() {}
+
+func (x *Snapshot) ProtoReflect() protoreflect.Message {
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Snapshot.ProtoReflect.Descriptor instead.
+func (*Snapshot) Descriptor() ([]byte, []int) {
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *Snapshot) GetMappings() []*SnapshotMapping {
+	if x != nil {
+		return x.Mappings
+	}
+	return nil
+}
+
 type ExportCSVConfig struct {
 	state               protoimpl.MessageState `protogen:"open.v1"`
 	Path                string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
@@ -642,7 +687,7 @@ type ExportCSVConfig struct {
 
 func (x *ExportCSVConfig) Reset() {
 	*x = ExportCSVConfig{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -654,7 +699,7 @@ func (x *ExportCSVConfig) String() string {
 func (*ExportCSVConfig) ProtoMessage() {}
 
 func (x *ExportCSVConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[10]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -667,7 +712,7 @@ func (x *ExportCSVConfig) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ExportCSVConfig.ProtoReflect.Descriptor instead.
 func (*ExportCSVConfig) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{10}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *ExportCSVConfig) GetPath() string {
@@ -743,7 +788,7 @@ type ExportCSVColumn struct {
 
 func (x *ExportCSVColumn) Reset() {
 	*x = ExportCSVColumn{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -755,7 +800,7 @@ func (x *ExportCSVColumn) String() string {
 func (*ExportCSVColumn) ProtoMessage() {}
 
 func (x *ExportCSVColumn) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[11]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -768,7 +813,7 @@ func (x *ExportCSVColumn) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ExportCSVColumn.ProtoReflect.Descriptor instead.
 func (*ExportCSVColumn) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{11}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *ExportCSVColumn) GetColumnName() string {
@@ -801,7 +846,7 @@ type Read struct {
 
 func (x *Read) Reset() {
 	*x = Read{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -813,7 +858,7 @@ func (x *Read) String() string {
 func (*Read) ProtoMessage() {}
 
 func (x *Read) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[12]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -826,7 +871,7 @@ func (x *Read) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Read.ProtoReflect.Descriptor instead.
 func (*Read) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{12}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{13}
 }
 
 func (x *Read) GetReadType() isRead_ReadType {
@@ -924,7 +969,7 @@ type Demand struct {
 
 func (x *Demand) Reset() {
 	*x = Demand{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -936,7 +981,7 @@ func (x *Demand) String() string {
 func (*Demand) ProtoMessage() {}
 
 func (x *Demand) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[13]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -949,7 +994,7 @@ func (x *Demand) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Demand.ProtoReflect.Descriptor instead.
 func (*Demand) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{13}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *Demand) GetRelationId() *RelationId {
@@ -969,7 +1014,7 @@ type Output struct {
 
 func (x *Output) Reset() {
 	*x = Output{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -981,7 +1026,7 @@ func (x *Output) String() string {
 func (*Output) ProtoMessage() {}
 
 func (x *Output) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[14]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -994,7 +1039,7 @@ func (x *Output) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Output.ProtoReflect.Descriptor instead.
 func (*Output) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{14}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *Output) GetName() string {
@@ -1023,7 +1068,7 @@ type Export struct {
 
 func (x *Export) Reset() {
 	*x = Export{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -1035,7 +1080,7 @@ func (x *Export) String() string {
 func (*Export) ProtoMessage() {}
 
 func (x *Export) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[15]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1048,7 +1093,7 @@ func (x *Export) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Export.ProtoReflect.Descriptor instead.
 func (*Export) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{15}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *Export) GetExportConfig() isExport_ExportConfig {
@@ -1087,7 +1132,7 @@ type WhatIf struct {
 
 func (x *WhatIf) Reset() {
 	*x = WhatIf{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -1099,7 +1144,7 @@ func (x *WhatIf) String() string {
 func (*WhatIf) ProtoMessage() {}
 
 func (x *WhatIf) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[16]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1112,7 +1157,7 @@ func (x *WhatIf) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use WhatIf.ProtoReflect.Descriptor instead.
 func (*WhatIf) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{16}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *WhatIf) GetBranch() string {
@@ -1139,7 +1184,7 @@ type Abort struct {
 
 func (x *Abort) Reset() {
 	*x = Abort{}
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[18]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -1151,7 +1196,7 @@ func (x *Abort) String() string {
 func (*Abort) ProtoMessage() {}
 
 func (x *Abort) ProtoReflect() protoreflect.Message {
-	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[17]
+	mi := &file_relationalai_lqp_v1_transactions_proto_msgTypes[18]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1164,7 +1209,7 @@ func (x *Abort) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Abort.ProtoReflect.Descriptor instead.
 func (*Abort) Descriptor() ([]byte, []int) {
-	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{17}
+	return file_relationalai_lqp_v1_transactions_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *Abort) GetName() string {
@@ -1258,116 +1303,124 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{
 	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
 	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74,
 	0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x22, 0x7f, 0x0a, 0x08, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x29, 0x0a, 0x10,
-	0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x12, 0x48, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63,
-	0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e,
-	0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49,
-	0x64, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x22, 0xc4, 0x04, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74,
-	0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
-	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43,
-	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
-	0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
-	0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61,
-	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, 0x12, 0x25,
-	0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69,
-	0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f,
-	0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08,
-	0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
-	0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78,
-	0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18,
-	0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d,
-	0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12,
-	0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18,
-	0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x44,
-	0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61,
-	0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28,
-	0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, 0x74, 0x65,
-	0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61,
-	0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, 0x20, 0x01,
-	0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, 0x63, 0x61,
-	0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61,
-	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c,
-	0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12,
-	0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72,
-	0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69,
-	0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d,
-	0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a,
-	0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68,
-	0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73,
-	0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f,
-	0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63,
-	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b,
-	0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
-	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x22, 0xa4,
-	0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65,
-	0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35,
-	0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b,
-	0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71,
-	0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x06, 0x6f,
-	0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x66,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x68, 0x61,
-	0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x32, 0x0a,
-	0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72,
+	0x22, 0x86, 0x01, 0x0a, 0x0f, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70,
+	0x70, 0x69, 0x6e, 0x67, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f,
+	0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x12,
+	0x48, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52,
+	0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63,
+	0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x08, 0x53, 0x6e, 0x61,
+	0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x08, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x6d,
+	0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x22, 0xc4, 0x04, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f,
+	0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70,
+	0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12,
+	0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f,
+	0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74,
+	0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03,
+	0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a,
+	0x65, 0x88, 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73,
+	0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d,
+	0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73,
+	0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78,
+	0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15,
+	0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73,
+	0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73,
+	0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f,
+	0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73,
+	0x79, 0x6e, 0x74, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a,
+	0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61,
+	0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61,
+	0x78, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a,
+	0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68,
+	0x61, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74,
+	0x61, 0x78, 0x45, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42,
+	0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69,
+	0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69,
+	0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65,
+	0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e,
+	0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65,
+	0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71,
+	0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e,
+	0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74,
+	0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
+	0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61,
+	0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74,
+	0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65,
+	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
+	0x44, 0x61, 0x74, 0x61, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a,
+	0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
+	0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70,
+	0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65,
+	0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75,
+	0x74, 0x48, 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77,
+	0x68, 0x61, 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72,
 	0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e,
-	0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x05, 0x61, 0x62, 0x6f, 0x72,
-	0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69,
-	0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00,
-	0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64,
-	0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12,
-	0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
-	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49,
-	0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
-	0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
-	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49,
-	0x64, 0x22, 0x60, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63,
-	0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
-	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66,
-	0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x16, 0x0a,
-	0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62,
-	0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
-	0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x5d, 0x0a, 0x05, 0x41, 0x62, 0x6f, 0x72, 0x74,
-	0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e,
-	0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74,
-	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d,
+	0x76, 0x31, 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61,
+	0x74, 0x49, 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61,
+	0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00,
+	0x52, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72,
+	0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78,
+	0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b,
+	0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44,
+	0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75,
+	0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x60, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72,
+	0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f,
+	0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63,
+	0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f,
+	0x72, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, 0x57, 0x68, 0x61,
+	0x74, 0x49, 0x66, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x05, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31,
+	0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x5d, 0x0a,
+	0x05, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65,
+	0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c,
+	0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64,
+	0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a,
+	0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65,
+	0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45,
+	0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49,
+	0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41,
+	0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12,
+	0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c,
+	0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d,
 	0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c,
-	0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19,
-	0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45,
-	0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49,
-	0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41,
-	0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e,
-	0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03,
-	0x42, 0x1f, 0x5a, 0x1d, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72,
-	0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76,
-	0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41,
+	0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f,
+	0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
 })
 
 var (
@@ -1383,7 +1436,7 @@ func file_relationalai_lqp_v1_transactions_proto_rawDescGZIP() []byte {
 }
 
 var file_relationalai_lqp_v1_transactions_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
+var file_relationalai_lqp_v1_transactions_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
 var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{
 	(MaintenanceLevel)(0),   // 0: relationalai.lqp.v1.MaintenanceLevel
 	(*Transaction)(nil),     // 1: relationalai.lqp.v1.Transaction
@@ -1395,18 +1448,19 @@ var file_relationalai_lqp_v1_transactions_proto_goTypes = []any{
 	(*Define)(nil),          // 7: relationalai.lqp.v1.Define
 	(*Undefine)(nil),        // 8: relationalai.lqp.v1.Undefine
 	(*Context)(nil),         // 9: relationalai.lqp.v1.Context
-	(*Snapshot)(nil),        // 10: relationalai.lqp.v1.Snapshot
-	(*ExportCSVConfig)(nil), // 11: relationalai.lqp.v1.ExportCSVConfig
-	(*ExportCSVColumn)(nil), // 12: relationalai.lqp.v1.ExportCSVColumn
-	(*Read)(nil),            // 13: relationalai.lqp.v1.Read
-	(*Demand)(nil),          // 14: relationalai.lqp.v1.Demand
-	(*Output)(nil),          // 15: relationalai.lqp.v1.Output
-	(*Export)(nil),          // 16: relationalai.lqp.v1.Export
-	(*WhatIf)(nil),          // 17: relationalai.lqp.v1.WhatIf
-	(*Abort)(nil),           // 18: relationalai.lqp.v1.Abort
-	(*FragmentId)(nil),      // 19: relationalai.lqp.v1.FragmentId
-	(*Fragment)(nil),        // 20: relationalai.lqp.v1.Fragment
-	(*RelationId)(nil),      // 21: relationalai.lqp.v1.RelationId
+	(*SnapshotMapping)(nil), // 10: relationalai.lqp.v1.SnapshotMapping
+	(*Snapshot)(nil),        // 11: relationalai.lqp.v1.Snapshot
+	(*ExportCSVConfig)(nil), // 12: relationalai.lqp.v1.ExportCSVConfig
+	(*ExportCSVColumn)(nil), // 13: relationalai.lqp.v1.ExportCSVColumn
+	(*Read)(nil),            // 14: relationalai.lqp.v1.Read
+	(*Demand)(nil),          // 15: relationalai.lqp.v1.Demand
+	(*Output)(nil),          // 16: relationalai.lqp.v1.Output
+	(*Export)(nil),          // 17: relationalai.lqp.v1.Export
+	(*WhatIf)(nil),          // 18: relationalai.lqp.v1.WhatIf
+	(*Abort)(nil),           // 19: relationalai.lqp.v1.Abort
+	(*FragmentId)(nil),      // 20: relationalai.lqp.v1.FragmentId
+	(*Fragment)(nil),        // 21: relationalai.lqp.v1.Fragment
+	(*RelationId)(nil),      // 22: relationalai.lqp.v1.RelationId
 }
 var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{
 	5,  // 0: relationalai.lqp.v1.Transaction.epochs:type_name -> relationalai.lqp.v1.Epoch
@@ -1414,34 +1468,35 @@ var file_relationalai_lqp_v1_transactions_proto_depIdxs = []int32{
 	4,  // 2: relationalai.lqp.v1.Transaction.sync:type_name -> relationalai.lqp.v1.Sync
 	3,  // 3: relationalai.lqp.v1.Configure.ivm_config:type_name -> relationalai.lqp.v1.IVMConfig
 	0,  // 4: relationalai.lqp.v1.IVMConfig.level:type_name -> relationalai.lqp.v1.MaintenanceLevel
-	19, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId
+	20, // 5: relationalai.lqp.v1.Sync.fragments:type_name -> relationalai.lqp.v1.FragmentId
 	6,  // 6: relationalai.lqp.v1.Epoch.writes:type_name -> relationalai.lqp.v1.Write
-	13, // 7: relationalai.lqp.v1.Epoch.reads:type_name -> relationalai.lqp.v1.Read
+	14, // 7: relationalai.lqp.v1.Epoch.reads:type_name -> relationalai.lqp.v1.Read
 	7,  // 8: relationalai.lqp.v1.Write.define:type_name -> relationalai.lqp.v1.Define
 	8,  // 9: relationalai.lqp.v1.Write.undefine:type_name -> relationalai.lqp.v1.Undefine
 	9,  // 10: relationalai.lqp.v1.Write.context:type_name -> relationalai.lqp.v1.Context
-	10, // 11: relationalai.lqp.v1.Write.snapshot:type_name -> relationalai.lqp.v1.Snapshot
-	20, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment
-	19, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId
-	21, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId
-	21, // 15: relationalai.lqp.v1.Snapshot.source_relation:type_name -> relationalai.lqp.v1.RelationId
-	12, // 16: relationalai.lqp.v1.ExportCSVConfig.data_columns:type_name -> relationalai.lqp.v1.ExportCSVColumn
-	21, // 17: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId
-	14, // 18: relationalai.lqp.v1.Read.demand:type_name -> relationalai.lqp.v1.Demand
-	15, // 19: relationalai.lqp.v1.Read.output:type_name -> relationalai.lqp.v1.Output
-	17, // 20: relationalai.lqp.v1.Read.what_if:type_name -> relationalai.lqp.v1.WhatIf
-	18, // 21: relationalai.lqp.v1.Read.abort:type_name -> relationalai.lqp.v1.Abort
-	16, // 22: relationalai.lqp.v1.Read.export:type_name -> relationalai.lqp.v1.Export
-	21, // 23: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId
-	21, // 24: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId
-	11, // 25: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig
-	5,  // 26: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch
-	21, // 27: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId
-	28, // [28:28] is the sub-list for method output_type
-	28, // [28:28] is the sub-list for method input_type
-	28, // [28:28] is the sub-list for extension type_name
-	28, // [28:28] is the sub-list for extension extendee
-	0,  // [0:28] is the sub-list for field type_name
+	11, // 11: relationalai.lqp.v1.Write.snapshot:type_name -> relationalai.lqp.v1.Snapshot
+	21, // 12: relationalai.lqp.v1.Define.fragment:type_name -> relationalai.lqp.v1.Fragment
+	20, // 13: relationalai.lqp.v1.Undefine.fragment_id:type_name -> relationalai.lqp.v1.FragmentId
+	22, // 14: relationalai.lqp.v1.Context.relations:type_name -> relationalai.lqp.v1.RelationId
+	22, // 15: relationalai.lqp.v1.SnapshotMapping.source_relation:type_name -> relationalai.lqp.v1.RelationId
+	10, // 16: relationalai.lqp.v1.Snapshot.mappings:type_name -> relationalai.lqp.v1.SnapshotMapping
+	13, // 17: relationalai.lqp.v1.ExportCSVConfig.data_columns:type_name -> relationalai.lqp.v1.ExportCSVColumn
+	22, // 18: relationalai.lqp.v1.ExportCSVColumn.column_data:type_name -> relationalai.lqp.v1.RelationId
+	15, // 19: relationalai.lqp.v1.Read.demand:type_name -> relationalai.lqp.v1.Demand
+	16, // 20: relationalai.lqp.v1.Read.output:type_name -> relationalai.lqp.v1.Output
+	18, // 21: relationalai.lqp.v1.Read.what_if:type_name -> relationalai.lqp.v1.WhatIf
+	19, // 22: relationalai.lqp.v1.Read.abort:type_name -> relationalai.lqp.v1.Abort
+	17, // 23: relationalai.lqp.v1.Read.export:type_name -> relationalai.lqp.v1.Export
+	22, // 24: relationalai.lqp.v1.Demand.relation_id:type_name -> relationalai.lqp.v1.RelationId
+	22, // 25: relationalai.lqp.v1.Output.relation_id:type_name -> relationalai.lqp.v1.RelationId
+	12, // 26: relationalai.lqp.v1.Export.csv_config:type_name -> relationalai.lqp.v1.ExportCSVConfig
+	5,  // 27: relationalai.lqp.v1.WhatIf.epoch:type_name -> relationalai.lqp.v1.Epoch
+	22, // 28: relationalai.lqp.v1.Abort.relation_id:type_name -> relationalai.lqp.v1.RelationId
+	29, // [29:29] is the sub-list for method output_type
+	29, // [29:29] is the sub-list for method input_type
+	29, // [29:29] is the sub-list for extension type_name
+	29, // [29:29] is the sub-list for extension extendee
+	0,  // [0:29] is the sub-list for field type_name
 }
 
 func init() { file_relationalai_lqp_v1_transactions_proto_init() }
@@ -1458,15 +1513,15 @@ func file_relationalai_lqp_v1_transactions_proto_init() {
 		(*Write_Context)(nil),
 		(*Write_Snapshot)(nil),
 	}
-	file_relationalai_lqp_v1_transactions_proto_msgTypes[10].OneofWrappers = []any{}
-	file_relationalai_lqp_v1_transactions_proto_msgTypes[12].OneofWrappers = []any{
+	file_relationalai_lqp_v1_transactions_proto_msgTypes[11].OneofWrappers = []any{}
+	file_relationalai_lqp_v1_transactions_proto_msgTypes[13].OneofWrappers = []any{
 		(*Read_Demand)(nil),
 		(*Read_Output)(nil),
 		(*Read_WhatIf)(nil),
 		(*Read_Abort)(nil),
 		(*Read_Export)(nil),
 	}
-	file_relationalai_lqp_v1_transactions_proto_msgTypes[15].OneofWrappers = []any{
+	file_relationalai_lqp_v1_transactions_proto_msgTypes[16].OneofWrappers = []any{
 		(*Export_CsvConfig)(nil),
 	}
 	type x struct{}
@@ -1475,7 +1530,7 @@ func file_relationalai_lqp_v1_transactions_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_relationalai_lqp_v1_transactions_proto_rawDesc), len(file_relationalai_lqp_v1_transactions_proto_rawDesc)),
 			NumEnums:      1,
-			NumMessages:   18,
+			NumMessages:   19,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go
index 32010315..4016cd4b 100644
--- a/sdks/go/src/parser.go
+++ b/sdks/go/src/parser.go
@@ -524,150 +524,150 @@ func toPascalCase(s string) string {
 // --- Helper functions ---
 
 func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 {
-	var _t1322 interface{}
+	var _t1350 interface{}
 	if (value != nil && hasProtoField(value, "int_value")) {
 		return int32(value.GetIntValue())
 	}
-	_ = _t1322
+	_ = _t1350
 	return int32(default_)
 }
 
 func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 {
-	var _t1323 interface{}
+	var _t1351 interface{}
 	if (value != nil && hasProtoField(value, "int_value")) {
 		return value.GetIntValue()
 	}
-	_ = _t1323
+	_ = _t1351
 	return default_
 }
 
 func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string {
-	var _t1324 interface{}
+	var _t1352 interface{}
 	if (value != nil && hasProtoField(value, "string_value")) {
 		return value.GetStringValue()
 	}
-	_ = _t1324
+	_ = _t1352
 	return default_
 }
 
 func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool {
-	var _t1325 interface{}
+	var _t1353 interface{}
 	if (value != nil && hasProtoField(value, "boolean_value")) {
 		return value.GetBooleanValue()
 	}
-	_ = _t1325
+	_ = _t1353
 	return default_
 }
 
 func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string {
-	var _t1326 interface{}
+	var _t1354 interface{}
 	if (value != nil && hasProtoField(value, "string_value")) {
 		return []string{value.GetStringValue()}
 	}
-	_ = _t1326
+	_ = _t1354
 	return default_
 }
 
 func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 {
-	var _t1327 interface{}
+	var _t1355 interface{}
 	if (value != nil && hasProtoField(value, "int_value")) {
 		return ptr(value.GetIntValue())
 	}
-	_ = _t1327
+	_ = _t1355
 	return nil
 }
 
 func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 {
-	var _t1328 interface{}
+	var _t1356 interface{}
 	if (value != nil && hasProtoField(value, "float_value")) {
 		return ptr(value.GetFloatValue())
 	}
-	_ = _t1328
+	_ = _t1356
 	return nil
 }
 
 func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte {
-	var _t1329 interface{}
+	var _t1357 interface{}
 	if (value != nil && hasProtoField(value, "string_value")) {
 		return []byte(value.GetStringValue())
 	}
-	_ = _t1329
+	_ = _t1357
 	return nil
 }
 
 func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value {
-	var _t1330 interface{}
+	var _t1358 interface{}
 	if (value != nil && hasProtoField(value, "uint128_value")) {
 		return value.GetUint128Value()
 	}
-	_ = _t1330
+	_ = _t1358
 	return nil
 }
 
 func (p *Parser) construct_csv_config(config_dict [][]interface{}) *pb.CSVConfig {
 	config := dictFromList(config_dict)
-	_t1331 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1)
-	header_row := _t1331
-	_t1332 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0)
-	skip := _t1332
-	_t1333 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "")
-	new_line := _t1333
-	_t1334 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",")
-	delimiter := _t1334
-	_t1335 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"")
-	quotechar := _t1335
-	_t1336 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"")
-	escapechar := _t1336
-	_t1337 := p._extract_value_string(dictGetValue(config, "csv_comment"), "")
-	comment := _t1337
-	_t1338 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{})
-	missing_strings := _t1338
-	_t1339 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".")
-	decimal_separator := _t1339
-	_t1340 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8")
-	encoding := _t1340
-	_t1341 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto")
-	compression := _t1341
-	_t1342 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression}
-	return _t1342
+	_t1359 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1)
+	header_row := _t1359
+	_t1360 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0)
+	skip := _t1360
+	_t1361 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "")
+	new_line := _t1361
+	_t1362 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",")
+	delimiter := _t1362
+	_t1363 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"")
+	quotechar := _t1363
+	_t1364 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"")
+	escapechar := _t1364
+	_t1365 := p._extract_value_string(dictGetValue(config, "csv_comment"), "")
+	comment := _t1365
+	_t1366 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{})
+	missing_strings := _t1366
+	_t1367 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".")
+	decimal_separator := _t1367
+	_t1368 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8")
+	encoding := _t1368
+	_t1369 := p._extract_value_string(dictGetValue(config, "csv_compression"), "auto")
+	compression := _t1369
+	_t1370 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression}
+	return _t1370
 }
 
 func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo {
 	config := dictFromList(config_dict)
-	_t1343 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon"))
-	epsilon := _t1343
-	_t1344 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots"))
-	max_pivots := _t1344
-	_t1345 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas"))
-	max_deltas := _t1345
-	_t1346 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf"))
-	max_leaf := _t1346
-	_t1347 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)}
-	storage_config := _t1347
-	_t1348 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid"))
-	root_pageid := _t1348
-	_t1349 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data"))
-	inline_data := _t1349
-	_t1350 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count"))
-	element_count := _t1350
-	_t1351 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height"))
-	tree_height := _t1351
-	_t1352 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)}
+	_t1371 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon"))
+	epsilon := _t1371
+	_t1372 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots"))
+	max_pivots := _t1372
+	_t1373 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas"))
+	max_deltas := _t1373
+	_t1374 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf"))
+	max_leaf := _t1374
+	_t1375 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)}
+	storage_config := _t1375
+	_t1376 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid"))
+	root_pageid := _t1376
+	_t1377 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data"))
+	inline_data := _t1377
+	_t1378 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count"))
+	element_count := _t1378
+	_t1379 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height"))
+	tree_height := _t1379
+	_t1380 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)}
 	if root_pageid != nil {
-		_t1352.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid}
+		_t1380.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid}
 	} else {
-		_t1352.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data}
+		_t1380.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data}
 	}
-	relation_locator := _t1352
-	_t1353 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator}
-	return _t1353
+	relation_locator := _t1380
+	_t1381 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator}
+	return _t1381
 }
 
 func (p *Parser) default_configure() *pb.Configure {
-	_t1354 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF}
-	ivm_config := _t1354
-	_t1355 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config}
-	return _t1355
+	_t1382 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF}
+	ivm_config := _t1382
+	_t1383 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config}
+	return _t1383
 }
 
 func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure {
@@ -689,32 +689,32 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure
 			}
 		}
 	}
-	_t1356 := &pb.IVMConfig{Level: maintenance_level}
-	ivm_config := _t1356
-	_t1357 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0)
-	semantics_version := _t1357
-	_t1358 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config}
-	return _t1358
+	_t1384 := &pb.IVMConfig{Level: maintenance_level}
+	ivm_config := _t1384
+	_t1385 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0)
+	semantics_version := _t1385
+	_t1386 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config}
+	return _t1386
 }
 
 func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig {
 	config := dictFromList(config_dict)
-	_t1359 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0)
-	partition_size := _t1359
-	_t1360 := p._extract_value_string(dictGetValue(config, "compression"), "")
-	compression := _t1360
-	_t1361 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true)
-	syntax_header_row := _t1361
-	_t1362 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "")
-	syntax_missing_string := _t1362
-	_t1363 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",")
-	syntax_delim := _t1363
-	_t1364 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"")
-	syntax_quotechar := _t1364
-	_t1365 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\")
-	syntax_escapechar := _t1365
-	_t1366 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)}
-	return _t1366
+	_t1387 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0)
+	partition_size := _t1387
+	_t1388 := p._extract_value_string(dictGetValue(config, "compression"), "")
+	compression := _t1388
+	_t1389 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true)
+	syntax_header_row := _t1389
+	_t1390 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "")
+	syntax_missing_string := _t1390
+	_t1391 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",")
+	syntax_delim := _t1391
+	_t1392 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"")
+	syntax_quotechar := _t1392
+	_t1393 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\")
+	syntax_escapechar := _t1393
+	_t1394 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)}
+	return _t1394
 }
 
 // --- Parse functions ---
@@ -722,3022 +722,3082 @@ func (p *Parser) export_csv_config(path string, columns []*pb.ExportCSVColumn, c
 func (p *Parser) parse_transaction() *pb.Transaction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("transaction")
-	var _t712 *pb.Configure
+	var _t732 *pb.Configure
 	if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) {
-		_t713 := p.parse_configure()
-		_t712 = _t713
+		_t733 := p.parse_configure()
+		_t732 = _t733
 	}
-	configure356 := _t712
-	var _t714 *pb.Sync
+	configure366 := _t732
+	var _t734 *pb.Sync
 	if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) {
-		_t715 := p.parse_sync()
-		_t714 = _t715
+		_t735 := p.parse_sync()
+		_t734 = _t735
 	}
-	sync357 := _t714
-	xs358 := []*pb.Epoch{}
-	cond359 := p.matchLookaheadLiteral("(", 0)
-	for cond359 {
-		_t716 := p.parse_epoch()
-		item360 := _t716
-		xs358 = append(xs358, item360)
-		cond359 = p.matchLookaheadLiteral("(", 0)
+	sync367 := _t734
+	xs368 := []*pb.Epoch{}
+	cond369 := p.matchLookaheadLiteral("(", 0)
+	for cond369 {
+		_t736 := p.parse_epoch()
+		item370 := _t736
+		xs368 = append(xs368, item370)
+		cond369 = p.matchLookaheadLiteral("(", 0)
 	}
-	epochs361 := xs358
+	epochs371 := xs368
 	p.consumeLiteral(")")
-	_t717 := p.default_configure()
-	_t718 := configure356
-	if configure356 == nil {
-		_t718 = _t717
+	_t737 := p.default_configure()
+	_t738 := configure366
+	if configure366 == nil {
+		_t738 = _t737
 	}
-	_t719 := &pb.Transaction{Epochs: epochs361, Configure: _t718, Sync: sync357}
-	return _t719
+	_t739 := &pb.Transaction{Epochs: epochs371, Configure: _t738, Sync: sync367}
+	return _t739
 }
 
 func (p *Parser) parse_configure() *pb.Configure {
 	p.consumeLiteral("(")
 	p.consumeLiteral("configure")
-	_t720 := p.parse_config_dict()
-	config_dict362 := _t720
+	_t740 := p.parse_config_dict()
+	config_dict372 := _t740
 	p.consumeLiteral(")")
-	_t721 := p.construct_configure(config_dict362)
-	return _t721
+	_t741 := p.construct_configure(config_dict372)
+	return _t741
 }
 
 func (p *Parser) parse_config_dict() [][]interface{} {
 	p.consumeLiteral("{")
-	xs363 := [][]interface{}{}
-	cond364 := p.matchLookaheadLiteral(":", 0)
-	for cond364 {
-		_t722 := p.parse_config_key_value()
-		item365 := _t722
-		xs363 = append(xs363, item365)
-		cond364 = p.matchLookaheadLiteral(":", 0)
-	}
-	config_key_values366 := xs363
+	xs373 := [][]interface{}{}
+	cond374 := p.matchLookaheadLiteral(":", 0)
+	for cond374 {
+		_t742 := p.parse_config_key_value()
+		item375 := _t742
+		xs373 = append(xs373, item375)
+		cond374 = p.matchLookaheadLiteral(":", 0)
+	}
+	config_key_values376 := xs373
 	p.consumeLiteral("}")
-	return config_key_values366
+	return config_key_values376
 }
 
 func (p *Parser) parse_config_key_value() []interface{} {
 	p.consumeLiteral(":")
-	symbol367 := p.consumeTerminal("SYMBOL").Value.str
-	_t723 := p.parse_value()
-	value368 := _t723
-	return []interface{}{symbol367, value368}
+	symbol377 := p.consumeTerminal("SYMBOL").Value.str
+	_t743 := p.parse_value()
+	value378 := _t743
+	return []interface{}{symbol377, value378}
 }
 
 func (p *Parser) parse_value() *pb.Value {
-	var _t724 int64
+	var _t744 int64
 	if p.matchLookaheadLiteral("true", 0) {
-		_t724 = 9
+		_t744 = 9
 	} else {
-		var _t725 int64
+		var _t745 int64
 		if p.matchLookaheadLiteral("missing", 0) {
-			_t725 = 8
+			_t745 = 8
 		} else {
-			var _t726 int64
+			var _t746 int64
 			if p.matchLookaheadLiteral("false", 0) {
-				_t726 = 9
+				_t746 = 9
 			} else {
-				var _t727 int64
+				var _t747 int64
 				if p.matchLookaheadLiteral("(", 0) {
-					var _t728 int64
+					var _t748 int64
 					if p.matchLookaheadLiteral("datetime", 1) {
-						_t728 = 1
+						_t748 = 1
 					} else {
-						var _t729 int64
+						var _t749 int64
 						if p.matchLookaheadLiteral("date", 1) {
-							_t729 = 0
+							_t749 = 0
 						} else {
-							_t729 = -1
+							_t749 = -1
 						}
-						_t728 = _t729
+						_t748 = _t749
 					}
-					_t727 = _t728
+					_t747 = _t748
 				} else {
-					var _t730 int64
+					var _t750 int64
 					if p.matchLookaheadTerminal("UINT128", 0) {
-						_t730 = 5
+						_t750 = 5
 					} else {
-						var _t731 int64
+						var _t751 int64
 						if p.matchLookaheadTerminal("STRING", 0) {
-							_t731 = 2
+							_t751 = 2
 						} else {
-							var _t732 int64
+							var _t752 int64
 							if p.matchLookaheadTerminal("INT128", 0) {
-								_t732 = 6
+								_t752 = 6
 							} else {
-								var _t733 int64
+								var _t753 int64
 								if p.matchLookaheadTerminal("INT", 0) {
-									_t733 = 3
+									_t753 = 3
 								} else {
-									var _t734 int64
+									var _t754 int64
 									if p.matchLookaheadTerminal("FLOAT", 0) {
-										_t734 = 4
+										_t754 = 4
 									} else {
-										var _t735 int64
+										var _t755 int64
 										if p.matchLookaheadTerminal("DECIMAL", 0) {
-											_t735 = 7
+											_t755 = 7
 										} else {
-											_t735 = -1
+											_t755 = -1
 										}
-										_t734 = _t735
+										_t754 = _t755
 									}
-									_t733 = _t734
+									_t753 = _t754
 								}
-								_t732 = _t733
+								_t752 = _t753
 							}
-							_t731 = _t732
+							_t751 = _t752
 						}
-						_t730 = _t731
+						_t750 = _t751
 					}
-					_t727 = _t730
+					_t747 = _t750
 				}
-				_t726 = _t727
+				_t746 = _t747
 			}
-			_t725 = _t726
+			_t745 = _t746
 		}
-		_t724 = _t725
-	}
-	prediction369 := _t724
-	var _t736 *pb.Value
-	if prediction369 == 9 {
-		_t737 := p.parse_boolean_value()
-		boolean_value378 := _t737
-		_t738 := &pb.Value{}
-		_t738.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value378}
-		_t736 = _t738
+		_t744 = _t745
+	}
+	prediction379 := _t744
+	var _t756 *pb.Value
+	if prediction379 == 9 {
+		_t757 := p.parse_boolean_value()
+		boolean_value388 := _t757
+		_t758 := &pb.Value{}
+		_t758.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value388}
+		_t756 = _t758
 	} else {
-		var _t739 *pb.Value
-		if prediction369 == 8 {
+		var _t759 *pb.Value
+		if prediction379 == 8 {
 			p.consumeLiteral("missing")
-			_t740 := &pb.MissingValue{}
-			_t741 := &pb.Value{}
-			_t741.Value = &pb.Value_MissingValue{MissingValue: _t740}
-			_t739 = _t741
+			_t760 := &pb.MissingValue{}
+			_t761 := &pb.Value{}
+			_t761.Value = &pb.Value_MissingValue{MissingValue: _t760}
+			_t759 = _t761
 		} else {
-			var _t742 *pb.Value
-			if prediction369 == 7 {
-				decimal377 := p.consumeTerminal("DECIMAL").Value.decimal
-				_t743 := &pb.Value{}
-				_t743.Value = &pb.Value_DecimalValue{DecimalValue: decimal377}
-				_t742 = _t743
+			var _t762 *pb.Value
+			if prediction379 == 7 {
+				decimal387 := p.consumeTerminal("DECIMAL").Value.decimal
+				_t763 := &pb.Value{}
+				_t763.Value = &pb.Value_DecimalValue{DecimalValue: decimal387}
+				_t762 = _t763
 			} else {
-				var _t744 *pb.Value
-				if prediction369 == 6 {
-					int128376 := p.consumeTerminal("INT128").Value.int128
-					_t745 := &pb.Value{}
-					_t745.Value = &pb.Value_Int128Value{Int128Value: int128376}
-					_t744 = _t745
+				var _t764 *pb.Value
+				if prediction379 == 6 {
+					int128386 := p.consumeTerminal("INT128").Value.int128
+					_t765 := &pb.Value{}
+					_t765.Value = &pb.Value_Int128Value{Int128Value: int128386}
+					_t764 = _t765
 				} else {
-					var _t746 *pb.Value
-					if prediction369 == 5 {
-						uint128375 := p.consumeTerminal("UINT128").Value.uint128
-						_t747 := &pb.Value{}
-						_t747.Value = &pb.Value_Uint128Value{Uint128Value: uint128375}
-						_t746 = _t747
+					var _t766 *pb.Value
+					if prediction379 == 5 {
+						uint128385 := p.consumeTerminal("UINT128").Value.uint128
+						_t767 := &pb.Value{}
+						_t767.Value = &pb.Value_Uint128Value{Uint128Value: uint128385}
+						_t766 = _t767
 					} else {
-						var _t748 *pb.Value
-						if prediction369 == 4 {
-							float374 := p.consumeTerminal("FLOAT").Value.f64
-							_t749 := &pb.Value{}
-							_t749.Value = &pb.Value_FloatValue{FloatValue: float374}
-							_t748 = _t749
+						var _t768 *pb.Value
+						if prediction379 == 4 {
+							float384 := p.consumeTerminal("FLOAT").Value.f64
+							_t769 := &pb.Value{}
+							_t769.Value = &pb.Value_FloatValue{FloatValue: float384}
+							_t768 = _t769
 						} else {
-							var _t750 *pb.Value
-							if prediction369 == 3 {
-								int373 := p.consumeTerminal("INT").Value.i64
-								_t751 := &pb.Value{}
-								_t751.Value = &pb.Value_IntValue{IntValue: int373}
-								_t750 = _t751
+							var _t770 *pb.Value
+							if prediction379 == 3 {
+								int383 := p.consumeTerminal("INT").Value.i64
+								_t771 := &pb.Value{}
+								_t771.Value = &pb.Value_IntValue{IntValue: int383}
+								_t770 = _t771
 							} else {
-								var _t752 *pb.Value
-								if prediction369 == 2 {
-									string372 := p.consumeTerminal("STRING").Value.str
-									_t753 := &pb.Value{}
-									_t753.Value = &pb.Value_StringValue{StringValue: string372}
-									_t752 = _t753
+								var _t772 *pb.Value
+								if prediction379 == 2 {
+									string382 := p.consumeTerminal("STRING").Value.str
+									_t773 := &pb.Value{}
+									_t773.Value = &pb.Value_StringValue{StringValue: string382}
+									_t772 = _t773
 								} else {
-									var _t754 *pb.Value
-									if prediction369 == 1 {
-										_t755 := p.parse_datetime()
-										datetime371 := _t755
-										_t756 := &pb.Value{}
-										_t756.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime371}
-										_t754 = _t756
+									var _t774 *pb.Value
+									if prediction379 == 1 {
+										_t775 := p.parse_datetime()
+										datetime381 := _t775
+										_t776 := &pb.Value{}
+										_t776.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime381}
+										_t774 = _t776
 									} else {
-										var _t757 *pb.Value
-										if prediction369 == 0 {
-											_t758 := p.parse_date()
-											date370 := _t758
-											_t759 := &pb.Value{}
-											_t759.Value = &pb.Value_DateValue{DateValue: date370}
-											_t757 = _t759
+										var _t777 *pb.Value
+										if prediction379 == 0 {
+											_t778 := p.parse_date()
+											date380 := _t778
+											_t779 := &pb.Value{}
+											_t779.Value = &pb.Value_DateValue{DateValue: date380}
+											_t777 = _t779
 										} else {
 											panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)})
 										}
-										_t754 = _t757
+										_t774 = _t777
 									}
-									_t752 = _t754
+									_t772 = _t774
 								}
-								_t750 = _t752
+								_t770 = _t772
 							}
-							_t748 = _t750
+							_t768 = _t770
 						}
-						_t746 = _t748
+						_t766 = _t768
 					}
-					_t744 = _t746
+					_t764 = _t766
 				}
-				_t742 = _t744
+				_t762 = _t764
 			}
-			_t739 = _t742
+			_t759 = _t762
 		}
-		_t736 = _t739
+		_t756 = _t759
 	}
-	return _t736
+	return _t756
 }
 
 func (p *Parser) parse_date() *pb.DateValue {
 	p.consumeLiteral("(")
 	p.consumeLiteral("date")
-	int379 := p.consumeTerminal("INT").Value.i64
-	int_3380 := p.consumeTerminal("INT").Value.i64
-	int_4381 := p.consumeTerminal("INT").Value.i64
+	int389 := p.consumeTerminal("INT").Value.i64
+	int_3390 := p.consumeTerminal("INT").Value.i64
+	int_4391 := p.consumeTerminal("INT").Value.i64
 	p.consumeLiteral(")")
-	_t760 := &pb.DateValue{Year: int32(int379), Month: int32(int_3380), Day: int32(int_4381)}
-	return _t760
+	_t780 := &pb.DateValue{Year: int32(int389), Month: int32(int_3390), Day: int32(int_4391)}
+	return _t780
 }
 
 func (p *Parser) parse_datetime() *pb.DateTimeValue {
 	p.consumeLiteral("(")
 	p.consumeLiteral("datetime")
-	int382 := p.consumeTerminal("INT").Value.i64
-	int_3383 := p.consumeTerminal("INT").Value.i64
-	int_4384 := p.consumeTerminal("INT").Value.i64
-	int_5385 := p.consumeTerminal("INT").Value.i64
-	int_6386 := p.consumeTerminal("INT").Value.i64
-	int_7387 := p.consumeTerminal("INT").Value.i64
-	var _t761 *int64
+	int392 := p.consumeTerminal("INT").Value.i64
+	int_3393 := p.consumeTerminal("INT").Value.i64
+	int_4394 := p.consumeTerminal("INT").Value.i64
+	int_5395 := p.consumeTerminal("INT").Value.i64
+	int_6396 := p.consumeTerminal("INT").Value.i64
+	int_7397 := p.consumeTerminal("INT").Value.i64
+	var _t781 *int64
 	if p.matchLookaheadTerminal("INT", 0) {
-		_t761 = ptr(p.consumeTerminal("INT").Value.i64)
+		_t781 = ptr(p.consumeTerminal("INT").Value.i64)
 	}
-	int_8388 := _t761
+	int_8398 := _t781
 	p.consumeLiteral(")")
-	_t762 := &pb.DateTimeValue{Year: int32(int382), Month: int32(int_3383), Day: int32(int_4384), Hour: int32(int_5385), Minute: int32(int_6386), Second: int32(int_7387), Microsecond: int32(deref(int_8388, 0))}
-	return _t762
+	_t782 := &pb.DateTimeValue{Year: int32(int392), Month: int32(int_3393), Day: int32(int_4394), Hour: int32(int_5395), Minute: int32(int_6396), Second: int32(int_7397), Microsecond: int32(deref(int_8398, 0))}
+	return _t782
 }
 
 func (p *Parser) parse_boolean_value() bool {
-	var _t763 int64
+	var _t783 int64
 	if p.matchLookaheadLiteral("true", 0) {
-		_t763 = 0
+		_t783 = 0
 	} else {
-		var _t764 int64
+		var _t784 int64
 		if p.matchLookaheadLiteral("false", 0) {
-			_t764 = 1
+			_t784 = 1
 		} else {
-			_t764 = -1
+			_t784 = -1
 		}
-		_t763 = _t764
+		_t783 = _t784
 	}
-	prediction389 := _t763
-	var _t765 bool
-	if prediction389 == 1 {
+	prediction399 := _t783
+	var _t785 bool
+	if prediction399 == 1 {
 		p.consumeLiteral("false")
-		_t765 = false
+		_t785 = false
 	} else {
-		var _t766 bool
-		if prediction389 == 0 {
+		var _t786 bool
+		if prediction399 == 0 {
 			p.consumeLiteral("true")
-			_t766 = true
+			_t786 = true
 		} else {
 			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)})
 		}
-		_t765 = _t766
+		_t785 = _t786
 	}
-	return _t765
+	return _t785
 }
 
 func (p *Parser) parse_sync() *pb.Sync {
 	p.consumeLiteral("(")
 	p.consumeLiteral("sync")
-	xs390 := []*pb.FragmentId{}
-	cond391 := p.matchLookaheadLiteral(":", 0)
-	for cond391 {
-		_t767 := p.parse_fragment_id()
-		item392 := _t767
-		xs390 = append(xs390, item392)
-		cond391 = p.matchLookaheadLiteral(":", 0)
+	xs400 := []*pb.FragmentId{}
+	cond401 := p.matchLookaheadLiteral(":", 0)
+	for cond401 {
+		_t787 := p.parse_fragment_id()
+		item402 := _t787
+		xs400 = append(xs400, item402)
+		cond401 = p.matchLookaheadLiteral(":", 0)
 	}
-	fragment_ids393 := xs390
+	fragment_ids403 := xs400
 	p.consumeLiteral(")")
-	_t768 := &pb.Sync{Fragments: fragment_ids393}
-	return _t768
+	_t788 := &pb.Sync{Fragments: fragment_ids403}
+	return _t788
 }
 
 func (p *Parser) parse_fragment_id() *pb.FragmentId {
 	p.consumeLiteral(":")
-	symbol394 := p.consumeTerminal("SYMBOL").Value.str
-	return &pb.FragmentId{Id: []byte(symbol394)}
+	symbol404 := p.consumeTerminal("SYMBOL").Value.str
+	return &pb.FragmentId{Id: []byte(symbol404)}
 }
 
 func (p *Parser) parse_epoch() *pb.Epoch {
 	p.consumeLiteral("(")
 	p.consumeLiteral("epoch")
-	var _t769 []*pb.Write
+	var _t789 []*pb.Write
 	if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) {
-		_t770 := p.parse_epoch_writes()
-		_t769 = _t770
+		_t790 := p.parse_epoch_writes()
+		_t789 = _t790
 	}
-	epoch_writes395 := _t769
-	var _t771 []*pb.Read
+	epoch_writes405 := _t789
+	var _t791 []*pb.Read
 	if p.matchLookaheadLiteral("(", 0) {
-		_t772 := p.parse_epoch_reads()
-		_t771 = _t772
+		_t792 := p.parse_epoch_reads()
+		_t791 = _t792
 	}
-	epoch_reads396 := _t771
+	epoch_reads406 := _t791
 	p.consumeLiteral(")")
-	_t773 := epoch_writes395
-	if epoch_writes395 == nil {
-		_t773 = []*pb.Write{}
+	_t793 := epoch_writes405
+	if epoch_writes405 == nil {
+		_t793 = []*pb.Write{}
 	}
-	_t774 := epoch_reads396
-	if epoch_reads396 == nil {
-		_t774 = []*pb.Read{}
+	_t794 := epoch_reads406
+	if epoch_reads406 == nil {
+		_t794 = []*pb.Read{}
 	}
-	_t775 := &pb.Epoch{Writes: _t773, Reads: _t774}
-	return _t775
+	_t795 := &pb.Epoch{Writes: _t793, Reads: _t794}
+	return _t795
 }
 
 func (p *Parser) parse_epoch_writes() []*pb.Write {
 	p.consumeLiteral("(")
 	p.consumeLiteral("writes")
-	xs397 := []*pb.Write{}
-	cond398 := p.matchLookaheadLiteral("(", 0)
-	for cond398 {
-		_t776 := p.parse_write()
-		item399 := _t776
-		xs397 = append(xs397, item399)
-		cond398 = p.matchLookaheadLiteral("(", 0)
+	xs407 := []*pb.Write{}
+	cond408 := p.matchLookaheadLiteral("(", 0)
+	for cond408 {
+		_t796 := p.parse_write()
+		item409 := _t796
+		xs407 = append(xs407, item409)
+		cond408 = p.matchLookaheadLiteral("(", 0)
 	}
-	writes400 := xs397
+	writes410 := xs407
 	p.consumeLiteral(")")
-	return writes400
+	return writes410
 }
 
 func (p *Parser) parse_write() *pb.Write {
-	var _t777 int64
+	var _t797 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t778 int64
+		var _t798 int64
 		if p.matchLookaheadLiteral("undefine", 1) {
-			_t778 = 1
+			_t798 = 1
 		} else {
-			var _t779 int64
+			var _t799 int64
 			if p.matchLookaheadLiteral("snapshot", 1) {
-				_t779 = 3
+				_t799 = 3
 			} else {
-				var _t780 int64
+				var _t800 int64
 				if p.matchLookaheadLiteral("define", 1) {
-					_t780 = 0
+					_t800 = 0
 				} else {
-					var _t781 int64
+					var _t801 int64
 					if p.matchLookaheadLiteral("context", 1) {
-						_t781 = 2
+						_t801 = 2
 					} else {
-						_t781 = -1
+						_t801 = -1
 					}
-					_t780 = _t781
+					_t800 = _t801
 				}
-				_t779 = _t780
+				_t799 = _t800
 			}
-			_t778 = _t779
+			_t798 = _t799
 		}
-		_t777 = _t778
+		_t797 = _t798
 	} else {
-		_t777 = -1
-	}
-	prediction401 := _t777
-	var _t782 *pb.Write
-	if prediction401 == 3 {
-		_t783 := p.parse_snapshot()
-		snapshot405 := _t783
-		_t784 := &pb.Write{}
-		_t784.WriteType = &pb.Write_Snapshot{Snapshot: snapshot405}
-		_t782 = _t784
+		_t797 = -1
+	}
+	prediction411 := _t797
+	var _t802 *pb.Write
+	if prediction411 == 3 {
+		_t803 := p.parse_snapshot()
+		snapshot415 := _t803
+		_t804 := &pb.Write{}
+		_t804.WriteType = &pb.Write_Snapshot{Snapshot: snapshot415}
+		_t802 = _t804
 	} else {
-		var _t785 *pb.Write
-		if prediction401 == 2 {
-			_t786 := p.parse_context()
-			context404 := _t786
-			_t787 := &pb.Write{}
-			_t787.WriteType = &pb.Write_Context{Context: context404}
-			_t785 = _t787
+		var _t805 *pb.Write
+		if prediction411 == 2 {
+			_t806 := p.parse_context()
+			context414 := _t806
+			_t807 := &pb.Write{}
+			_t807.WriteType = &pb.Write_Context{Context: context414}
+			_t805 = _t807
 		} else {
-			var _t788 *pb.Write
-			if prediction401 == 1 {
-				_t789 := p.parse_undefine()
-				undefine403 := _t789
-				_t790 := &pb.Write{}
-				_t790.WriteType = &pb.Write_Undefine{Undefine: undefine403}
-				_t788 = _t790
+			var _t808 *pb.Write
+			if prediction411 == 1 {
+				_t809 := p.parse_undefine()
+				undefine413 := _t809
+				_t810 := &pb.Write{}
+				_t810.WriteType = &pb.Write_Undefine{Undefine: undefine413}
+				_t808 = _t810
 			} else {
-				var _t791 *pb.Write
-				if prediction401 == 0 {
-					_t792 := p.parse_define()
-					define402 := _t792
-					_t793 := &pb.Write{}
-					_t793.WriteType = &pb.Write_Define{Define: define402}
-					_t791 = _t793
+				var _t811 *pb.Write
+				if prediction411 == 0 {
+					_t812 := p.parse_define()
+					define412 := _t812
+					_t813 := &pb.Write{}
+					_t813.WriteType = &pb.Write_Define{Define: define412}
+					_t811 = _t813
 				} else {
 					panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)})
 				}
-				_t788 = _t791
+				_t808 = _t811
 			}
-			_t785 = _t788
+			_t805 = _t808
 		}
-		_t782 = _t785
+		_t802 = _t805
 	}
-	return _t782
+	return _t802
 }
 
 func (p *Parser) parse_define() *pb.Define {
 	p.consumeLiteral("(")
 	p.consumeLiteral("define")
-	_t794 := p.parse_fragment()
-	fragment406 := _t794
+	_t814 := p.parse_fragment()
+	fragment416 := _t814
 	p.consumeLiteral(")")
-	_t795 := &pb.Define{Fragment: fragment406}
-	return _t795
+	_t815 := &pb.Define{Fragment: fragment416}
+	return _t815
 }
 
 func (p *Parser) parse_fragment() *pb.Fragment {
 	p.consumeLiteral("(")
 	p.consumeLiteral("fragment")
-	_t796 := p.parse_new_fragment_id()
-	new_fragment_id407 := _t796
-	xs408 := []*pb.Declaration{}
-	cond409 := p.matchLookaheadLiteral("(", 0)
-	for cond409 {
-		_t797 := p.parse_declaration()
-		item410 := _t797
-		xs408 = append(xs408, item410)
-		cond409 = p.matchLookaheadLiteral("(", 0)
+	_t816 := p.parse_new_fragment_id()
+	new_fragment_id417 := _t816
+	xs418 := []*pb.Declaration{}
+	cond419 := p.matchLookaheadLiteral("(", 0)
+	for cond419 {
+		_t817 := p.parse_declaration()
+		item420 := _t817
+		xs418 = append(xs418, item420)
+		cond419 = p.matchLookaheadLiteral("(", 0)
 	}
-	declarations411 := xs408
+	declarations421 := xs418
 	p.consumeLiteral(")")
-	return p.constructFragment(new_fragment_id407, declarations411)
+	return p.constructFragment(new_fragment_id417, declarations421)
 }
 
 func (p *Parser) parse_new_fragment_id() *pb.FragmentId {
-	_t798 := p.parse_fragment_id()
-	fragment_id412 := _t798
-	p.startFragment(fragment_id412)
-	return fragment_id412
+	_t818 := p.parse_fragment_id()
+	fragment_id422 := _t818
+	p.startFragment(fragment_id422)
+	return fragment_id422
 }
 
 func (p *Parser) parse_declaration() *pb.Declaration {
-	var _t799 int64
+	var _t819 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t800 int64
-		if p.matchLookaheadLiteral("rel_edb", 1) {
-			_t800 = 3
+		var _t820 int64
+		if p.matchLookaheadLiteral("functional_dependency", 1) {
+			_t820 = 2
 		} else {
-			var _t801 int64
-			if p.matchLookaheadLiteral("functional_dependency", 1) {
-				_t801 = 2
+			var _t821 int64
+			if p.matchLookaheadLiteral("edb", 1) {
+				_t821 = 3
 			} else {
-				var _t802 int64
+				var _t822 int64
 				if p.matchLookaheadLiteral("def", 1) {
-					_t802 = 0
+					_t822 = 0
 				} else {
-					var _t803 int64
+					var _t823 int64
 					if p.matchLookaheadLiteral("csv_data", 1) {
-						_t803 = 3
+						_t823 = 3
 					} else {
-						var _t804 int64
+						var _t824 int64
 						if p.matchLookaheadLiteral("betree_relation", 1) {
-							_t804 = 3
+							_t824 = 3
 						} else {
-							var _t805 int64
+							var _t825 int64
 							if p.matchLookaheadLiteral("algorithm", 1) {
-								_t805 = 1
+								_t825 = 1
 							} else {
-								_t805 = -1
+								_t825 = -1
 							}
-							_t804 = _t805
+							_t824 = _t825
 						}
-						_t803 = _t804
+						_t823 = _t824
 					}
-					_t802 = _t803
+					_t822 = _t823
 				}
-				_t801 = _t802
+				_t821 = _t822
 			}
-			_t800 = _t801
+			_t820 = _t821
 		}
-		_t799 = _t800
+		_t819 = _t820
 	} else {
-		_t799 = -1
-	}
-	prediction413 := _t799
-	var _t806 *pb.Declaration
-	if prediction413 == 3 {
-		_t807 := p.parse_data()
-		data417 := _t807
-		_t808 := &pb.Declaration{}
-		_t808.DeclarationType = &pb.Declaration_Data{Data: data417}
-		_t806 = _t808
+		_t819 = -1
+	}
+	prediction423 := _t819
+	var _t826 *pb.Declaration
+	if prediction423 == 3 {
+		_t827 := p.parse_data()
+		data427 := _t827
+		_t828 := &pb.Declaration{}
+		_t828.DeclarationType = &pb.Declaration_Data{Data: data427}
+		_t826 = _t828
 	} else {
-		var _t809 *pb.Declaration
-		if prediction413 == 2 {
-			_t810 := p.parse_constraint()
-			constraint416 := _t810
-			_t811 := &pb.Declaration{}
-			_t811.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint416}
-			_t809 = _t811
+		var _t829 *pb.Declaration
+		if prediction423 == 2 {
+			_t830 := p.parse_constraint()
+			constraint426 := _t830
+			_t831 := &pb.Declaration{}
+			_t831.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint426}
+			_t829 = _t831
 		} else {
-			var _t812 *pb.Declaration
-			if prediction413 == 1 {
-				_t813 := p.parse_algorithm()
-				algorithm415 := _t813
-				_t814 := &pb.Declaration{}
-				_t814.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm415}
-				_t812 = _t814
+			var _t832 *pb.Declaration
+			if prediction423 == 1 {
+				_t833 := p.parse_algorithm()
+				algorithm425 := _t833
+				_t834 := &pb.Declaration{}
+				_t834.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm425}
+				_t832 = _t834
 			} else {
-				var _t815 *pb.Declaration
-				if prediction413 == 0 {
-					_t816 := p.parse_def()
-					def414 := _t816
-					_t817 := &pb.Declaration{}
-					_t817.DeclarationType = &pb.Declaration_Def{Def: def414}
-					_t815 = _t817
+				var _t835 *pb.Declaration
+				if prediction423 == 0 {
+					_t836 := p.parse_def()
+					def424 := _t836
+					_t837 := &pb.Declaration{}
+					_t837.DeclarationType = &pb.Declaration_Def{Def: def424}
+					_t835 = _t837
 				} else {
 					panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)})
 				}
-				_t812 = _t815
+				_t832 = _t835
 			}
-			_t809 = _t812
+			_t829 = _t832
 		}
-		_t806 = _t809
+		_t826 = _t829
 	}
-	return _t806
+	return _t826
 }
 
 func (p *Parser) parse_def() *pb.Def {
 	p.consumeLiteral("(")
 	p.consumeLiteral("def")
-	_t818 := p.parse_relation_id()
-	relation_id418 := _t818
-	_t819 := p.parse_abstraction()
-	abstraction419 := _t819
-	var _t820 []*pb.Attribute
+	_t838 := p.parse_relation_id()
+	relation_id428 := _t838
+	_t839 := p.parse_abstraction()
+	abstraction429 := _t839
+	var _t840 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t821 := p.parse_attrs()
-		_t820 = _t821
+		_t841 := p.parse_attrs()
+		_t840 = _t841
 	}
-	attrs420 := _t820
+	attrs430 := _t840
 	p.consumeLiteral(")")
-	_t822 := attrs420
-	if attrs420 == nil {
-		_t822 = []*pb.Attribute{}
+	_t842 := attrs430
+	if attrs430 == nil {
+		_t842 = []*pb.Attribute{}
 	}
-	_t823 := &pb.Def{Name: relation_id418, Body: abstraction419, Attrs: _t822}
-	return _t823
+	_t843 := &pb.Def{Name: relation_id428, Body: abstraction429, Attrs: _t842}
+	return _t843
 }
 
 func (p *Parser) parse_relation_id() *pb.RelationId {
-	var _t824 int64
+	var _t844 int64
 	if p.matchLookaheadLiteral(":", 0) {
-		_t824 = 0
+		_t844 = 0
 	} else {
-		var _t825 int64
+		var _t845 int64
 		if p.matchLookaheadTerminal("UINT128", 0) {
-			_t825 = 1
+			_t845 = 1
 		} else {
-			_t825 = -1
+			_t845 = -1
 		}
-		_t824 = _t825
-	}
-	prediction421 := _t824
-	var _t826 *pb.RelationId
-	if prediction421 == 1 {
-		uint128423 := p.consumeTerminal("UINT128").Value.uint128
-		_ = uint128423
-		_t826 = &pb.RelationId{IdLow: uint128423.Low, IdHigh: uint128423.High}
+		_t844 = _t845
+	}
+	prediction431 := _t844
+	var _t846 *pb.RelationId
+	if prediction431 == 1 {
+		uint128433 := p.consumeTerminal("UINT128").Value.uint128
+		_ = uint128433
+		_t846 = &pb.RelationId{IdLow: uint128433.Low, IdHigh: uint128433.High}
 	} else {
-		var _t827 *pb.RelationId
-		if prediction421 == 0 {
+		var _t847 *pb.RelationId
+		if prediction431 == 0 {
 			p.consumeLiteral(":")
-			symbol422 := p.consumeTerminal("SYMBOL").Value.str
-			_t827 = p.relationIdFromString(symbol422)
+			symbol432 := p.consumeTerminal("SYMBOL").Value.str
+			_t847 = p.relationIdFromString(symbol432)
 		} else {
 			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)})
 		}
-		_t826 = _t827
+		_t846 = _t847
 	}
-	return _t826
+	return _t846
 }
 
 func (p *Parser) parse_abstraction() *pb.Abstraction {
 	p.consumeLiteral("(")
-	_t828 := p.parse_bindings()
-	bindings424 := _t828
-	_t829 := p.parse_formula()
-	formula425 := _t829
+	_t848 := p.parse_bindings()
+	bindings434 := _t848
+	_t849 := p.parse_formula()
+	formula435 := _t849
 	p.consumeLiteral(")")
-	_t830 := &pb.Abstraction{Vars: listConcat(bindings424[0].([]*pb.Binding), bindings424[1].([]*pb.Binding)), Value: formula425}
-	return _t830
+	_t850 := &pb.Abstraction{Vars: listConcat(bindings434[0].([]*pb.Binding), bindings434[1].([]*pb.Binding)), Value: formula435}
+	return _t850
 }
 
 func (p *Parser) parse_bindings() []interface{} {
 	p.consumeLiteral("[")
-	xs426 := []*pb.Binding{}
-	cond427 := p.matchLookaheadTerminal("SYMBOL", 0)
-	for cond427 {
-		_t831 := p.parse_binding()
-		item428 := _t831
-		xs426 = append(xs426, item428)
-		cond427 = p.matchLookaheadTerminal("SYMBOL", 0)
-	}
-	bindings429 := xs426
-	var _t832 []*pb.Binding
+	xs436 := []*pb.Binding{}
+	cond437 := p.matchLookaheadTerminal("SYMBOL", 0)
+	for cond437 {
+		_t851 := p.parse_binding()
+		item438 := _t851
+		xs436 = append(xs436, item438)
+		cond437 = p.matchLookaheadTerminal("SYMBOL", 0)
+	}
+	bindings439 := xs436
+	var _t852 []*pb.Binding
 	if p.matchLookaheadLiteral("|", 0) {
-		_t833 := p.parse_value_bindings()
-		_t832 = _t833
+		_t853 := p.parse_value_bindings()
+		_t852 = _t853
 	}
-	value_bindings430 := _t832
+	value_bindings440 := _t852
 	p.consumeLiteral("]")
-	_t834 := value_bindings430
-	if value_bindings430 == nil {
-		_t834 = []*pb.Binding{}
+	_t854 := value_bindings440
+	if value_bindings440 == nil {
+		_t854 = []*pb.Binding{}
 	}
-	return []interface{}{bindings429, _t834}
+	return []interface{}{bindings439, _t854}
 }
 
 func (p *Parser) parse_binding() *pb.Binding {
-	symbol431 := p.consumeTerminal("SYMBOL").Value.str
+	symbol441 := p.consumeTerminal("SYMBOL").Value.str
 	p.consumeLiteral("::")
-	_t835 := p.parse_type()
-	type432 := _t835
-	_t836 := &pb.Var{Name: symbol431}
-	_t837 := &pb.Binding{Var: _t836, Type: type432}
-	return _t837
+	_t855 := p.parse_type()
+	type442 := _t855
+	_t856 := &pb.Var{Name: symbol441}
+	_t857 := &pb.Binding{Var: _t856, Type: type442}
+	return _t857
 }
 
 func (p *Parser) parse_type() *pb.Type {
-	var _t838 int64
+	var _t858 int64
 	if p.matchLookaheadLiteral("UNKNOWN", 0) {
-		_t838 = 0
+		_t858 = 0
 	} else {
-		var _t839 int64
+		var _t859 int64
 		if p.matchLookaheadLiteral("UINT128", 0) {
-			_t839 = 4
+			_t859 = 4
 		} else {
-			var _t840 int64
+			var _t860 int64
 			if p.matchLookaheadLiteral("STRING", 0) {
-				_t840 = 1
+				_t860 = 1
 			} else {
-				var _t841 int64
+				var _t861 int64
 				if p.matchLookaheadLiteral("MISSING", 0) {
-					_t841 = 8
+					_t861 = 8
 				} else {
-					var _t842 int64
+					var _t862 int64
 					if p.matchLookaheadLiteral("INT128", 0) {
-						_t842 = 5
+						_t862 = 5
 					} else {
-						var _t843 int64
+						var _t863 int64
 						if p.matchLookaheadLiteral("INT", 0) {
-							_t843 = 2
+							_t863 = 2
 						} else {
-							var _t844 int64
+							var _t864 int64
 							if p.matchLookaheadLiteral("FLOAT", 0) {
-								_t844 = 3
+								_t864 = 3
 							} else {
-								var _t845 int64
+								var _t865 int64
 								if p.matchLookaheadLiteral("DATETIME", 0) {
-									_t845 = 7
+									_t865 = 7
 								} else {
-									var _t846 int64
+									var _t866 int64
 									if p.matchLookaheadLiteral("DATE", 0) {
-										_t846 = 6
+										_t866 = 6
 									} else {
-										var _t847 int64
+										var _t867 int64
 										if p.matchLookaheadLiteral("BOOLEAN", 0) {
-											_t847 = 10
+											_t867 = 10
 										} else {
-											var _t848 int64
+											var _t868 int64
 											if p.matchLookaheadLiteral("(", 0) {
-												_t848 = 9
+												_t868 = 9
 											} else {
-												_t848 = -1
+												_t868 = -1
 											}
-											_t847 = _t848
+											_t867 = _t868
 										}
-										_t846 = _t847
+										_t866 = _t867
 									}
-									_t845 = _t846
+									_t865 = _t866
 								}
-								_t844 = _t845
+								_t864 = _t865
 							}
-							_t843 = _t844
+							_t863 = _t864
 						}
-						_t842 = _t843
+						_t862 = _t863
 					}
-					_t841 = _t842
+					_t861 = _t862
 				}
-				_t840 = _t841
+				_t860 = _t861
 			}
-			_t839 = _t840
+			_t859 = _t860
 		}
-		_t838 = _t839
-	}
-	prediction433 := _t838
-	var _t849 *pb.Type
-	if prediction433 == 10 {
-		_t850 := p.parse_boolean_type()
-		boolean_type444 := _t850
-		_t851 := &pb.Type{}
-		_t851.Type = &pb.Type_BooleanType{BooleanType: boolean_type444}
-		_t849 = _t851
+		_t858 = _t859
+	}
+	prediction443 := _t858
+	var _t869 *pb.Type
+	if prediction443 == 10 {
+		_t870 := p.parse_boolean_type()
+		boolean_type454 := _t870
+		_t871 := &pb.Type{}
+		_t871.Type = &pb.Type_BooleanType{BooleanType: boolean_type454}
+		_t869 = _t871
 	} else {
-		var _t852 *pb.Type
-		if prediction433 == 9 {
-			_t853 := p.parse_decimal_type()
-			decimal_type443 := _t853
-			_t854 := &pb.Type{}
-			_t854.Type = &pb.Type_DecimalType{DecimalType: decimal_type443}
-			_t852 = _t854
+		var _t872 *pb.Type
+		if prediction443 == 9 {
+			_t873 := p.parse_decimal_type()
+			decimal_type453 := _t873
+			_t874 := &pb.Type{}
+			_t874.Type = &pb.Type_DecimalType{DecimalType: decimal_type453}
+			_t872 = _t874
 		} else {
-			var _t855 *pb.Type
-			if prediction433 == 8 {
-				_t856 := p.parse_missing_type()
-				missing_type442 := _t856
-				_t857 := &pb.Type{}
-				_t857.Type = &pb.Type_MissingType{MissingType: missing_type442}
-				_t855 = _t857
+			var _t875 *pb.Type
+			if prediction443 == 8 {
+				_t876 := p.parse_missing_type()
+				missing_type452 := _t876
+				_t877 := &pb.Type{}
+				_t877.Type = &pb.Type_MissingType{MissingType: missing_type452}
+				_t875 = _t877
 			} else {
-				var _t858 *pb.Type
-				if prediction433 == 7 {
-					_t859 := p.parse_datetime_type()
-					datetime_type441 := _t859
-					_t860 := &pb.Type{}
-					_t860.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type441}
-					_t858 = _t860
+				var _t878 *pb.Type
+				if prediction443 == 7 {
+					_t879 := p.parse_datetime_type()
+					datetime_type451 := _t879
+					_t880 := &pb.Type{}
+					_t880.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type451}
+					_t878 = _t880
 				} else {
-					var _t861 *pb.Type
-					if prediction433 == 6 {
-						_t862 := p.parse_date_type()
-						date_type440 := _t862
-						_t863 := &pb.Type{}
-						_t863.Type = &pb.Type_DateType{DateType: date_type440}
-						_t861 = _t863
+					var _t881 *pb.Type
+					if prediction443 == 6 {
+						_t882 := p.parse_date_type()
+						date_type450 := _t882
+						_t883 := &pb.Type{}
+						_t883.Type = &pb.Type_DateType{DateType: date_type450}
+						_t881 = _t883
 					} else {
-						var _t864 *pb.Type
-						if prediction433 == 5 {
-							_t865 := p.parse_int128_type()
-							int128_type439 := _t865
-							_t866 := &pb.Type{}
-							_t866.Type = &pb.Type_Int128Type{Int128Type: int128_type439}
-							_t864 = _t866
+						var _t884 *pb.Type
+						if prediction443 == 5 {
+							_t885 := p.parse_int128_type()
+							int128_type449 := _t885
+							_t886 := &pb.Type{}
+							_t886.Type = &pb.Type_Int128Type{Int128Type: int128_type449}
+							_t884 = _t886
 						} else {
-							var _t867 *pb.Type
-							if prediction433 == 4 {
-								_t868 := p.parse_uint128_type()
-								uint128_type438 := _t868
-								_t869 := &pb.Type{}
-								_t869.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type438}
-								_t867 = _t869
+							var _t887 *pb.Type
+							if prediction443 == 4 {
+								_t888 := p.parse_uint128_type()
+								uint128_type448 := _t888
+								_t889 := &pb.Type{}
+								_t889.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type448}
+								_t887 = _t889
 							} else {
-								var _t870 *pb.Type
-								if prediction433 == 3 {
-									_t871 := p.parse_float_type()
-									float_type437 := _t871
-									_t872 := &pb.Type{}
-									_t872.Type = &pb.Type_FloatType{FloatType: float_type437}
-									_t870 = _t872
+								var _t890 *pb.Type
+								if prediction443 == 3 {
+									_t891 := p.parse_float_type()
+									float_type447 := _t891
+									_t892 := &pb.Type{}
+									_t892.Type = &pb.Type_FloatType{FloatType: float_type447}
+									_t890 = _t892
 								} else {
-									var _t873 *pb.Type
-									if prediction433 == 2 {
-										_t874 := p.parse_int_type()
-										int_type436 := _t874
-										_t875 := &pb.Type{}
-										_t875.Type = &pb.Type_IntType{IntType: int_type436}
-										_t873 = _t875
+									var _t893 *pb.Type
+									if prediction443 == 2 {
+										_t894 := p.parse_int_type()
+										int_type446 := _t894
+										_t895 := &pb.Type{}
+										_t895.Type = &pb.Type_IntType{IntType: int_type446}
+										_t893 = _t895
 									} else {
-										var _t876 *pb.Type
-										if prediction433 == 1 {
-											_t877 := p.parse_string_type()
-											string_type435 := _t877
-											_t878 := &pb.Type{}
-											_t878.Type = &pb.Type_StringType{StringType: string_type435}
-											_t876 = _t878
+										var _t896 *pb.Type
+										if prediction443 == 1 {
+											_t897 := p.parse_string_type()
+											string_type445 := _t897
+											_t898 := &pb.Type{}
+											_t898.Type = &pb.Type_StringType{StringType: string_type445}
+											_t896 = _t898
 										} else {
-											var _t879 *pb.Type
-											if prediction433 == 0 {
-												_t880 := p.parse_unspecified_type()
-												unspecified_type434 := _t880
-												_t881 := &pb.Type{}
-												_t881.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type434}
-												_t879 = _t881
+											var _t899 *pb.Type
+											if prediction443 == 0 {
+												_t900 := p.parse_unspecified_type()
+												unspecified_type444 := _t900
+												_t901 := &pb.Type{}
+												_t901.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type444}
+												_t899 = _t901
 											} else {
 												panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)})
 											}
-											_t876 = _t879
+											_t896 = _t899
 										}
-										_t873 = _t876
+										_t893 = _t896
 									}
-									_t870 = _t873
+									_t890 = _t893
 								}
-								_t867 = _t870
+								_t887 = _t890
 							}
-							_t864 = _t867
+							_t884 = _t887
 						}
-						_t861 = _t864
+						_t881 = _t884
 					}
-					_t858 = _t861
+					_t878 = _t881
 				}
-				_t855 = _t858
+				_t875 = _t878
 			}
-			_t852 = _t855
+			_t872 = _t875
 		}
-		_t849 = _t852
+		_t869 = _t872
 	}
-	return _t849
+	return _t869
 }
 
 func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType {
 	p.consumeLiteral("UNKNOWN")
-	_t882 := &pb.UnspecifiedType{}
-	return _t882
+	_t902 := &pb.UnspecifiedType{}
+	return _t902
 }
 
 func (p *Parser) parse_string_type() *pb.StringType {
 	p.consumeLiteral("STRING")
-	_t883 := &pb.StringType{}
-	return _t883
+	_t903 := &pb.StringType{}
+	return _t903
 }
 
 func (p *Parser) parse_int_type() *pb.IntType {
 	p.consumeLiteral("INT")
-	_t884 := &pb.IntType{}
-	return _t884
+	_t904 := &pb.IntType{}
+	return _t904
 }
 
 func (p *Parser) parse_float_type() *pb.FloatType {
 	p.consumeLiteral("FLOAT")
-	_t885 := &pb.FloatType{}
-	return _t885
+	_t905 := &pb.FloatType{}
+	return _t905
 }
 
 func (p *Parser) parse_uint128_type() *pb.UInt128Type {
 	p.consumeLiteral("UINT128")
-	_t886 := &pb.UInt128Type{}
-	return _t886
+	_t906 := &pb.UInt128Type{}
+	return _t906
 }
 
 func (p *Parser) parse_int128_type() *pb.Int128Type {
 	p.consumeLiteral("INT128")
-	_t887 := &pb.Int128Type{}
-	return _t887
+	_t907 := &pb.Int128Type{}
+	return _t907
 }
 
 func (p *Parser) parse_date_type() *pb.DateType {
 	p.consumeLiteral("DATE")
-	_t888 := &pb.DateType{}
-	return _t888
+	_t908 := &pb.DateType{}
+	return _t908
 }
 
 func (p *Parser) parse_datetime_type() *pb.DateTimeType {
 	p.consumeLiteral("DATETIME")
-	_t889 := &pb.DateTimeType{}
-	return _t889
+	_t909 := &pb.DateTimeType{}
+	return _t909
 }
 
 func (p *Parser) parse_missing_type() *pb.MissingType {
 	p.consumeLiteral("MISSING")
-	_t890 := &pb.MissingType{}
-	return _t890
+	_t910 := &pb.MissingType{}
+	return _t910
 }
 
 func (p *Parser) parse_decimal_type() *pb.DecimalType {
 	p.consumeLiteral("(")
 	p.consumeLiteral("DECIMAL")
-	int445 := p.consumeTerminal("INT").Value.i64
-	int_3446 := p.consumeTerminal("INT").Value.i64
+	int455 := p.consumeTerminal("INT").Value.i64
+	int_3456 := p.consumeTerminal("INT").Value.i64
 	p.consumeLiteral(")")
-	_t891 := &pb.DecimalType{Precision: int32(int445), Scale: int32(int_3446)}
-	return _t891
+	_t911 := &pb.DecimalType{Precision: int32(int455), Scale: int32(int_3456)}
+	return _t911
 }
 
 func (p *Parser) parse_boolean_type() *pb.BooleanType {
 	p.consumeLiteral("BOOLEAN")
-	_t892 := &pb.BooleanType{}
-	return _t892
+	_t912 := &pb.BooleanType{}
+	return _t912
 }
 
 func (p *Parser) parse_value_bindings() []*pb.Binding {
 	p.consumeLiteral("|")
-	xs447 := []*pb.Binding{}
-	cond448 := p.matchLookaheadTerminal("SYMBOL", 0)
-	for cond448 {
-		_t893 := p.parse_binding()
-		item449 := _t893
-		xs447 = append(xs447, item449)
-		cond448 = p.matchLookaheadTerminal("SYMBOL", 0)
+	xs457 := []*pb.Binding{}
+	cond458 := p.matchLookaheadTerminal("SYMBOL", 0)
+	for cond458 {
+		_t913 := p.parse_binding()
+		item459 := _t913
+		xs457 = append(xs457, item459)
+		cond458 = p.matchLookaheadTerminal("SYMBOL", 0)
 	}
-	bindings450 := xs447
-	return bindings450
+	bindings460 := xs457
+	return bindings460
 }
 
 func (p *Parser) parse_formula() *pb.Formula {
-	var _t894 int64
+	var _t914 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t895 int64
+		var _t915 int64
 		if p.matchLookaheadLiteral("true", 1) {
-			_t895 = 0
+			_t915 = 0
 		} else {
-			var _t896 int64
+			var _t916 int64
 			if p.matchLookaheadLiteral("relatom", 1) {
-				_t896 = 11
+				_t916 = 11
 			} else {
-				var _t897 int64
+				var _t917 int64
 				if p.matchLookaheadLiteral("reduce", 1) {
-					_t897 = 3
+					_t917 = 3
 				} else {
-					var _t898 int64
+					var _t918 int64
 					if p.matchLookaheadLiteral("primitive", 1) {
-						_t898 = 10
+						_t918 = 10
 					} else {
-						var _t899 int64
+						var _t919 int64
 						if p.matchLookaheadLiteral("pragma", 1) {
-							_t899 = 9
+							_t919 = 9
 						} else {
-							var _t900 int64
+							var _t920 int64
 							if p.matchLookaheadLiteral("or", 1) {
-								_t900 = 5
+								_t920 = 5
 							} else {
-								var _t901 int64
+								var _t921 int64
 								if p.matchLookaheadLiteral("not", 1) {
-									_t901 = 6
+									_t921 = 6
 								} else {
-									var _t902 int64
+									var _t922 int64
 									if p.matchLookaheadLiteral("ffi", 1) {
-										_t902 = 7
+										_t922 = 7
 									} else {
-										var _t903 int64
+										var _t923 int64
 										if p.matchLookaheadLiteral("false", 1) {
-											_t903 = 1
+											_t923 = 1
 										} else {
-											var _t904 int64
+											var _t924 int64
 											if p.matchLookaheadLiteral("exists", 1) {
-												_t904 = 2
+												_t924 = 2
 											} else {
-												var _t905 int64
+												var _t925 int64
 												if p.matchLookaheadLiteral("cast", 1) {
-													_t905 = 12
+													_t925 = 12
 												} else {
-													var _t906 int64
+													var _t926 int64
 													if p.matchLookaheadLiteral("atom", 1) {
-														_t906 = 8
+														_t926 = 8
 													} else {
-														var _t907 int64
+														var _t927 int64
 														if p.matchLookaheadLiteral("and", 1) {
-															_t907 = 4
+															_t927 = 4
 														} else {
-															var _t908 int64
+															var _t928 int64
 															if p.matchLookaheadLiteral(">=", 1) {
-																_t908 = 10
+																_t928 = 10
 															} else {
-																var _t909 int64
+																var _t929 int64
 																if p.matchLookaheadLiteral(">", 1) {
-																	_t909 = 10
+																	_t929 = 10
 																} else {
-																	var _t910 int64
+																	var _t930 int64
 																	if p.matchLookaheadLiteral("=", 1) {
-																		_t910 = 10
+																		_t930 = 10
 																	} else {
-																		var _t911 int64
+																		var _t931 int64
 																		if p.matchLookaheadLiteral("<=", 1) {
-																			_t911 = 10
+																			_t931 = 10
 																		} else {
-																			var _t912 int64
+																			var _t932 int64
 																			if p.matchLookaheadLiteral("<", 1) {
-																				_t912 = 10
+																				_t932 = 10
 																			} else {
-																				var _t913 int64
+																				var _t933 int64
 																				if p.matchLookaheadLiteral("/", 1) {
-																					_t913 = 10
+																					_t933 = 10
 																				} else {
-																					var _t914 int64
+																					var _t934 int64
 																					if p.matchLookaheadLiteral("-", 1) {
-																						_t914 = 10
+																						_t934 = 10
 																					} else {
-																						var _t915 int64
+																						var _t935 int64
 																						if p.matchLookaheadLiteral("+", 1) {
-																							_t915 = 10
+																							_t935 = 10
 																						} else {
-																							var _t916 int64
+																							var _t936 int64
 																							if p.matchLookaheadLiteral("*", 1) {
-																								_t916 = 10
+																								_t936 = 10
 																							} else {
-																								_t916 = -1
+																								_t936 = -1
 																							}
-																							_t915 = _t916
+																							_t935 = _t936
 																						}
-																						_t914 = _t915
+																						_t934 = _t935
 																					}
-																					_t913 = _t914
+																					_t933 = _t934
 																				}
-																				_t912 = _t913
+																				_t932 = _t933
 																			}
-																			_t911 = _t912
+																			_t931 = _t932
 																		}
-																		_t910 = _t911
+																		_t930 = _t931
 																	}
-																	_t909 = _t910
+																	_t929 = _t930
 																}
-																_t908 = _t909
+																_t928 = _t929
 															}
-															_t907 = _t908
+															_t927 = _t928
 														}
-														_t906 = _t907
+														_t926 = _t927
 													}
-													_t905 = _t906
+													_t925 = _t926
 												}
-												_t904 = _t905
+												_t924 = _t925
 											}
-											_t903 = _t904
+											_t923 = _t924
 										}
-										_t902 = _t903
+										_t922 = _t923
 									}
-									_t901 = _t902
+									_t921 = _t922
 								}
-								_t900 = _t901
+								_t920 = _t921
 							}
-							_t899 = _t900
+							_t919 = _t920
 						}
-						_t898 = _t899
+						_t918 = _t919
 					}
-					_t897 = _t898
+					_t917 = _t918
 				}
-				_t896 = _t897
+				_t916 = _t917
 			}
-			_t895 = _t896
+			_t915 = _t916
 		}
-		_t894 = _t895
+		_t914 = _t915
 	} else {
-		_t894 = -1
-	}
-	prediction451 := _t894
-	var _t917 *pb.Formula
-	if prediction451 == 12 {
-		_t918 := p.parse_cast()
-		cast464 := _t918
-		_t919 := &pb.Formula{}
-		_t919.FormulaType = &pb.Formula_Cast{Cast: cast464}
-		_t917 = _t919
+		_t914 = -1
+	}
+	prediction461 := _t914
+	var _t937 *pb.Formula
+	if prediction461 == 12 {
+		_t938 := p.parse_cast()
+		cast474 := _t938
+		_t939 := &pb.Formula{}
+		_t939.FormulaType = &pb.Formula_Cast{Cast: cast474}
+		_t937 = _t939
 	} else {
-		var _t920 *pb.Formula
-		if prediction451 == 11 {
-			_t921 := p.parse_rel_atom()
-			rel_atom463 := _t921
-			_t922 := &pb.Formula{}
-			_t922.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom463}
-			_t920 = _t922
+		var _t940 *pb.Formula
+		if prediction461 == 11 {
+			_t941 := p.parse_rel_atom()
+			rel_atom473 := _t941
+			_t942 := &pb.Formula{}
+			_t942.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom473}
+			_t940 = _t942
 		} else {
-			var _t923 *pb.Formula
-			if prediction451 == 10 {
-				_t924 := p.parse_primitive()
-				primitive462 := _t924
-				_t925 := &pb.Formula{}
-				_t925.FormulaType = &pb.Formula_Primitive{Primitive: primitive462}
-				_t923 = _t925
+			var _t943 *pb.Formula
+			if prediction461 == 10 {
+				_t944 := p.parse_primitive()
+				primitive472 := _t944
+				_t945 := &pb.Formula{}
+				_t945.FormulaType = &pb.Formula_Primitive{Primitive: primitive472}
+				_t943 = _t945
 			} else {
-				var _t926 *pb.Formula
-				if prediction451 == 9 {
-					_t927 := p.parse_pragma()
-					pragma461 := _t927
-					_t928 := &pb.Formula{}
-					_t928.FormulaType = &pb.Formula_Pragma{Pragma: pragma461}
-					_t926 = _t928
+				var _t946 *pb.Formula
+				if prediction461 == 9 {
+					_t947 := p.parse_pragma()
+					pragma471 := _t947
+					_t948 := &pb.Formula{}
+					_t948.FormulaType = &pb.Formula_Pragma{Pragma: pragma471}
+					_t946 = _t948
 				} else {
-					var _t929 *pb.Formula
-					if prediction451 == 8 {
-						_t930 := p.parse_atom()
-						atom460 := _t930
-						_t931 := &pb.Formula{}
-						_t931.FormulaType = &pb.Formula_Atom{Atom: atom460}
-						_t929 = _t931
+					var _t949 *pb.Formula
+					if prediction461 == 8 {
+						_t950 := p.parse_atom()
+						atom470 := _t950
+						_t951 := &pb.Formula{}
+						_t951.FormulaType = &pb.Formula_Atom{Atom: atom470}
+						_t949 = _t951
 					} else {
-						var _t932 *pb.Formula
-						if prediction451 == 7 {
-							_t933 := p.parse_ffi()
-							ffi459 := _t933
-							_t934 := &pb.Formula{}
-							_t934.FormulaType = &pb.Formula_Ffi{Ffi: ffi459}
-							_t932 = _t934
+						var _t952 *pb.Formula
+						if prediction461 == 7 {
+							_t953 := p.parse_ffi()
+							ffi469 := _t953
+							_t954 := &pb.Formula{}
+							_t954.FormulaType = &pb.Formula_Ffi{Ffi: ffi469}
+							_t952 = _t954
 						} else {
-							var _t935 *pb.Formula
-							if prediction451 == 6 {
-								_t936 := p.parse_not()
-								not458 := _t936
-								_t937 := &pb.Formula{}
-								_t937.FormulaType = &pb.Formula_Not{Not: not458}
-								_t935 = _t937
+							var _t955 *pb.Formula
+							if prediction461 == 6 {
+								_t956 := p.parse_not()
+								not468 := _t956
+								_t957 := &pb.Formula{}
+								_t957.FormulaType = &pb.Formula_Not{Not: not468}
+								_t955 = _t957
 							} else {
-								var _t938 *pb.Formula
-								if prediction451 == 5 {
-									_t939 := p.parse_disjunction()
-									disjunction457 := _t939
-									_t940 := &pb.Formula{}
-									_t940.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction457}
-									_t938 = _t940
+								var _t958 *pb.Formula
+								if prediction461 == 5 {
+									_t959 := p.parse_disjunction()
+									disjunction467 := _t959
+									_t960 := &pb.Formula{}
+									_t960.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction467}
+									_t958 = _t960
 								} else {
-									var _t941 *pb.Formula
-									if prediction451 == 4 {
-										_t942 := p.parse_conjunction()
-										conjunction456 := _t942
-										_t943 := &pb.Formula{}
-										_t943.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction456}
-										_t941 = _t943
+									var _t961 *pb.Formula
+									if prediction461 == 4 {
+										_t962 := p.parse_conjunction()
+										conjunction466 := _t962
+										_t963 := &pb.Formula{}
+										_t963.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction466}
+										_t961 = _t963
 									} else {
-										var _t944 *pb.Formula
-										if prediction451 == 3 {
-											_t945 := p.parse_reduce()
-											reduce455 := _t945
-											_t946 := &pb.Formula{}
-											_t946.FormulaType = &pb.Formula_Reduce{Reduce: reduce455}
-											_t944 = _t946
+										var _t964 *pb.Formula
+										if prediction461 == 3 {
+											_t965 := p.parse_reduce()
+											reduce465 := _t965
+											_t966 := &pb.Formula{}
+											_t966.FormulaType = &pb.Formula_Reduce{Reduce: reduce465}
+											_t964 = _t966
 										} else {
-											var _t947 *pb.Formula
-											if prediction451 == 2 {
-												_t948 := p.parse_exists()
-												exists454 := _t948
-												_t949 := &pb.Formula{}
-												_t949.FormulaType = &pb.Formula_Exists{Exists: exists454}
-												_t947 = _t949
+											var _t967 *pb.Formula
+											if prediction461 == 2 {
+												_t968 := p.parse_exists()
+												exists464 := _t968
+												_t969 := &pb.Formula{}
+												_t969.FormulaType = &pb.Formula_Exists{Exists: exists464}
+												_t967 = _t969
 											} else {
-												var _t950 *pb.Formula
-												if prediction451 == 1 {
-													_t951 := p.parse_false()
-													false453 := _t951
-													_t952 := &pb.Formula{}
-													_t952.FormulaType = &pb.Formula_Disjunction{Disjunction: false453}
-													_t950 = _t952
+												var _t970 *pb.Formula
+												if prediction461 == 1 {
+													_t971 := p.parse_false()
+													false463 := _t971
+													_t972 := &pb.Formula{}
+													_t972.FormulaType = &pb.Formula_Disjunction{Disjunction: false463}
+													_t970 = _t972
 												} else {
-													var _t953 *pb.Formula
-													if prediction451 == 0 {
-														_t954 := p.parse_true()
-														true452 := _t954
-														_t955 := &pb.Formula{}
-														_t955.FormulaType = &pb.Formula_Conjunction{Conjunction: true452}
-														_t953 = _t955
+													var _t973 *pb.Formula
+													if prediction461 == 0 {
+														_t974 := p.parse_true()
+														true462 := _t974
+														_t975 := &pb.Formula{}
+														_t975.FormulaType = &pb.Formula_Conjunction{Conjunction: true462}
+														_t973 = _t975
 													} else {
 														panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)})
 													}
-													_t950 = _t953
+													_t970 = _t973
 												}
-												_t947 = _t950
+												_t967 = _t970
 											}
-											_t944 = _t947
+											_t964 = _t967
 										}
-										_t941 = _t944
+										_t961 = _t964
 									}
-									_t938 = _t941
+									_t958 = _t961
 								}
-								_t935 = _t938
+								_t955 = _t958
 							}
-							_t932 = _t935
+							_t952 = _t955
 						}
-						_t929 = _t932
+						_t949 = _t952
 					}
-					_t926 = _t929
+					_t946 = _t949
 				}
-				_t923 = _t926
+				_t943 = _t946
 			}
-			_t920 = _t923
+			_t940 = _t943
 		}
-		_t917 = _t920
+		_t937 = _t940
 	}
-	return _t917
+	return _t937
 }
 
 func (p *Parser) parse_true() *pb.Conjunction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("true")
 	p.consumeLiteral(")")
-	_t956 := &pb.Conjunction{Args: []*pb.Formula{}}
-	return _t956
+	_t976 := &pb.Conjunction{Args: []*pb.Formula{}}
+	return _t976
 }
 
 func (p *Parser) parse_false() *pb.Disjunction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("false")
 	p.consumeLiteral(")")
-	_t957 := &pb.Disjunction{Args: []*pb.Formula{}}
-	return _t957
+	_t977 := &pb.Disjunction{Args: []*pb.Formula{}}
+	return _t977
 }
 
 func (p *Parser) parse_exists() *pb.Exists {
 	p.consumeLiteral("(")
 	p.consumeLiteral("exists")
-	_t958 := p.parse_bindings()
-	bindings465 := _t958
-	_t959 := p.parse_formula()
-	formula466 := _t959
+	_t978 := p.parse_bindings()
+	bindings475 := _t978
+	_t979 := p.parse_formula()
+	formula476 := _t979
 	p.consumeLiteral(")")
-	_t960 := &pb.Abstraction{Vars: listConcat(bindings465[0].([]*pb.Binding), bindings465[1].([]*pb.Binding)), Value: formula466}
-	_t961 := &pb.Exists{Body: _t960}
-	return _t961
+	_t980 := &pb.Abstraction{Vars: listConcat(bindings475[0].([]*pb.Binding), bindings475[1].([]*pb.Binding)), Value: formula476}
+	_t981 := &pb.Exists{Body: _t980}
+	return _t981
 }
 
 func (p *Parser) parse_reduce() *pb.Reduce {
 	p.consumeLiteral("(")
 	p.consumeLiteral("reduce")
-	_t962 := p.parse_abstraction()
-	abstraction467 := _t962
-	_t963 := p.parse_abstraction()
-	abstraction_3468 := _t963
-	_t964 := p.parse_terms()
-	terms469 := _t964
+	_t982 := p.parse_abstraction()
+	abstraction477 := _t982
+	_t983 := p.parse_abstraction()
+	abstraction_3478 := _t983
+	_t984 := p.parse_terms()
+	terms479 := _t984
 	p.consumeLiteral(")")
-	_t965 := &pb.Reduce{Op: abstraction467, Body: abstraction_3468, Terms: terms469}
-	return _t965
+	_t985 := &pb.Reduce{Op: abstraction477, Body: abstraction_3478, Terms: terms479}
+	return _t985
 }
 
 func (p *Parser) parse_terms() []*pb.Term {
 	p.consumeLiteral("(")
 	p.consumeLiteral("terms")
-	xs470 := []*pb.Term{}
-	cond471 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond471 {
-		_t966 := p.parse_term()
-		item472 := _t966
-		xs470 = append(xs470, item472)
-		cond471 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	xs480 := []*pb.Term{}
+	cond481 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond481 {
+		_t986 := p.parse_term()
+		item482 := _t986
+		xs480 = append(xs480, item482)
+		cond481 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	terms473 := xs470
+	terms483 := xs480
 	p.consumeLiteral(")")
-	return terms473
+	return terms483
 }
 
 func (p *Parser) parse_term() *pb.Term {
-	var _t967 int64
+	var _t987 int64
 	if p.matchLookaheadLiteral("true", 0) {
-		_t967 = 1
+		_t987 = 1
 	} else {
-		var _t968 int64
+		var _t988 int64
 		if p.matchLookaheadLiteral("missing", 0) {
-			_t968 = 1
+			_t988 = 1
 		} else {
-			var _t969 int64
+			var _t989 int64
 			if p.matchLookaheadLiteral("false", 0) {
-				_t969 = 1
+				_t989 = 1
 			} else {
-				var _t970 int64
+				var _t990 int64
 				if p.matchLookaheadLiteral("(", 0) {
-					_t970 = 1
+					_t990 = 1
 				} else {
-					var _t971 int64
+					var _t991 int64
 					if p.matchLookaheadTerminal("UINT128", 0) {
-						_t971 = 1
+						_t991 = 1
 					} else {
-						var _t972 int64
+						var _t992 int64
 						if p.matchLookaheadTerminal("SYMBOL", 0) {
-							_t972 = 0
+							_t992 = 0
 						} else {
-							var _t973 int64
+							var _t993 int64
 							if p.matchLookaheadTerminal("STRING", 0) {
-								_t973 = 1
+								_t993 = 1
 							} else {
-								var _t974 int64
+								var _t994 int64
 								if p.matchLookaheadTerminal("INT128", 0) {
-									_t974 = 1
+									_t994 = 1
 								} else {
-									var _t975 int64
+									var _t995 int64
 									if p.matchLookaheadTerminal("INT", 0) {
-										_t975 = 1
+										_t995 = 1
 									} else {
-										var _t976 int64
+										var _t996 int64
 										if p.matchLookaheadTerminal("FLOAT", 0) {
-											_t976 = 1
+											_t996 = 1
 										} else {
-											var _t977 int64
+											var _t997 int64
 											if p.matchLookaheadTerminal("DECIMAL", 0) {
-												_t977 = 1
+												_t997 = 1
 											} else {
-												_t977 = -1
+												_t997 = -1
 											}
-											_t976 = _t977
+											_t996 = _t997
 										}
-										_t975 = _t976
+										_t995 = _t996
 									}
-									_t974 = _t975
+									_t994 = _t995
 								}
-								_t973 = _t974
+								_t993 = _t994
 							}
-							_t972 = _t973
+							_t992 = _t993
 						}
-						_t971 = _t972
+						_t991 = _t992
 					}
-					_t970 = _t971
+					_t990 = _t991
 				}
-				_t969 = _t970
+				_t989 = _t990
 			}
-			_t968 = _t969
+			_t988 = _t989
 		}
-		_t967 = _t968
-	}
-	prediction474 := _t967
-	var _t978 *pb.Term
-	if prediction474 == 1 {
-		_t979 := p.parse_constant()
-		constant476 := _t979
-		_t980 := &pb.Term{}
-		_t980.TermType = &pb.Term_Constant{Constant: constant476}
-		_t978 = _t980
+		_t987 = _t988
+	}
+	prediction484 := _t987
+	var _t998 *pb.Term
+	if prediction484 == 1 {
+		_t999 := p.parse_constant()
+		constant486 := _t999
+		_t1000 := &pb.Term{}
+		_t1000.TermType = &pb.Term_Constant{Constant: constant486}
+		_t998 = _t1000
 	} else {
-		var _t981 *pb.Term
-		if prediction474 == 0 {
-			_t982 := p.parse_var()
-			var475 := _t982
-			_t983 := &pb.Term{}
-			_t983.TermType = &pb.Term_Var{Var: var475}
-			_t981 = _t983
+		var _t1001 *pb.Term
+		if prediction484 == 0 {
+			_t1002 := p.parse_var()
+			var485 := _t1002
+			_t1003 := &pb.Term{}
+			_t1003.TermType = &pb.Term_Var{Var: var485}
+			_t1001 = _t1003
 		} else {
 			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)})
 		}
-		_t978 = _t981
+		_t998 = _t1001
 	}
-	return _t978
+	return _t998
 }
 
 func (p *Parser) parse_var() *pb.Var {
-	symbol477 := p.consumeTerminal("SYMBOL").Value.str
-	_t984 := &pb.Var{Name: symbol477}
-	return _t984
+	symbol487 := p.consumeTerminal("SYMBOL").Value.str
+	_t1004 := &pb.Var{Name: symbol487}
+	return _t1004
 }
 
 func (p *Parser) parse_constant() *pb.Value {
-	_t985 := p.parse_value()
-	value478 := _t985
-	return value478
+	_t1005 := p.parse_value()
+	value488 := _t1005
+	return value488
 }
 
 func (p *Parser) parse_conjunction() *pb.Conjunction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("and")
-	xs479 := []*pb.Formula{}
-	cond480 := p.matchLookaheadLiteral("(", 0)
-	for cond480 {
-		_t986 := p.parse_formula()
-		item481 := _t986
-		xs479 = append(xs479, item481)
-		cond480 = p.matchLookaheadLiteral("(", 0)
+	xs489 := []*pb.Formula{}
+	cond490 := p.matchLookaheadLiteral("(", 0)
+	for cond490 {
+		_t1006 := p.parse_formula()
+		item491 := _t1006
+		xs489 = append(xs489, item491)
+		cond490 = p.matchLookaheadLiteral("(", 0)
 	}
-	formulas482 := xs479
+	formulas492 := xs489
 	p.consumeLiteral(")")
-	_t987 := &pb.Conjunction{Args: formulas482}
-	return _t987
+	_t1007 := &pb.Conjunction{Args: formulas492}
+	return _t1007
 }
 
 func (p *Parser) parse_disjunction() *pb.Disjunction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("or")
-	xs483 := []*pb.Formula{}
-	cond484 := p.matchLookaheadLiteral("(", 0)
-	for cond484 {
-		_t988 := p.parse_formula()
-		item485 := _t988
-		xs483 = append(xs483, item485)
-		cond484 = p.matchLookaheadLiteral("(", 0)
+	xs493 := []*pb.Formula{}
+	cond494 := p.matchLookaheadLiteral("(", 0)
+	for cond494 {
+		_t1008 := p.parse_formula()
+		item495 := _t1008
+		xs493 = append(xs493, item495)
+		cond494 = p.matchLookaheadLiteral("(", 0)
 	}
-	formulas486 := xs483
+	formulas496 := xs493
 	p.consumeLiteral(")")
-	_t989 := &pb.Disjunction{Args: formulas486}
-	return _t989
+	_t1009 := &pb.Disjunction{Args: formulas496}
+	return _t1009
 }
 
 func (p *Parser) parse_not() *pb.Not {
 	p.consumeLiteral("(")
 	p.consumeLiteral("not")
-	_t990 := p.parse_formula()
-	formula487 := _t990
+	_t1010 := p.parse_formula()
+	formula497 := _t1010
 	p.consumeLiteral(")")
-	_t991 := &pb.Not{Arg: formula487}
-	return _t991
+	_t1011 := &pb.Not{Arg: formula497}
+	return _t1011
 }
 
 func (p *Parser) parse_ffi() *pb.FFI {
 	p.consumeLiteral("(")
 	p.consumeLiteral("ffi")
-	_t992 := p.parse_name()
-	name488 := _t992
-	_t993 := p.parse_ffi_args()
-	ffi_args489 := _t993
-	_t994 := p.parse_terms()
-	terms490 := _t994
+	_t1012 := p.parse_name()
+	name498 := _t1012
+	_t1013 := p.parse_ffi_args()
+	ffi_args499 := _t1013
+	_t1014 := p.parse_terms()
+	terms500 := _t1014
 	p.consumeLiteral(")")
-	_t995 := &pb.FFI{Name: name488, Args: ffi_args489, Terms: terms490}
-	return _t995
+	_t1015 := &pb.FFI{Name: name498, Args: ffi_args499, Terms: terms500}
+	return _t1015
 }
 
 func (p *Parser) parse_name() string {
 	p.consumeLiteral(":")
-	symbol491 := p.consumeTerminal("SYMBOL").Value.str
-	return symbol491
+	symbol501 := p.consumeTerminal("SYMBOL").Value.str
+	return symbol501
 }
 
 func (p *Parser) parse_ffi_args() []*pb.Abstraction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("args")
-	xs492 := []*pb.Abstraction{}
-	cond493 := p.matchLookaheadLiteral("(", 0)
-	for cond493 {
-		_t996 := p.parse_abstraction()
-		item494 := _t996
-		xs492 = append(xs492, item494)
-		cond493 = p.matchLookaheadLiteral("(", 0)
+	xs502 := []*pb.Abstraction{}
+	cond503 := p.matchLookaheadLiteral("(", 0)
+	for cond503 {
+		_t1016 := p.parse_abstraction()
+		item504 := _t1016
+		xs502 = append(xs502, item504)
+		cond503 = p.matchLookaheadLiteral("(", 0)
 	}
-	abstractions495 := xs492
+	abstractions505 := xs502
 	p.consumeLiteral(")")
-	return abstractions495
+	return abstractions505
 }
 
 func (p *Parser) parse_atom() *pb.Atom {
 	p.consumeLiteral("(")
 	p.consumeLiteral("atom")
-	_t997 := p.parse_relation_id()
-	relation_id496 := _t997
-	xs497 := []*pb.Term{}
-	cond498 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond498 {
-		_t998 := p.parse_term()
-		item499 := _t998
-		xs497 = append(xs497, item499)
-		cond498 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	_t1017 := p.parse_relation_id()
+	relation_id506 := _t1017
+	xs507 := []*pb.Term{}
+	cond508 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond508 {
+		_t1018 := p.parse_term()
+		item509 := _t1018
+		xs507 = append(xs507, item509)
+		cond508 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	terms500 := xs497
+	terms510 := xs507
 	p.consumeLiteral(")")
-	_t999 := &pb.Atom{Name: relation_id496, Terms: terms500}
-	return _t999
+	_t1019 := &pb.Atom{Name: relation_id506, Terms: terms510}
+	return _t1019
 }
 
 func (p *Parser) parse_pragma() *pb.Pragma {
 	p.consumeLiteral("(")
 	p.consumeLiteral("pragma")
-	_t1000 := p.parse_name()
-	name501 := _t1000
-	xs502 := []*pb.Term{}
-	cond503 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond503 {
-		_t1001 := p.parse_term()
-		item504 := _t1001
-		xs502 = append(xs502, item504)
-		cond503 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	_t1020 := p.parse_name()
+	name511 := _t1020
+	xs512 := []*pb.Term{}
+	cond513 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond513 {
+		_t1021 := p.parse_term()
+		item514 := _t1021
+		xs512 = append(xs512, item514)
+		cond513 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	terms505 := xs502
+	terms515 := xs512
 	p.consumeLiteral(")")
-	_t1002 := &pb.Pragma{Name: name501, Terms: terms505}
-	return _t1002
+	_t1022 := &pb.Pragma{Name: name511, Terms: terms515}
+	return _t1022
 }
 
 func (p *Parser) parse_primitive() *pb.Primitive {
-	var _t1003 int64
+	var _t1023 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1004 int64
+		var _t1024 int64
 		if p.matchLookaheadLiteral("primitive", 1) {
-			_t1004 = 9
+			_t1024 = 9
 		} else {
-			var _t1005 int64
+			var _t1025 int64
 			if p.matchLookaheadLiteral(">=", 1) {
-				_t1005 = 4
+				_t1025 = 4
 			} else {
-				var _t1006 int64
+				var _t1026 int64
 				if p.matchLookaheadLiteral(">", 1) {
-					_t1006 = 3
+					_t1026 = 3
 				} else {
-					var _t1007 int64
+					var _t1027 int64
 					if p.matchLookaheadLiteral("=", 1) {
-						_t1007 = 0
+						_t1027 = 0
 					} else {
-						var _t1008 int64
+						var _t1028 int64
 						if p.matchLookaheadLiteral("<=", 1) {
-							_t1008 = 2
+							_t1028 = 2
 						} else {
-							var _t1009 int64
+							var _t1029 int64
 							if p.matchLookaheadLiteral("<", 1) {
-								_t1009 = 1
+								_t1029 = 1
 							} else {
-								var _t1010 int64
+								var _t1030 int64
 								if p.matchLookaheadLiteral("/", 1) {
-									_t1010 = 8
+									_t1030 = 8
 								} else {
-									var _t1011 int64
+									var _t1031 int64
 									if p.matchLookaheadLiteral("-", 1) {
-										_t1011 = 6
+										_t1031 = 6
 									} else {
-										var _t1012 int64
+										var _t1032 int64
 										if p.matchLookaheadLiteral("+", 1) {
-											_t1012 = 5
+											_t1032 = 5
 										} else {
-											var _t1013 int64
+											var _t1033 int64
 											if p.matchLookaheadLiteral("*", 1) {
-												_t1013 = 7
+												_t1033 = 7
 											} else {
-												_t1013 = -1
+												_t1033 = -1
 											}
-											_t1012 = _t1013
+											_t1032 = _t1033
 										}
-										_t1011 = _t1012
+										_t1031 = _t1032
 									}
-									_t1010 = _t1011
+									_t1030 = _t1031
 								}
-								_t1009 = _t1010
+								_t1029 = _t1030
 							}
-							_t1008 = _t1009
+							_t1028 = _t1029
 						}
-						_t1007 = _t1008
+						_t1027 = _t1028
 					}
-					_t1006 = _t1007
+					_t1026 = _t1027
 				}
-				_t1005 = _t1006
+				_t1025 = _t1026
 			}
-			_t1004 = _t1005
+			_t1024 = _t1025
 		}
-		_t1003 = _t1004
+		_t1023 = _t1024
 	} else {
-		_t1003 = -1
+		_t1023 = -1
 	}
-	prediction506 := _t1003
-	var _t1014 *pb.Primitive
-	if prediction506 == 9 {
+	prediction516 := _t1023
+	var _t1034 *pb.Primitive
+	if prediction516 == 9 {
 		p.consumeLiteral("(")
 		p.consumeLiteral("primitive")
-		_t1015 := p.parse_name()
-		name516 := _t1015
-		xs517 := []*pb.RelTerm{}
-		cond518 := (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-		for cond518 {
-			_t1016 := p.parse_rel_term()
-			item519 := _t1016
-			xs517 = append(xs517, item519)
-			cond518 = (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+		_t1035 := p.parse_name()
+		name526 := _t1035
+		xs527 := []*pb.RelTerm{}
+		cond528 := (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+		for cond528 {
+			_t1036 := p.parse_rel_term()
+			item529 := _t1036
+			xs527 = append(xs527, item529)
+			cond528 = (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
 		}
-		rel_terms520 := xs517
+		rel_terms530 := xs527
 		p.consumeLiteral(")")
-		_t1017 := &pb.Primitive{Name: name516, Terms: rel_terms520}
-		_t1014 = _t1017
+		_t1037 := &pb.Primitive{Name: name526, Terms: rel_terms530}
+		_t1034 = _t1037
 	} else {
-		var _t1018 *pb.Primitive
-		if prediction506 == 8 {
-			_t1019 := p.parse_divide()
-			divide515 := _t1019
-			_t1018 = divide515
+		var _t1038 *pb.Primitive
+		if prediction516 == 8 {
+			_t1039 := p.parse_divide()
+			divide525 := _t1039
+			_t1038 = divide525
 		} else {
-			var _t1020 *pb.Primitive
-			if prediction506 == 7 {
-				_t1021 := p.parse_multiply()
-				multiply514 := _t1021
-				_t1020 = multiply514
+			var _t1040 *pb.Primitive
+			if prediction516 == 7 {
+				_t1041 := p.parse_multiply()
+				multiply524 := _t1041
+				_t1040 = multiply524
 			} else {
-				var _t1022 *pb.Primitive
-				if prediction506 == 6 {
-					_t1023 := p.parse_minus()
-					minus513 := _t1023
-					_t1022 = minus513
+				var _t1042 *pb.Primitive
+				if prediction516 == 6 {
+					_t1043 := p.parse_minus()
+					minus523 := _t1043
+					_t1042 = minus523
 				} else {
-					var _t1024 *pb.Primitive
-					if prediction506 == 5 {
-						_t1025 := p.parse_add()
-						add512 := _t1025
-						_t1024 = add512
+					var _t1044 *pb.Primitive
+					if prediction516 == 5 {
+						_t1045 := p.parse_add()
+						add522 := _t1045
+						_t1044 = add522
 					} else {
-						var _t1026 *pb.Primitive
-						if prediction506 == 4 {
-							_t1027 := p.parse_gt_eq()
-							gt_eq511 := _t1027
-							_t1026 = gt_eq511
+						var _t1046 *pb.Primitive
+						if prediction516 == 4 {
+							_t1047 := p.parse_gt_eq()
+							gt_eq521 := _t1047
+							_t1046 = gt_eq521
 						} else {
-							var _t1028 *pb.Primitive
-							if prediction506 == 3 {
-								_t1029 := p.parse_gt()
-								gt510 := _t1029
-								_t1028 = gt510
+							var _t1048 *pb.Primitive
+							if prediction516 == 3 {
+								_t1049 := p.parse_gt()
+								gt520 := _t1049
+								_t1048 = gt520
 							} else {
-								var _t1030 *pb.Primitive
-								if prediction506 == 2 {
-									_t1031 := p.parse_lt_eq()
-									lt_eq509 := _t1031
-									_t1030 = lt_eq509
+								var _t1050 *pb.Primitive
+								if prediction516 == 2 {
+									_t1051 := p.parse_lt_eq()
+									lt_eq519 := _t1051
+									_t1050 = lt_eq519
 								} else {
-									var _t1032 *pb.Primitive
-									if prediction506 == 1 {
-										_t1033 := p.parse_lt()
-										lt508 := _t1033
-										_t1032 = lt508
+									var _t1052 *pb.Primitive
+									if prediction516 == 1 {
+										_t1053 := p.parse_lt()
+										lt518 := _t1053
+										_t1052 = lt518
 									} else {
-										var _t1034 *pb.Primitive
-										if prediction506 == 0 {
-											_t1035 := p.parse_eq()
-											eq507 := _t1035
-											_t1034 = eq507
+										var _t1054 *pb.Primitive
+										if prediction516 == 0 {
+											_t1055 := p.parse_eq()
+											eq517 := _t1055
+											_t1054 = eq517
 										} else {
 											panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)})
 										}
-										_t1032 = _t1034
+										_t1052 = _t1054
 									}
-									_t1030 = _t1032
+									_t1050 = _t1052
 								}
-								_t1028 = _t1030
+								_t1048 = _t1050
 							}
-							_t1026 = _t1028
+							_t1046 = _t1048
 						}
-						_t1024 = _t1026
+						_t1044 = _t1046
 					}
-					_t1022 = _t1024
+					_t1042 = _t1044
 				}
-				_t1020 = _t1022
+				_t1040 = _t1042
 			}
-			_t1018 = _t1020
+			_t1038 = _t1040
 		}
-		_t1014 = _t1018
+		_t1034 = _t1038
 	}
-	return _t1014
+	return _t1034
 }
 
 func (p *Parser) parse_eq() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("=")
-	_t1036 := p.parse_term()
-	term521 := _t1036
-	_t1037 := p.parse_term()
-	term_3522 := _t1037
+	_t1056 := p.parse_term()
+	term531 := _t1056
+	_t1057 := p.parse_term()
+	term_3532 := _t1057
 	p.consumeLiteral(")")
-	_t1038 := &pb.RelTerm{}
-	_t1038.RelTermType = &pb.RelTerm_Term{Term: term521}
-	_t1039 := &pb.RelTerm{}
-	_t1039.RelTermType = &pb.RelTerm_Term{Term: term_3522}
-	_t1040 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1038, _t1039}}
-	return _t1040
+	_t1058 := &pb.RelTerm{}
+	_t1058.RelTermType = &pb.RelTerm_Term{Term: term531}
+	_t1059 := &pb.RelTerm{}
+	_t1059.RelTermType = &pb.RelTerm_Term{Term: term_3532}
+	_t1060 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1058, _t1059}}
+	return _t1060
 }
 
 func (p *Parser) parse_lt() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("<")
-	_t1041 := p.parse_term()
-	term523 := _t1041
-	_t1042 := p.parse_term()
-	term_3524 := _t1042
+	_t1061 := p.parse_term()
+	term533 := _t1061
+	_t1062 := p.parse_term()
+	term_3534 := _t1062
 	p.consumeLiteral(")")
-	_t1043 := &pb.RelTerm{}
-	_t1043.RelTermType = &pb.RelTerm_Term{Term: term523}
-	_t1044 := &pb.RelTerm{}
-	_t1044.RelTermType = &pb.RelTerm_Term{Term: term_3524}
-	_t1045 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1043, _t1044}}
-	return _t1045
+	_t1063 := &pb.RelTerm{}
+	_t1063.RelTermType = &pb.RelTerm_Term{Term: term533}
+	_t1064 := &pb.RelTerm{}
+	_t1064.RelTermType = &pb.RelTerm_Term{Term: term_3534}
+	_t1065 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1063, _t1064}}
+	return _t1065
 }
 
 func (p *Parser) parse_lt_eq() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("<=")
-	_t1046 := p.parse_term()
-	term525 := _t1046
-	_t1047 := p.parse_term()
-	term_3526 := _t1047
+	_t1066 := p.parse_term()
+	term535 := _t1066
+	_t1067 := p.parse_term()
+	term_3536 := _t1067
 	p.consumeLiteral(")")
-	_t1048 := &pb.RelTerm{}
-	_t1048.RelTermType = &pb.RelTerm_Term{Term: term525}
-	_t1049 := &pb.RelTerm{}
-	_t1049.RelTermType = &pb.RelTerm_Term{Term: term_3526}
-	_t1050 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1048, _t1049}}
-	return _t1050
+	_t1068 := &pb.RelTerm{}
+	_t1068.RelTermType = &pb.RelTerm_Term{Term: term535}
+	_t1069 := &pb.RelTerm{}
+	_t1069.RelTermType = &pb.RelTerm_Term{Term: term_3536}
+	_t1070 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1068, _t1069}}
+	return _t1070
 }
 
 func (p *Parser) parse_gt() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral(">")
-	_t1051 := p.parse_term()
-	term527 := _t1051
-	_t1052 := p.parse_term()
-	term_3528 := _t1052
+	_t1071 := p.parse_term()
+	term537 := _t1071
+	_t1072 := p.parse_term()
+	term_3538 := _t1072
 	p.consumeLiteral(")")
-	_t1053 := &pb.RelTerm{}
-	_t1053.RelTermType = &pb.RelTerm_Term{Term: term527}
-	_t1054 := &pb.RelTerm{}
-	_t1054.RelTermType = &pb.RelTerm_Term{Term: term_3528}
-	_t1055 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1053, _t1054}}
-	return _t1055
+	_t1073 := &pb.RelTerm{}
+	_t1073.RelTermType = &pb.RelTerm_Term{Term: term537}
+	_t1074 := &pb.RelTerm{}
+	_t1074.RelTermType = &pb.RelTerm_Term{Term: term_3538}
+	_t1075 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1073, _t1074}}
+	return _t1075
 }
 
 func (p *Parser) parse_gt_eq() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral(">=")
-	_t1056 := p.parse_term()
-	term529 := _t1056
-	_t1057 := p.parse_term()
-	term_3530 := _t1057
+	_t1076 := p.parse_term()
+	term539 := _t1076
+	_t1077 := p.parse_term()
+	term_3540 := _t1077
 	p.consumeLiteral(")")
-	_t1058 := &pb.RelTerm{}
-	_t1058.RelTermType = &pb.RelTerm_Term{Term: term529}
-	_t1059 := &pb.RelTerm{}
-	_t1059.RelTermType = &pb.RelTerm_Term{Term: term_3530}
-	_t1060 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1058, _t1059}}
-	return _t1060
+	_t1078 := &pb.RelTerm{}
+	_t1078.RelTermType = &pb.RelTerm_Term{Term: term539}
+	_t1079 := &pb.RelTerm{}
+	_t1079.RelTermType = &pb.RelTerm_Term{Term: term_3540}
+	_t1080 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1078, _t1079}}
+	return _t1080
 }
 
 func (p *Parser) parse_add() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("+")
-	_t1061 := p.parse_term()
-	term531 := _t1061
-	_t1062 := p.parse_term()
-	term_3532 := _t1062
-	_t1063 := p.parse_term()
-	term_4533 := _t1063
+	_t1081 := p.parse_term()
+	term541 := _t1081
+	_t1082 := p.parse_term()
+	term_3542 := _t1082
+	_t1083 := p.parse_term()
+	term_4543 := _t1083
 	p.consumeLiteral(")")
-	_t1064 := &pb.RelTerm{}
-	_t1064.RelTermType = &pb.RelTerm_Term{Term: term531}
-	_t1065 := &pb.RelTerm{}
-	_t1065.RelTermType = &pb.RelTerm_Term{Term: term_3532}
-	_t1066 := &pb.RelTerm{}
-	_t1066.RelTermType = &pb.RelTerm_Term{Term: term_4533}
-	_t1067 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1064, _t1065, _t1066}}
-	return _t1067
+	_t1084 := &pb.RelTerm{}
+	_t1084.RelTermType = &pb.RelTerm_Term{Term: term541}
+	_t1085 := &pb.RelTerm{}
+	_t1085.RelTermType = &pb.RelTerm_Term{Term: term_3542}
+	_t1086 := &pb.RelTerm{}
+	_t1086.RelTermType = &pb.RelTerm_Term{Term: term_4543}
+	_t1087 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1084, _t1085, _t1086}}
+	return _t1087
 }
 
 func (p *Parser) parse_minus() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("-")
-	_t1068 := p.parse_term()
-	term534 := _t1068
-	_t1069 := p.parse_term()
-	term_3535 := _t1069
-	_t1070 := p.parse_term()
-	term_4536 := _t1070
-	p.consumeLiteral(")")
-	_t1071 := &pb.RelTerm{}
-	_t1071.RelTermType = &pb.RelTerm_Term{Term: term534}
-	_t1072 := &pb.RelTerm{}
-	_t1072.RelTermType = &pb.RelTerm_Term{Term: term_3535}
-	_t1073 := &pb.RelTerm{}
-	_t1073.RelTermType = &pb.RelTerm_Term{Term: term_4536}
-	_t1074 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1071, _t1072, _t1073}}
-	return _t1074
+	_t1088 := p.parse_term()
+	term544 := _t1088
+	_t1089 := p.parse_term()
+	term_3545 := _t1089
+	_t1090 := p.parse_term()
+	term_4546 := _t1090
+	p.consumeLiteral(")")
+	_t1091 := &pb.RelTerm{}
+	_t1091.RelTermType = &pb.RelTerm_Term{Term: term544}
+	_t1092 := &pb.RelTerm{}
+	_t1092.RelTermType = &pb.RelTerm_Term{Term: term_3545}
+	_t1093 := &pb.RelTerm{}
+	_t1093.RelTermType = &pb.RelTerm_Term{Term: term_4546}
+	_t1094 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1091, _t1092, _t1093}}
+	return _t1094
 }
 
 func (p *Parser) parse_multiply() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("*")
-	_t1075 := p.parse_term()
-	term537 := _t1075
-	_t1076 := p.parse_term()
-	term_3538 := _t1076
-	_t1077 := p.parse_term()
-	term_4539 := _t1077
-	p.consumeLiteral(")")
-	_t1078 := &pb.RelTerm{}
-	_t1078.RelTermType = &pb.RelTerm_Term{Term: term537}
-	_t1079 := &pb.RelTerm{}
-	_t1079.RelTermType = &pb.RelTerm_Term{Term: term_3538}
-	_t1080 := &pb.RelTerm{}
-	_t1080.RelTermType = &pb.RelTerm_Term{Term: term_4539}
-	_t1081 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1078, _t1079, _t1080}}
-	return _t1081
+	_t1095 := p.parse_term()
+	term547 := _t1095
+	_t1096 := p.parse_term()
+	term_3548 := _t1096
+	_t1097 := p.parse_term()
+	term_4549 := _t1097
+	p.consumeLiteral(")")
+	_t1098 := &pb.RelTerm{}
+	_t1098.RelTermType = &pb.RelTerm_Term{Term: term547}
+	_t1099 := &pb.RelTerm{}
+	_t1099.RelTermType = &pb.RelTerm_Term{Term: term_3548}
+	_t1100 := &pb.RelTerm{}
+	_t1100.RelTermType = &pb.RelTerm_Term{Term: term_4549}
+	_t1101 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1098, _t1099, _t1100}}
+	return _t1101
 }
 
 func (p *Parser) parse_divide() *pb.Primitive {
 	p.consumeLiteral("(")
 	p.consumeLiteral("/")
-	_t1082 := p.parse_term()
-	term540 := _t1082
-	_t1083 := p.parse_term()
-	term_3541 := _t1083
-	_t1084 := p.parse_term()
-	term_4542 := _t1084
-	p.consumeLiteral(")")
-	_t1085 := &pb.RelTerm{}
-	_t1085.RelTermType = &pb.RelTerm_Term{Term: term540}
-	_t1086 := &pb.RelTerm{}
-	_t1086.RelTermType = &pb.RelTerm_Term{Term: term_3541}
-	_t1087 := &pb.RelTerm{}
-	_t1087.RelTermType = &pb.RelTerm_Term{Term: term_4542}
-	_t1088 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1085, _t1086, _t1087}}
-	return _t1088
+	_t1102 := p.parse_term()
+	term550 := _t1102
+	_t1103 := p.parse_term()
+	term_3551 := _t1103
+	_t1104 := p.parse_term()
+	term_4552 := _t1104
+	p.consumeLiteral(")")
+	_t1105 := &pb.RelTerm{}
+	_t1105.RelTermType = &pb.RelTerm_Term{Term: term550}
+	_t1106 := &pb.RelTerm{}
+	_t1106.RelTermType = &pb.RelTerm_Term{Term: term_3551}
+	_t1107 := &pb.RelTerm{}
+	_t1107.RelTermType = &pb.RelTerm_Term{Term: term_4552}
+	_t1108 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1105, _t1106, _t1107}}
+	return _t1108
 }
 
 func (p *Parser) parse_rel_term() *pb.RelTerm {
-	var _t1089 int64
+	var _t1109 int64
 	if p.matchLookaheadLiteral("true", 0) {
-		_t1089 = 1
+		_t1109 = 1
 	} else {
-		var _t1090 int64
+		var _t1110 int64
 		if p.matchLookaheadLiteral("missing", 0) {
-			_t1090 = 1
+			_t1110 = 1
 		} else {
-			var _t1091 int64
+			var _t1111 int64
 			if p.matchLookaheadLiteral("false", 0) {
-				_t1091 = 1
+				_t1111 = 1
 			} else {
-				var _t1092 int64
+				var _t1112 int64
 				if p.matchLookaheadLiteral("(", 0) {
-					_t1092 = 1
+					_t1112 = 1
 				} else {
-					var _t1093 int64
+					var _t1113 int64
 					if p.matchLookaheadLiteral("#", 0) {
-						_t1093 = 0
+						_t1113 = 0
 					} else {
-						var _t1094 int64
+						var _t1114 int64
 						if p.matchLookaheadTerminal("UINT128", 0) {
-							_t1094 = 1
+							_t1114 = 1
 						} else {
-							var _t1095 int64
+							var _t1115 int64
 							if p.matchLookaheadTerminal("SYMBOL", 0) {
-								_t1095 = 1
+								_t1115 = 1
 							} else {
-								var _t1096 int64
+								var _t1116 int64
 								if p.matchLookaheadTerminal("STRING", 0) {
-									_t1096 = 1
+									_t1116 = 1
 								} else {
-									var _t1097 int64
+									var _t1117 int64
 									if p.matchLookaheadTerminal("INT128", 0) {
-										_t1097 = 1
+										_t1117 = 1
 									} else {
-										var _t1098 int64
+										var _t1118 int64
 										if p.matchLookaheadTerminal("INT", 0) {
-											_t1098 = 1
+											_t1118 = 1
 										} else {
-											var _t1099 int64
+											var _t1119 int64
 											if p.matchLookaheadTerminal("FLOAT", 0) {
-												_t1099 = 1
+												_t1119 = 1
 											} else {
-												var _t1100 int64
+												var _t1120 int64
 												if p.matchLookaheadTerminal("DECIMAL", 0) {
-													_t1100 = 1
+													_t1120 = 1
 												} else {
-													_t1100 = -1
+													_t1120 = -1
 												}
-												_t1099 = _t1100
+												_t1119 = _t1120
 											}
-											_t1098 = _t1099
+											_t1118 = _t1119
 										}
-										_t1097 = _t1098
+										_t1117 = _t1118
 									}
-									_t1096 = _t1097
+									_t1116 = _t1117
 								}
-								_t1095 = _t1096
+								_t1115 = _t1116
 							}
-							_t1094 = _t1095
+							_t1114 = _t1115
 						}
-						_t1093 = _t1094
+						_t1113 = _t1114
 					}
-					_t1092 = _t1093
+					_t1112 = _t1113
 				}
-				_t1091 = _t1092
+				_t1111 = _t1112
 			}
-			_t1090 = _t1091
+			_t1110 = _t1111
 		}
-		_t1089 = _t1090
-	}
-	prediction543 := _t1089
-	var _t1101 *pb.RelTerm
-	if prediction543 == 1 {
-		_t1102 := p.parse_term()
-		term545 := _t1102
-		_t1103 := &pb.RelTerm{}
-		_t1103.RelTermType = &pb.RelTerm_Term{Term: term545}
-		_t1101 = _t1103
+		_t1109 = _t1110
+	}
+	prediction553 := _t1109
+	var _t1121 *pb.RelTerm
+	if prediction553 == 1 {
+		_t1122 := p.parse_term()
+		term555 := _t1122
+		_t1123 := &pb.RelTerm{}
+		_t1123.RelTermType = &pb.RelTerm_Term{Term: term555}
+		_t1121 = _t1123
 	} else {
-		var _t1104 *pb.RelTerm
-		if prediction543 == 0 {
-			_t1105 := p.parse_specialized_value()
-			specialized_value544 := _t1105
-			_t1106 := &pb.RelTerm{}
-			_t1106.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value544}
-			_t1104 = _t1106
+		var _t1124 *pb.RelTerm
+		if prediction553 == 0 {
+			_t1125 := p.parse_specialized_value()
+			specialized_value554 := _t1125
+			_t1126 := &pb.RelTerm{}
+			_t1126.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value554}
+			_t1124 = _t1126
 		} else {
 			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)})
 		}
-		_t1101 = _t1104
+		_t1121 = _t1124
 	}
-	return _t1101
+	return _t1121
 }
 
 func (p *Parser) parse_specialized_value() *pb.Value {
 	p.consumeLiteral("#")
-	_t1107 := p.parse_value()
-	value546 := _t1107
-	return value546
+	_t1127 := p.parse_value()
+	value556 := _t1127
+	return value556
 }
 
 func (p *Parser) parse_rel_atom() *pb.RelAtom {
 	p.consumeLiteral("(")
 	p.consumeLiteral("relatom")
-	_t1108 := p.parse_name()
-	name547 := _t1108
-	xs548 := []*pb.RelTerm{}
-	cond549 := (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond549 {
-		_t1109 := p.parse_rel_term()
-		item550 := _t1109
-		xs548 = append(xs548, item550)
-		cond549 = (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	}
-	rel_terms551 := xs548
-	p.consumeLiteral(")")
-	_t1110 := &pb.RelAtom{Name: name547, Terms: rel_terms551}
-	return _t1110
+	_t1128 := p.parse_name()
+	name557 := _t1128
+	xs558 := []*pb.RelTerm{}
+	cond559 := (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond559 {
+		_t1129 := p.parse_rel_term()
+		item560 := _t1129
+		xs558 = append(xs558, item560)
+		cond559 = (((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	}
+	rel_terms561 := xs558
+	p.consumeLiteral(")")
+	_t1130 := &pb.RelAtom{Name: name557, Terms: rel_terms561}
+	return _t1130
 }
 
 func (p *Parser) parse_cast() *pb.Cast {
 	p.consumeLiteral("(")
 	p.consumeLiteral("cast")
-	_t1111 := p.parse_term()
-	term552 := _t1111
-	_t1112 := p.parse_term()
-	term_3553 := _t1112
+	_t1131 := p.parse_term()
+	term562 := _t1131
+	_t1132 := p.parse_term()
+	term_3563 := _t1132
 	p.consumeLiteral(")")
-	_t1113 := &pb.Cast{Input: term552, Result: term_3553}
-	return _t1113
+	_t1133 := &pb.Cast{Input: term562, Result: term_3563}
+	return _t1133
 }
 
 func (p *Parser) parse_attrs() []*pb.Attribute {
 	p.consumeLiteral("(")
 	p.consumeLiteral("attrs")
-	xs554 := []*pb.Attribute{}
-	cond555 := p.matchLookaheadLiteral("(", 0)
-	for cond555 {
-		_t1114 := p.parse_attribute()
-		item556 := _t1114
-		xs554 = append(xs554, item556)
-		cond555 = p.matchLookaheadLiteral("(", 0)
+	xs564 := []*pb.Attribute{}
+	cond565 := p.matchLookaheadLiteral("(", 0)
+	for cond565 {
+		_t1134 := p.parse_attribute()
+		item566 := _t1134
+		xs564 = append(xs564, item566)
+		cond565 = p.matchLookaheadLiteral("(", 0)
 	}
-	attributes557 := xs554
+	attributes567 := xs564
 	p.consumeLiteral(")")
-	return attributes557
+	return attributes567
 }
 
 func (p *Parser) parse_attribute() *pb.Attribute {
 	p.consumeLiteral("(")
 	p.consumeLiteral("attribute")
-	_t1115 := p.parse_name()
-	name558 := _t1115
-	xs559 := []*pb.Value{}
-	cond560 := (((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond560 {
-		_t1116 := p.parse_value()
-		item561 := _t1116
-		xs559 = append(xs559, item561)
-		cond560 = (((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	_t1135 := p.parse_name()
+	name568 := _t1135
+	xs569 := []*pb.Value{}
+	cond570 := (((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond570 {
+		_t1136 := p.parse_value()
+		item571 := _t1136
+		xs569 = append(xs569, item571)
+		cond570 = (((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	values562 := xs559
+	values572 := xs569
 	p.consumeLiteral(")")
-	_t1117 := &pb.Attribute{Name: name558, Args: values562}
-	return _t1117
+	_t1137 := &pb.Attribute{Name: name568, Args: values572}
+	return _t1137
 }
 
 func (p *Parser) parse_algorithm() *pb.Algorithm {
 	p.consumeLiteral("(")
 	p.consumeLiteral("algorithm")
-	xs563 := []*pb.RelationId{}
-	cond564 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond564 {
-		_t1118 := p.parse_relation_id()
-		item565 := _t1118
-		xs563 = append(xs563, item565)
-		cond564 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
+	xs573 := []*pb.RelationId{}
+	cond574 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond574 {
+		_t1138 := p.parse_relation_id()
+		item575 := _t1138
+		xs573 = append(xs573, item575)
+		cond574 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	relation_ids566 := xs563
-	_t1119 := p.parse_script()
-	script567 := _t1119
+	relation_ids576 := xs573
+	_t1139 := p.parse_script()
+	script577 := _t1139
 	p.consumeLiteral(")")
-	_t1120 := &pb.Algorithm{Global: relation_ids566, Body: script567}
-	return _t1120
+	_t1140 := &pb.Algorithm{Global: relation_ids576, Body: script577}
+	return _t1140
 }
 
 func (p *Parser) parse_script() *pb.Script {
 	p.consumeLiteral("(")
 	p.consumeLiteral("script")
-	xs568 := []*pb.Construct{}
-	cond569 := p.matchLookaheadLiteral("(", 0)
-	for cond569 {
-		_t1121 := p.parse_construct()
-		item570 := _t1121
-		xs568 = append(xs568, item570)
-		cond569 = p.matchLookaheadLiteral("(", 0)
+	xs578 := []*pb.Construct{}
+	cond579 := p.matchLookaheadLiteral("(", 0)
+	for cond579 {
+		_t1141 := p.parse_construct()
+		item580 := _t1141
+		xs578 = append(xs578, item580)
+		cond579 = p.matchLookaheadLiteral("(", 0)
 	}
-	constructs571 := xs568
+	constructs581 := xs578
 	p.consumeLiteral(")")
-	_t1122 := &pb.Script{Constructs: constructs571}
-	return _t1122
+	_t1142 := &pb.Script{Constructs: constructs581}
+	return _t1142
 }
 
 func (p *Parser) parse_construct() *pb.Construct {
-	var _t1123 int64
+	var _t1143 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1124 int64
+		var _t1144 int64
 		if p.matchLookaheadLiteral("upsert", 1) {
-			_t1124 = 1
+			_t1144 = 1
 		} else {
-			var _t1125 int64
+			var _t1145 int64
 			if p.matchLookaheadLiteral("monus", 1) {
-				_t1125 = 1
+				_t1145 = 1
 			} else {
-				var _t1126 int64
+				var _t1146 int64
 				if p.matchLookaheadLiteral("monoid", 1) {
-					_t1126 = 1
+					_t1146 = 1
 				} else {
-					var _t1127 int64
+					var _t1147 int64
 					if p.matchLookaheadLiteral("loop", 1) {
-						_t1127 = 0
+						_t1147 = 0
 					} else {
-						var _t1128 int64
+						var _t1148 int64
 						if p.matchLookaheadLiteral("break", 1) {
-							_t1128 = 1
+							_t1148 = 1
 						} else {
-							var _t1129 int64
+							var _t1149 int64
 							if p.matchLookaheadLiteral("assign", 1) {
-								_t1129 = 1
+								_t1149 = 1
 							} else {
-								_t1129 = -1
+								_t1149 = -1
 							}
-							_t1128 = _t1129
+							_t1148 = _t1149
 						}
-						_t1127 = _t1128
+						_t1147 = _t1148
 					}
-					_t1126 = _t1127
+					_t1146 = _t1147
 				}
-				_t1125 = _t1126
+				_t1145 = _t1146
 			}
-			_t1124 = _t1125
+			_t1144 = _t1145
 		}
-		_t1123 = _t1124
+		_t1143 = _t1144
 	} else {
-		_t1123 = -1
-	}
-	prediction572 := _t1123
-	var _t1130 *pb.Construct
-	if prediction572 == 1 {
-		_t1131 := p.parse_instruction()
-		instruction574 := _t1131
-		_t1132 := &pb.Construct{}
-		_t1132.ConstructType = &pb.Construct_Instruction{Instruction: instruction574}
-		_t1130 = _t1132
+		_t1143 = -1
+	}
+	prediction582 := _t1143
+	var _t1150 *pb.Construct
+	if prediction582 == 1 {
+		_t1151 := p.parse_instruction()
+		instruction584 := _t1151
+		_t1152 := &pb.Construct{}
+		_t1152.ConstructType = &pb.Construct_Instruction{Instruction: instruction584}
+		_t1150 = _t1152
 	} else {
-		var _t1133 *pb.Construct
-		if prediction572 == 0 {
-			_t1134 := p.parse_loop()
-			loop573 := _t1134
-			_t1135 := &pb.Construct{}
-			_t1135.ConstructType = &pb.Construct_Loop{Loop: loop573}
-			_t1133 = _t1135
+		var _t1153 *pb.Construct
+		if prediction582 == 0 {
+			_t1154 := p.parse_loop()
+			loop583 := _t1154
+			_t1155 := &pb.Construct{}
+			_t1155.ConstructType = &pb.Construct_Loop{Loop: loop583}
+			_t1153 = _t1155
 		} else {
 			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)})
 		}
-		_t1130 = _t1133
+		_t1150 = _t1153
 	}
-	return _t1130
+	return _t1150
 }
 
 func (p *Parser) parse_loop() *pb.Loop {
 	p.consumeLiteral("(")
 	p.consumeLiteral("loop")
-	_t1136 := p.parse_init()
-	init575 := _t1136
-	_t1137 := p.parse_script()
-	script576 := _t1137
+	_t1156 := p.parse_init()
+	init585 := _t1156
+	_t1157 := p.parse_script()
+	script586 := _t1157
 	p.consumeLiteral(")")
-	_t1138 := &pb.Loop{Init: init575, Body: script576}
-	return _t1138
+	_t1158 := &pb.Loop{Init: init585, Body: script586}
+	return _t1158
 }
 
 func (p *Parser) parse_init() []*pb.Instruction {
 	p.consumeLiteral("(")
 	p.consumeLiteral("init")
-	xs577 := []*pb.Instruction{}
-	cond578 := p.matchLookaheadLiteral("(", 0)
-	for cond578 {
-		_t1139 := p.parse_instruction()
-		item579 := _t1139
-		xs577 = append(xs577, item579)
-		cond578 = p.matchLookaheadLiteral("(", 0)
+	xs587 := []*pb.Instruction{}
+	cond588 := p.matchLookaheadLiteral("(", 0)
+	for cond588 {
+		_t1159 := p.parse_instruction()
+		item589 := _t1159
+		xs587 = append(xs587, item589)
+		cond588 = p.matchLookaheadLiteral("(", 0)
 	}
-	instructions580 := xs577
+	instructions590 := xs587
 	p.consumeLiteral(")")
-	return instructions580
+	return instructions590
 }
 
 func (p *Parser) parse_instruction() *pb.Instruction {
-	var _t1140 int64
+	var _t1160 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1141 int64
+		var _t1161 int64
 		if p.matchLookaheadLiteral("upsert", 1) {
-			_t1141 = 1
+			_t1161 = 1
 		} else {
-			var _t1142 int64
+			var _t1162 int64
 			if p.matchLookaheadLiteral("monus", 1) {
-				_t1142 = 4
+				_t1162 = 4
 			} else {
-				var _t1143 int64
+				var _t1163 int64
 				if p.matchLookaheadLiteral("monoid", 1) {
-					_t1143 = 3
+					_t1163 = 3
 				} else {
-					var _t1144 int64
+					var _t1164 int64
 					if p.matchLookaheadLiteral("break", 1) {
-						_t1144 = 2
+						_t1164 = 2
 					} else {
-						var _t1145 int64
+						var _t1165 int64
 						if p.matchLookaheadLiteral("assign", 1) {
-							_t1145 = 0
+							_t1165 = 0
 						} else {
-							_t1145 = -1
+							_t1165 = -1
 						}
-						_t1144 = _t1145
+						_t1164 = _t1165
 					}
-					_t1143 = _t1144
+					_t1163 = _t1164
 				}
-				_t1142 = _t1143
+				_t1162 = _t1163
 			}
-			_t1141 = _t1142
+			_t1161 = _t1162
 		}
-		_t1140 = _t1141
+		_t1160 = _t1161
 	} else {
-		_t1140 = -1
-	}
-	prediction581 := _t1140
-	var _t1146 *pb.Instruction
-	if prediction581 == 4 {
-		_t1147 := p.parse_monus_def()
-		monus_def586 := _t1147
-		_t1148 := &pb.Instruction{}
-		_t1148.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def586}
-		_t1146 = _t1148
+		_t1160 = -1
+	}
+	prediction591 := _t1160
+	var _t1166 *pb.Instruction
+	if prediction591 == 4 {
+		_t1167 := p.parse_monus_def()
+		monus_def596 := _t1167
+		_t1168 := &pb.Instruction{}
+		_t1168.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def596}
+		_t1166 = _t1168
 	} else {
-		var _t1149 *pb.Instruction
-		if prediction581 == 3 {
-			_t1150 := p.parse_monoid_def()
-			monoid_def585 := _t1150
-			_t1151 := &pb.Instruction{}
-			_t1151.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def585}
-			_t1149 = _t1151
+		var _t1169 *pb.Instruction
+		if prediction591 == 3 {
+			_t1170 := p.parse_monoid_def()
+			monoid_def595 := _t1170
+			_t1171 := &pb.Instruction{}
+			_t1171.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def595}
+			_t1169 = _t1171
 		} else {
-			var _t1152 *pb.Instruction
-			if prediction581 == 2 {
-				_t1153 := p.parse_break()
-				break584 := _t1153
-				_t1154 := &pb.Instruction{}
-				_t1154.InstrType = &pb.Instruction_Break{Break: break584}
-				_t1152 = _t1154
+			var _t1172 *pb.Instruction
+			if prediction591 == 2 {
+				_t1173 := p.parse_break()
+				break594 := _t1173
+				_t1174 := &pb.Instruction{}
+				_t1174.InstrType = &pb.Instruction_Break{Break: break594}
+				_t1172 = _t1174
 			} else {
-				var _t1155 *pb.Instruction
-				if prediction581 == 1 {
-					_t1156 := p.parse_upsert()
-					upsert583 := _t1156
-					_t1157 := &pb.Instruction{}
-					_t1157.InstrType = &pb.Instruction_Upsert{Upsert: upsert583}
-					_t1155 = _t1157
+				var _t1175 *pb.Instruction
+				if prediction591 == 1 {
+					_t1176 := p.parse_upsert()
+					upsert593 := _t1176
+					_t1177 := &pb.Instruction{}
+					_t1177.InstrType = &pb.Instruction_Upsert{Upsert: upsert593}
+					_t1175 = _t1177
 				} else {
-					var _t1158 *pb.Instruction
-					if prediction581 == 0 {
-						_t1159 := p.parse_assign()
-						assign582 := _t1159
-						_t1160 := &pb.Instruction{}
-						_t1160.InstrType = &pb.Instruction_Assign{Assign: assign582}
-						_t1158 = _t1160
+					var _t1178 *pb.Instruction
+					if prediction591 == 0 {
+						_t1179 := p.parse_assign()
+						assign592 := _t1179
+						_t1180 := &pb.Instruction{}
+						_t1180.InstrType = &pb.Instruction_Assign{Assign: assign592}
+						_t1178 = _t1180
 					} else {
 						panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)})
 					}
-					_t1155 = _t1158
+					_t1175 = _t1178
 				}
-				_t1152 = _t1155
+				_t1172 = _t1175
 			}
-			_t1149 = _t1152
+			_t1169 = _t1172
 		}
-		_t1146 = _t1149
+		_t1166 = _t1169
 	}
-	return _t1146
+	return _t1166
 }
 
 func (p *Parser) parse_assign() *pb.Assign {
 	p.consumeLiteral("(")
 	p.consumeLiteral("assign")
-	_t1161 := p.parse_relation_id()
-	relation_id587 := _t1161
-	_t1162 := p.parse_abstraction()
-	abstraction588 := _t1162
-	var _t1163 []*pb.Attribute
+	_t1181 := p.parse_relation_id()
+	relation_id597 := _t1181
+	_t1182 := p.parse_abstraction()
+	abstraction598 := _t1182
+	var _t1183 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1164 := p.parse_attrs()
-		_t1163 = _t1164
+		_t1184 := p.parse_attrs()
+		_t1183 = _t1184
 	}
-	attrs589 := _t1163
+	attrs599 := _t1183
 	p.consumeLiteral(")")
-	_t1165 := attrs589
-	if attrs589 == nil {
-		_t1165 = []*pb.Attribute{}
+	_t1185 := attrs599
+	if attrs599 == nil {
+		_t1185 = []*pb.Attribute{}
 	}
-	_t1166 := &pb.Assign{Name: relation_id587, Body: abstraction588, Attrs: _t1165}
-	return _t1166
+	_t1186 := &pb.Assign{Name: relation_id597, Body: abstraction598, Attrs: _t1185}
+	return _t1186
 }
 
 func (p *Parser) parse_upsert() *pb.Upsert {
 	p.consumeLiteral("(")
 	p.consumeLiteral("upsert")
-	_t1167 := p.parse_relation_id()
-	relation_id590 := _t1167
-	_t1168 := p.parse_abstraction_with_arity()
-	abstraction_with_arity591 := _t1168
-	var _t1169 []*pb.Attribute
+	_t1187 := p.parse_relation_id()
+	relation_id600 := _t1187
+	_t1188 := p.parse_abstraction_with_arity()
+	abstraction_with_arity601 := _t1188
+	var _t1189 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1170 := p.parse_attrs()
-		_t1169 = _t1170
+		_t1190 := p.parse_attrs()
+		_t1189 = _t1190
 	}
-	attrs592 := _t1169
+	attrs602 := _t1189
 	p.consumeLiteral(")")
-	_t1171 := attrs592
-	if attrs592 == nil {
-		_t1171 = []*pb.Attribute{}
+	_t1191 := attrs602
+	if attrs602 == nil {
+		_t1191 = []*pb.Attribute{}
 	}
-	_t1172 := &pb.Upsert{Name: relation_id590, Body: abstraction_with_arity591[0].(*pb.Abstraction), Attrs: _t1171, ValueArity: abstraction_with_arity591[1].(int64)}
-	return _t1172
+	_t1192 := &pb.Upsert{Name: relation_id600, Body: abstraction_with_arity601[0].(*pb.Abstraction), Attrs: _t1191, ValueArity: abstraction_with_arity601[1].(int64)}
+	return _t1192
 }
 
 func (p *Parser) parse_abstraction_with_arity() []interface{} {
 	p.consumeLiteral("(")
-	_t1173 := p.parse_bindings()
-	bindings593 := _t1173
-	_t1174 := p.parse_formula()
-	formula594 := _t1174
+	_t1193 := p.parse_bindings()
+	bindings603 := _t1193
+	_t1194 := p.parse_formula()
+	formula604 := _t1194
 	p.consumeLiteral(")")
-	_t1175 := &pb.Abstraction{Vars: listConcat(bindings593[0].([]*pb.Binding), bindings593[1].([]*pb.Binding)), Value: formula594}
-	return []interface{}{_t1175, int64(len(bindings593[1].([]*pb.Binding)))}
+	_t1195 := &pb.Abstraction{Vars: listConcat(bindings603[0].([]*pb.Binding), bindings603[1].([]*pb.Binding)), Value: formula604}
+	return []interface{}{_t1195, int64(len(bindings603[1].([]*pb.Binding)))}
 }
 
 func (p *Parser) parse_break() *pb.Break {
 	p.consumeLiteral("(")
 	p.consumeLiteral("break")
-	_t1176 := p.parse_relation_id()
-	relation_id595 := _t1176
-	_t1177 := p.parse_abstraction()
-	abstraction596 := _t1177
-	var _t1178 []*pb.Attribute
+	_t1196 := p.parse_relation_id()
+	relation_id605 := _t1196
+	_t1197 := p.parse_abstraction()
+	abstraction606 := _t1197
+	var _t1198 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1179 := p.parse_attrs()
-		_t1178 = _t1179
+		_t1199 := p.parse_attrs()
+		_t1198 = _t1199
 	}
-	attrs597 := _t1178
+	attrs607 := _t1198
 	p.consumeLiteral(")")
-	_t1180 := attrs597
-	if attrs597 == nil {
-		_t1180 = []*pb.Attribute{}
+	_t1200 := attrs607
+	if attrs607 == nil {
+		_t1200 = []*pb.Attribute{}
 	}
-	_t1181 := &pb.Break{Name: relation_id595, Body: abstraction596, Attrs: _t1180}
-	return _t1181
+	_t1201 := &pb.Break{Name: relation_id605, Body: abstraction606, Attrs: _t1200}
+	return _t1201
 }
 
 func (p *Parser) parse_monoid_def() *pb.MonoidDef {
 	p.consumeLiteral("(")
 	p.consumeLiteral("monoid")
-	_t1182 := p.parse_monoid()
-	monoid598 := _t1182
-	_t1183 := p.parse_relation_id()
-	relation_id599 := _t1183
-	_t1184 := p.parse_abstraction_with_arity()
-	abstraction_with_arity600 := _t1184
-	var _t1185 []*pb.Attribute
+	_t1202 := p.parse_monoid()
+	monoid608 := _t1202
+	_t1203 := p.parse_relation_id()
+	relation_id609 := _t1203
+	_t1204 := p.parse_abstraction_with_arity()
+	abstraction_with_arity610 := _t1204
+	var _t1205 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1186 := p.parse_attrs()
-		_t1185 = _t1186
+		_t1206 := p.parse_attrs()
+		_t1205 = _t1206
 	}
-	attrs601 := _t1185
+	attrs611 := _t1205
 	p.consumeLiteral(")")
-	_t1187 := attrs601
-	if attrs601 == nil {
-		_t1187 = []*pb.Attribute{}
+	_t1207 := attrs611
+	if attrs611 == nil {
+		_t1207 = []*pb.Attribute{}
 	}
-	_t1188 := &pb.MonoidDef{Monoid: monoid598, Name: relation_id599, Body: abstraction_with_arity600[0].(*pb.Abstraction), Attrs: _t1187, ValueArity: abstraction_with_arity600[1].(int64)}
-	return _t1188
+	_t1208 := &pb.MonoidDef{Monoid: monoid608, Name: relation_id609, Body: abstraction_with_arity610[0].(*pb.Abstraction), Attrs: _t1207, ValueArity: abstraction_with_arity610[1].(int64)}
+	return _t1208
 }
 
 func (p *Parser) parse_monoid() *pb.Monoid {
-	var _t1189 int64
+	var _t1209 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1190 int64
+		var _t1210 int64
 		if p.matchLookaheadLiteral("sum", 1) {
-			_t1190 = 3
+			_t1210 = 3
 		} else {
-			var _t1191 int64
+			var _t1211 int64
 			if p.matchLookaheadLiteral("or", 1) {
-				_t1191 = 0
+				_t1211 = 0
 			} else {
-				var _t1192 int64
+				var _t1212 int64
 				if p.matchLookaheadLiteral("min", 1) {
-					_t1192 = 1
+					_t1212 = 1
 				} else {
-					var _t1193 int64
+					var _t1213 int64
 					if p.matchLookaheadLiteral("max", 1) {
-						_t1193 = 2
+						_t1213 = 2
 					} else {
-						_t1193 = -1
+						_t1213 = -1
 					}
-					_t1192 = _t1193
+					_t1212 = _t1213
 				}
-				_t1191 = _t1192
+				_t1211 = _t1212
 			}
-			_t1190 = _t1191
+			_t1210 = _t1211
 		}
-		_t1189 = _t1190
+		_t1209 = _t1210
 	} else {
-		_t1189 = -1
-	}
-	prediction602 := _t1189
-	var _t1194 *pb.Monoid
-	if prediction602 == 3 {
-		_t1195 := p.parse_sum_monoid()
-		sum_monoid606 := _t1195
-		_t1196 := &pb.Monoid{}
-		_t1196.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid606}
-		_t1194 = _t1196
+		_t1209 = -1
+	}
+	prediction612 := _t1209
+	var _t1214 *pb.Monoid
+	if prediction612 == 3 {
+		_t1215 := p.parse_sum_monoid()
+		sum_monoid616 := _t1215
+		_t1216 := &pb.Monoid{}
+		_t1216.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid616}
+		_t1214 = _t1216
 	} else {
-		var _t1197 *pb.Monoid
-		if prediction602 == 2 {
-			_t1198 := p.parse_max_monoid()
-			max_monoid605 := _t1198
-			_t1199 := &pb.Monoid{}
-			_t1199.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid605}
-			_t1197 = _t1199
+		var _t1217 *pb.Monoid
+		if prediction612 == 2 {
+			_t1218 := p.parse_max_monoid()
+			max_monoid615 := _t1218
+			_t1219 := &pb.Monoid{}
+			_t1219.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid615}
+			_t1217 = _t1219
 		} else {
-			var _t1200 *pb.Monoid
-			if prediction602 == 1 {
-				_t1201 := p.parse_min_monoid()
-				min_monoid604 := _t1201
-				_t1202 := &pb.Monoid{}
-				_t1202.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid604}
-				_t1200 = _t1202
+			var _t1220 *pb.Monoid
+			if prediction612 == 1 {
+				_t1221 := p.parse_min_monoid()
+				min_monoid614 := _t1221
+				_t1222 := &pb.Monoid{}
+				_t1222.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid614}
+				_t1220 = _t1222
 			} else {
-				var _t1203 *pb.Monoid
-				if prediction602 == 0 {
-					_t1204 := p.parse_or_monoid()
-					or_monoid603 := _t1204
-					_t1205 := &pb.Monoid{}
-					_t1205.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid603}
-					_t1203 = _t1205
+				var _t1223 *pb.Monoid
+				if prediction612 == 0 {
+					_t1224 := p.parse_or_monoid()
+					or_monoid613 := _t1224
+					_t1225 := &pb.Monoid{}
+					_t1225.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid613}
+					_t1223 = _t1225
 				} else {
 					panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)})
 				}
-				_t1200 = _t1203
+				_t1220 = _t1223
 			}
-			_t1197 = _t1200
+			_t1217 = _t1220
 		}
-		_t1194 = _t1197
+		_t1214 = _t1217
 	}
-	return _t1194
+	return _t1214
 }
 
 func (p *Parser) parse_or_monoid() *pb.OrMonoid {
 	p.consumeLiteral("(")
 	p.consumeLiteral("or")
 	p.consumeLiteral(")")
-	_t1206 := &pb.OrMonoid{}
-	return _t1206
+	_t1226 := &pb.OrMonoid{}
+	return _t1226
 }
 
 func (p *Parser) parse_min_monoid() *pb.MinMonoid {
 	p.consumeLiteral("(")
 	p.consumeLiteral("min")
-	_t1207 := p.parse_type()
-	type607 := _t1207
+	_t1227 := p.parse_type()
+	type617 := _t1227
 	p.consumeLiteral(")")
-	_t1208 := &pb.MinMonoid{Type: type607}
-	return _t1208
+	_t1228 := &pb.MinMonoid{Type: type617}
+	return _t1228
 }
 
 func (p *Parser) parse_max_monoid() *pb.MaxMonoid {
 	p.consumeLiteral("(")
 	p.consumeLiteral("max")
-	_t1209 := p.parse_type()
-	type608 := _t1209
+	_t1229 := p.parse_type()
+	type618 := _t1229
 	p.consumeLiteral(")")
-	_t1210 := &pb.MaxMonoid{Type: type608}
-	return _t1210
+	_t1230 := &pb.MaxMonoid{Type: type618}
+	return _t1230
 }
 
 func (p *Parser) parse_sum_monoid() *pb.SumMonoid {
 	p.consumeLiteral("(")
 	p.consumeLiteral("sum")
-	_t1211 := p.parse_type()
-	type609 := _t1211
+	_t1231 := p.parse_type()
+	type619 := _t1231
 	p.consumeLiteral(")")
-	_t1212 := &pb.SumMonoid{Type: type609}
-	return _t1212
+	_t1232 := &pb.SumMonoid{Type: type619}
+	return _t1232
 }
 
 func (p *Parser) parse_monus_def() *pb.MonusDef {
 	p.consumeLiteral("(")
 	p.consumeLiteral("monus")
-	_t1213 := p.parse_monoid()
-	monoid610 := _t1213
-	_t1214 := p.parse_relation_id()
-	relation_id611 := _t1214
-	_t1215 := p.parse_abstraction_with_arity()
-	abstraction_with_arity612 := _t1215
-	var _t1216 []*pb.Attribute
+	_t1233 := p.parse_monoid()
+	monoid620 := _t1233
+	_t1234 := p.parse_relation_id()
+	relation_id621 := _t1234
+	_t1235 := p.parse_abstraction_with_arity()
+	abstraction_with_arity622 := _t1235
+	var _t1236 []*pb.Attribute
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1217 := p.parse_attrs()
-		_t1216 = _t1217
+		_t1237 := p.parse_attrs()
+		_t1236 = _t1237
 	}
-	attrs613 := _t1216
+	attrs623 := _t1236
 	p.consumeLiteral(")")
-	_t1218 := attrs613
-	if attrs613 == nil {
-		_t1218 = []*pb.Attribute{}
+	_t1238 := attrs623
+	if attrs623 == nil {
+		_t1238 = []*pb.Attribute{}
 	}
-	_t1219 := &pb.MonusDef{Monoid: monoid610, Name: relation_id611, Body: abstraction_with_arity612[0].(*pb.Abstraction), Attrs: _t1218, ValueArity: abstraction_with_arity612[1].(int64)}
-	return _t1219
+	_t1239 := &pb.MonusDef{Monoid: monoid620, Name: relation_id621, Body: abstraction_with_arity622[0].(*pb.Abstraction), Attrs: _t1238, ValueArity: abstraction_with_arity622[1].(int64)}
+	return _t1239
 }
 
 func (p *Parser) parse_constraint() *pb.Constraint {
 	p.consumeLiteral("(")
 	p.consumeLiteral("functional_dependency")
-	_t1220 := p.parse_relation_id()
-	relation_id614 := _t1220
-	_t1221 := p.parse_abstraction()
-	abstraction615 := _t1221
-	_t1222 := p.parse_functional_dependency_keys()
-	functional_dependency_keys616 := _t1222
-	_t1223 := p.parse_functional_dependency_values()
-	functional_dependency_values617 := _t1223
+	_t1240 := p.parse_relation_id()
+	relation_id624 := _t1240
+	_t1241 := p.parse_abstraction()
+	abstraction625 := _t1241
+	_t1242 := p.parse_functional_dependency_keys()
+	functional_dependency_keys626 := _t1242
+	_t1243 := p.parse_functional_dependency_values()
+	functional_dependency_values627 := _t1243
 	p.consumeLiteral(")")
-	_t1224 := &pb.FunctionalDependency{Guard: abstraction615, Keys: functional_dependency_keys616, Values: functional_dependency_values617}
-	_t1225 := &pb.Constraint{Name: relation_id614}
-	_t1225.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1224}
-	return _t1225
+	_t1244 := &pb.FunctionalDependency{Guard: abstraction625, Keys: functional_dependency_keys626, Values: functional_dependency_values627}
+	_t1245 := &pb.Constraint{Name: relation_id624}
+	_t1245.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1244}
+	return _t1245
 }
 
 func (p *Parser) parse_functional_dependency_keys() []*pb.Var {
 	p.consumeLiteral("(")
 	p.consumeLiteral("keys")
-	xs618 := []*pb.Var{}
-	cond619 := p.matchLookaheadTerminal("SYMBOL", 0)
-	for cond619 {
-		_t1226 := p.parse_var()
-		item620 := _t1226
-		xs618 = append(xs618, item620)
-		cond619 = p.matchLookaheadTerminal("SYMBOL", 0)
+	xs628 := []*pb.Var{}
+	cond629 := p.matchLookaheadTerminal("SYMBOL", 0)
+	for cond629 {
+		_t1246 := p.parse_var()
+		item630 := _t1246
+		xs628 = append(xs628, item630)
+		cond629 = p.matchLookaheadTerminal("SYMBOL", 0)
 	}
-	vars621 := xs618
+	vars631 := xs628
 	p.consumeLiteral(")")
-	return vars621
+	return vars631
 }
 
 func (p *Parser) parse_functional_dependency_values() []*pb.Var {
 	p.consumeLiteral("(")
 	p.consumeLiteral("values")
-	xs622 := []*pb.Var{}
-	cond623 := p.matchLookaheadTerminal("SYMBOL", 0)
-	for cond623 {
-		_t1227 := p.parse_var()
-		item624 := _t1227
-		xs622 = append(xs622, item624)
-		cond623 = p.matchLookaheadTerminal("SYMBOL", 0)
+	xs632 := []*pb.Var{}
+	cond633 := p.matchLookaheadTerminal("SYMBOL", 0)
+	for cond633 {
+		_t1247 := p.parse_var()
+		item634 := _t1247
+		xs632 = append(xs632, item634)
+		cond633 = p.matchLookaheadTerminal("SYMBOL", 0)
 	}
-	vars625 := xs622
+	vars635 := xs632
 	p.consumeLiteral(")")
-	return vars625
+	return vars635
 }
 
 func (p *Parser) parse_data() *pb.Data {
-	var _t1228 int64
+	var _t1248 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1229 int64
-		if p.matchLookaheadLiteral("rel_edb", 1) {
-			_t1229 = 0
+		var _t1249 int64
+		if p.matchLookaheadLiteral("edb", 1) {
+			_t1249 = 0
 		} else {
-			var _t1230 int64
+			var _t1250 int64
 			if p.matchLookaheadLiteral("csv_data", 1) {
-				_t1230 = 2
+				_t1250 = 2
 			} else {
-				var _t1231 int64
+				var _t1251 int64
 				if p.matchLookaheadLiteral("betree_relation", 1) {
-					_t1231 = 1
+					_t1251 = 1
 				} else {
-					_t1231 = -1
+					_t1251 = -1
 				}
-				_t1230 = _t1231
+				_t1250 = _t1251
 			}
-			_t1229 = _t1230
+			_t1249 = _t1250
 		}
-		_t1228 = _t1229
+		_t1248 = _t1249
 	} else {
-		_t1228 = -1
-	}
-	prediction626 := _t1228
-	var _t1232 *pb.Data
-	if prediction626 == 2 {
-		_t1233 := p.parse_csv_data()
-		csv_data629 := _t1233
-		_t1234 := &pb.Data{}
-		_t1234.DataType = &pb.Data_CsvData{CsvData: csv_data629}
-		_t1232 = _t1234
+		_t1248 = -1
+	}
+	prediction636 := _t1248
+	var _t1252 *pb.Data
+	if prediction636 == 2 {
+		_t1253 := p.parse_csv_data()
+		csv_data639 := _t1253
+		_t1254 := &pb.Data{}
+		_t1254.DataType = &pb.Data_CsvData{CsvData: csv_data639}
+		_t1252 = _t1254
 	} else {
-		var _t1235 *pb.Data
-		if prediction626 == 1 {
-			_t1236 := p.parse_betree_relation()
-			betree_relation628 := _t1236
-			_t1237 := &pb.Data{}
-			_t1237.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation628}
-			_t1235 = _t1237
+		var _t1255 *pb.Data
+		if prediction636 == 1 {
+			_t1256 := p.parse_betree_relation()
+			betree_relation638 := _t1256
+			_t1257 := &pb.Data{}
+			_t1257.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation638}
+			_t1255 = _t1257
 		} else {
-			var _t1238 *pb.Data
-			if prediction626 == 0 {
-				_t1239 := p.parse_rel_edb()
-				rel_edb627 := _t1239
-				_t1240 := &pb.Data{}
-				_t1240.DataType = &pb.Data_RelEdb{RelEdb: rel_edb627}
-				_t1238 = _t1240
+			var _t1258 *pb.Data
+			if prediction636 == 0 {
+				_t1259 := p.parse_edb()
+				edb637 := _t1259
+				_t1260 := &pb.Data{}
+				_t1260.DataType = &pb.Data_Edb{Edb: edb637}
+				_t1258 = _t1260
 			} else {
 				panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)})
 			}
-			_t1235 = _t1238
+			_t1255 = _t1258
 		}
-		_t1232 = _t1235
+		_t1252 = _t1255
 	}
-	return _t1232
+	return _t1252
 }
 
-func (p *Parser) parse_rel_edb() *pb.RelEDB {
+func (p *Parser) parse_edb() *pb.EDB {
 	p.consumeLiteral("(")
-	p.consumeLiteral("rel_edb")
-	_t1241 := p.parse_relation_id()
-	relation_id630 := _t1241
-	_t1242 := p.parse_rel_edb_path()
-	rel_edb_path631 := _t1242
-	_t1243 := p.parse_rel_edb_types()
-	rel_edb_types632 := _t1243
+	p.consumeLiteral("edb")
+	_t1261 := p.parse_relation_id()
+	relation_id640 := _t1261
+	_t1262 := p.parse_edb_path()
+	edb_path641 := _t1262
+	_t1263 := p.parse_edb_types()
+	edb_types642 := _t1263
 	p.consumeLiteral(")")
-	_t1244 := &pb.RelEDB{TargetId: relation_id630, Path: rel_edb_path631, Types: rel_edb_types632}
-	return _t1244
+	_t1264 := &pb.EDB{TargetId: relation_id640, Path: edb_path641, Types: edb_types642}
+	return _t1264
 }
 
-func (p *Parser) parse_rel_edb_path() []string {
+func (p *Parser) parse_edb_path() []string {
 	p.consumeLiteral("[")
-	xs633 := []string{}
-	cond634 := p.matchLookaheadTerminal("STRING", 0)
-	for cond634 {
-		item635 := p.consumeTerminal("STRING").Value.str
-		xs633 = append(xs633, item635)
-		cond634 = p.matchLookaheadTerminal("STRING", 0)
-	}
-	strings636 := xs633
+	xs643 := []string{}
+	cond644 := p.matchLookaheadTerminal("STRING", 0)
+	for cond644 {
+		item645 := p.consumeTerminal("STRING").Value.str
+		xs643 = append(xs643, item645)
+		cond644 = p.matchLookaheadTerminal("STRING", 0)
+	}
+	strings646 := xs643
 	p.consumeLiteral("]")
-	return strings636
+	return strings646
 }
 
-func (p *Parser) parse_rel_edb_types() []*pb.Type {
+func (p *Parser) parse_edb_types() []*pb.Type {
 	p.consumeLiteral("[")
-	xs637 := []*pb.Type{}
-	cond638 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	for cond638 {
-		_t1245 := p.parse_type()
-		item639 := _t1245
-		xs637 = append(xs637, item639)
-		cond638 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	}
-	types640 := xs637
+	xs647 := []*pb.Type{}
+	cond648 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	for cond648 {
+		_t1265 := p.parse_type()
+		item649 := _t1265
+		xs647 = append(xs647, item649)
+		cond648 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	}
+	types650 := xs647
 	p.consumeLiteral("]")
-	return types640
+	return types650
 }
 
 func (p *Parser) parse_betree_relation() *pb.BeTreeRelation {
 	p.consumeLiteral("(")
 	p.consumeLiteral("betree_relation")
-	_t1246 := p.parse_relation_id()
-	relation_id641 := _t1246
-	_t1247 := p.parse_betree_info()
-	betree_info642 := _t1247
+	_t1266 := p.parse_relation_id()
+	relation_id651 := _t1266
+	_t1267 := p.parse_betree_info()
+	betree_info652 := _t1267
 	p.consumeLiteral(")")
-	_t1248 := &pb.BeTreeRelation{Name: relation_id641, RelationInfo: betree_info642}
-	return _t1248
+	_t1268 := &pb.BeTreeRelation{Name: relation_id651, RelationInfo: betree_info652}
+	return _t1268
 }
 
 func (p *Parser) parse_betree_info() *pb.BeTreeInfo {
 	p.consumeLiteral("(")
 	p.consumeLiteral("betree_info")
-	_t1249 := p.parse_betree_info_key_types()
-	betree_info_key_types643 := _t1249
-	_t1250 := p.parse_betree_info_value_types()
-	betree_info_value_types644 := _t1250
-	_t1251 := p.parse_config_dict()
-	config_dict645 := _t1251
-	p.consumeLiteral(")")
-	_t1252 := p.construct_betree_info(betree_info_key_types643, betree_info_value_types644, config_dict645)
-	return _t1252
+	_t1269 := p.parse_betree_info_key_types()
+	betree_info_key_types653 := _t1269
+	_t1270 := p.parse_betree_info_value_types()
+	betree_info_value_types654 := _t1270
+	_t1271 := p.parse_config_dict()
+	config_dict655 := _t1271
+	p.consumeLiteral(")")
+	_t1272 := p.construct_betree_info(betree_info_key_types653, betree_info_value_types654, config_dict655)
+	return _t1272
 }
 
 func (p *Parser) parse_betree_info_key_types() []*pb.Type {
 	p.consumeLiteral("(")
 	p.consumeLiteral("key_types")
-	xs646 := []*pb.Type{}
-	cond647 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	for cond647 {
-		_t1253 := p.parse_type()
-		item648 := _t1253
-		xs646 = append(xs646, item648)
-		cond647 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	xs656 := []*pb.Type{}
+	cond657 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	for cond657 {
+		_t1273 := p.parse_type()
+		item658 := _t1273
+		xs656 = append(xs656, item658)
+		cond657 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
 	}
-	types649 := xs646
+	types659 := xs656
 	p.consumeLiteral(")")
-	return types649
+	return types659
 }
 
 func (p *Parser) parse_betree_info_value_types() []*pb.Type {
 	p.consumeLiteral("(")
 	p.consumeLiteral("value_types")
-	xs650 := []*pb.Type{}
-	cond651 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	for cond651 {
-		_t1254 := p.parse_type()
-		item652 := _t1254
-		xs650 = append(xs650, item652)
-		cond651 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	xs660 := []*pb.Type{}
+	cond661 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	for cond661 {
+		_t1274 := p.parse_type()
+		item662 := _t1274
+		xs660 = append(xs660, item662)
+		cond661 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
 	}
-	types653 := xs650
+	types663 := xs660
 	p.consumeLiteral(")")
-	return types653
+	return types663
 }
 
 func (p *Parser) parse_csv_data() *pb.CSVData {
 	p.consumeLiteral("(")
 	p.consumeLiteral("csv_data")
-	_t1255 := p.parse_csvlocator()
-	csvlocator654 := _t1255
-	_t1256 := p.parse_csv_config()
-	csv_config655 := _t1256
-	_t1257 := p.parse_csv_columns()
-	csv_columns656 := _t1257
-	_t1258 := p.parse_csv_asof()
-	csv_asof657 := _t1258
+	_t1275 := p.parse_csvlocator()
+	csvlocator664 := _t1275
+	_t1276 := p.parse_csv_config()
+	csv_config665 := _t1276
+	_t1277 := p.parse_gnf_columns()
+	gnf_columns666 := _t1277
+	_t1278 := p.parse_csv_asof()
+	csv_asof667 := _t1278
 	p.consumeLiteral(")")
-	_t1259 := &pb.CSVData{Locator: csvlocator654, Config: csv_config655, Columns: csv_columns656, Asof: csv_asof657}
-	return _t1259
+	_t1279 := &pb.CSVData{Locator: csvlocator664, Config: csv_config665, Columns: gnf_columns666, Asof: csv_asof667}
+	return _t1279
 }
 
 func (p *Parser) parse_csvlocator() *pb.CSVLocator {
 	p.consumeLiteral("(")
 	p.consumeLiteral("csv_locator")
-	var _t1260 []string
+	var _t1280 []string
 	if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) {
-		_t1261 := p.parse_csv_locator_paths()
-		_t1260 = _t1261
+		_t1281 := p.parse_csv_locator_paths()
+		_t1280 = _t1281
 	}
-	csv_locator_paths658 := _t1260
-	var _t1262 *string
+	csv_locator_paths668 := _t1280
+	var _t1282 *string
 	if p.matchLookaheadLiteral("(", 0) {
-		_t1263 := p.parse_csv_locator_inline_data()
-		_t1262 = ptr(_t1263)
+		_t1283 := p.parse_csv_locator_inline_data()
+		_t1282 = ptr(_t1283)
 	}
-	csv_locator_inline_data659 := _t1262
+	csv_locator_inline_data669 := _t1282
 	p.consumeLiteral(")")
-	_t1264 := csv_locator_paths658
-	if csv_locator_paths658 == nil {
-		_t1264 = []string{}
+	_t1284 := csv_locator_paths668
+	if csv_locator_paths668 == nil {
+		_t1284 = []string{}
 	}
-	_t1265 := &pb.CSVLocator{Paths: _t1264, InlineData: []byte(deref(csv_locator_inline_data659, ""))}
-	return _t1265
+	_t1285 := &pb.CSVLocator{Paths: _t1284, InlineData: []byte(deref(csv_locator_inline_data669, ""))}
+	return _t1285
 }
 
 func (p *Parser) parse_csv_locator_paths() []string {
 	p.consumeLiteral("(")
 	p.consumeLiteral("paths")
-	xs660 := []string{}
-	cond661 := p.matchLookaheadTerminal("STRING", 0)
-	for cond661 {
-		item662 := p.consumeTerminal("STRING").Value.str
-		xs660 = append(xs660, item662)
-		cond661 = p.matchLookaheadTerminal("STRING", 0)
+	xs670 := []string{}
+	cond671 := p.matchLookaheadTerminal("STRING", 0)
+	for cond671 {
+		item672 := p.consumeTerminal("STRING").Value.str
+		xs670 = append(xs670, item672)
+		cond671 = p.matchLookaheadTerminal("STRING", 0)
 	}
-	strings663 := xs660
+	strings673 := xs670
 	p.consumeLiteral(")")
-	return strings663
+	return strings673
 }
 
 func (p *Parser) parse_csv_locator_inline_data() string {
 	p.consumeLiteral("(")
 	p.consumeLiteral("inline_data")
-	string664 := p.consumeTerminal("STRING").Value.str
+	string674 := p.consumeTerminal("STRING").Value.str
 	p.consumeLiteral(")")
-	return string664
+	return string674
 }
 
 func (p *Parser) parse_csv_config() *pb.CSVConfig {
 	p.consumeLiteral("(")
 	p.consumeLiteral("csv_config")
-	_t1266 := p.parse_config_dict()
-	config_dict665 := _t1266
+	_t1286 := p.parse_config_dict()
+	config_dict675 := _t1286
 	p.consumeLiteral(")")
-	_t1267 := p.construct_csv_config(config_dict665)
-	return _t1267
+	_t1287 := p.construct_csv_config(config_dict675)
+	return _t1287
 }
 
-func (p *Parser) parse_csv_columns() []*pb.CSVColumn {
+func (p *Parser) parse_gnf_columns() []*pb.GNFColumn {
 	p.consumeLiteral("(")
 	p.consumeLiteral("columns")
-	xs666 := []*pb.CSVColumn{}
-	cond667 := p.matchLookaheadLiteral("(", 0)
-	for cond667 {
-		_t1268 := p.parse_csv_column()
-		item668 := _t1268
-		xs666 = append(xs666, item668)
-		cond667 = p.matchLookaheadLiteral("(", 0)
+	xs676 := []*pb.GNFColumn{}
+	cond677 := p.matchLookaheadLiteral("(", 0)
+	for cond677 {
+		_t1288 := p.parse_gnf_column()
+		item678 := _t1288
+		xs676 = append(xs676, item678)
+		cond677 = p.matchLookaheadLiteral("(", 0)
 	}
-	csv_columns669 := xs666
+	gnf_columns679 := xs676
 	p.consumeLiteral(")")
-	return csv_columns669
+	return gnf_columns679
 }
 
-func (p *Parser) parse_csv_column() *pb.CSVColumn {
+func (p *Parser) parse_gnf_column() *pb.GNFColumn {
 	p.consumeLiteral("(")
 	p.consumeLiteral("column")
-	string670 := p.consumeTerminal("STRING").Value.str
-	_t1269 := p.parse_relation_id()
-	relation_id671 := _t1269
+	_t1289 := p.parse_gnf_column_path()
+	gnf_column_path680 := _t1289
+	var _t1290 *pb.RelationId
+	if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) {
+		_t1291 := p.parse_relation_id()
+		_t1290 = _t1291
+	}
+	relation_id681 := _t1290
 	p.consumeLiteral("[")
-	xs672 := []*pb.Type{}
-	cond673 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	for cond673 {
-		_t1270 := p.parse_type()
-		item674 := _t1270
-		xs672 = append(xs672, item674)
-		cond673 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
-	}
-	types675 := xs672
+	xs682 := []*pb.Type{}
+	cond683 := ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	for cond683 {
+		_t1292 := p.parse_type()
+		item684 := _t1292
+		xs682 = append(xs682, item684)
+		cond683 = ((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0))
+	}
+	types685 := xs682
 	p.consumeLiteral("]")
 	p.consumeLiteral(")")
-	_t1271 := &pb.CSVColumn{ColumnName: string670, TargetId: relation_id671, Types: types675}
-	return _t1271
+	_t1293 := &pb.GNFColumn{ColumnPath: gnf_column_path680, TargetId: relation_id681, Types: types685}
+	return _t1293
+}
+
+func (p *Parser) parse_gnf_column_path() []string {
+	var _t1294 int64
+	if p.matchLookaheadLiteral("[", 0) {
+		_t1294 = 1
+	} else {
+		var _t1295 int64
+		if p.matchLookaheadTerminal("STRING", 0) {
+			_t1295 = 0
+		} else {
+			_t1295 = -1
+		}
+		_t1294 = _t1295
+	}
+	prediction686 := _t1294
+	var _t1296 []string
+	if prediction686 == 1 {
+		p.consumeLiteral("[")
+		xs688 := []string{}
+		cond689 := p.matchLookaheadTerminal("STRING", 0)
+		for cond689 {
+			item690 := p.consumeTerminal("STRING").Value.str
+			xs688 = append(xs688, item690)
+			cond689 = p.matchLookaheadTerminal("STRING", 0)
+		}
+		strings691 := xs688
+		p.consumeLiteral("]")
+		_t1296 = strings691
+	} else {
+		var _t1297 []string
+		if prediction686 == 0 {
+			string687 := p.consumeTerminal("STRING").Value.str
+			_ = string687
+			_t1297 = []string{string687}
+		} else {
+			panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)})
+		}
+		_t1296 = _t1297
+	}
+	return _t1296
 }
 
 func (p *Parser) parse_csv_asof() string {
 	p.consumeLiteral("(")
 	p.consumeLiteral("asof")
-	string676 := p.consumeTerminal("STRING").Value.str
+	string692 := p.consumeTerminal("STRING").Value.str
 	p.consumeLiteral(")")
-	return string676
+	return string692
 }
 
 func (p *Parser) parse_undefine() *pb.Undefine {
 	p.consumeLiteral("(")
 	p.consumeLiteral("undefine")
-	_t1272 := p.parse_fragment_id()
-	fragment_id677 := _t1272
+	_t1298 := p.parse_fragment_id()
+	fragment_id693 := _t1298
 	p.consumeLiteral(")")
-	_t1273 := &pb.Undefine{FragmentId: fragment_id677}
-	return _t1273
+	_t1299 := &pb.Undefine{FragmentId: fragment_id693}
+	return _t1299
 }
 
 func (p *Parser) parse_context() *pb.Context {
 	p.consumeLiteral("(")
 	p.consumeLiteral("context")
-	xs678 := []*pb.RelationId{}
-	cond679 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
-	for cond679 {
-		_t1274 := p.parse_relation_id()
-		item680 := _t1274
-		xs678 = append(xs678, item680)
-		cond679 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
+	xs694 := []*pb.RelationId{}
+	cond695 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
+	for cond695 {
+		_t1300 := p.parse_relation_id()
+		item696 := _t1300
+		xs694 = append(xs694, item696)
+		cond695 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0))
 	}
-	relation_ids681 := xs678
+	relation_ids697 := xs694
 	p.consumeLiteral(")")
-	_t1275 := &pb.Context{Relations: relation_ids681}
-	return _t1275
+	_t1301 := &pb.Context{Relations: relation_ids697}
+	return _t1301
 }
 
 func (p *Parser) parse_snapshot() *pb.Snapshot {
 	p.consumeLiteral("(")
 	p.consumeLiteral("snapshot")
-	_t1276 := p.parse_rel_edb_path()
-	rel_edb_path682 := _t1276
-	_t1277 := p.parse_relation_id()
-	relation_id683 := _t1277
+	xs698 := []*pb.SnapshotMapping{}
+	cond699 := p.matchLookaheadLiteral("[", 0)
+	for cond699 {
+		_t1302 := p.parse_snapshot_mapping()
+		item700 := _t1302
+		xs698 = append(xs698, item700)
+		cond699 = p.matchLookaheadLiteral("[", 0)
+	}
+	snapshot_mappings701 := xs698
 	p.consumeLiteral(")")
-	_t1278 := &pb.Snapshot{DestinationPath: rel_edb_path682, SourceRelation: relation_id683}
-	return _t1278
+	_t1303 := &pb.Snapshot{Mappings: snapshot_mappings701}
+	return _t1303
+}
+
+func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping {
+	_t1304 := p.parse_edb_path()
+	edb_path702 := _t1304
+	_t1305 := p.parse_relation_id()
+	relation_id703 := _t1305
+	_t1306 := &pb.SnapshotMapping{DestinationPath: edb_path702, SourceRelation: relation_id703}
+	return _t1306
 }
 
 func (p *Parser) parse_epoch_reads() []*pb.Read {
 	p.consumeLiteral("(")
 	p.consumeLiteral("reads")
-	xs684 := []*pb.Read{}
-	cond685 := p.matchLookaheadLiteral("(", 0)
-	for cond685 {
-		_t1279 := p.parse_read()
-		item686 := _t1279
-		xs684 = append(xs684, item686)
-		cond685 = p.matchLookaheadLiteral("(", 0)
+	xs704 := []*pb.Read{}
+	cond705 := p.matchLookaheadLiteral("(", 0)
+	for cond705 {
+		_t1307 := p.parse_read()
+		item706 := _t1307
+		xs704 = append(xs704, item706)
+		cond705 = p.matchLookaheadLiteral("(", 0)
 	}
-	reads687 := xs684
+	reads707 := xs704
 	p.consumeLiteral(")")
-	return reads687
+	return reads707
 }
 
 func (p *Parser) parse_read() *pb.Read {
-	var _t1280 int64
+	var _t1308 int64
 	if p.matchLookaheadLiteral("(", 0) {
-		var _t1281 int64
+		var _t1309 int64
 		if p.matchLookaheadLiteral("what_if", 1) {
-			_t1281 = 2
+			_t1309 = 2
 		} else {
-			var _t1282 int64
+			var _t1310 int64
 			if p.matchLookaheadLiteral("output", 1) {
-				_t1282 = 1
+				_t1310 = 1
 			} else {
-				var _t1283 int64
+				var _t1311 int64
 				if p.matchLookaheadLiteral("export", 1) {
-					_t1283 = 4
+					_t1311 = 4
 				} else {
-					var _t1284 int64
+					var _t1312 int64
 					if p.matchLookaheadLiteral("demand", 1) {
-						_t1284 = 0
+						_t1312 = 0
 					} else {
-						var _t1285 int64
+						var _t1313 int64
 						if p.matchLookaheadLiteral("abort", 1) {
-							_t1285 = 3
+							_t1313 = 3
 						} else {
-							_t1285 = -1
+							_t1313 = -1
 						}
-						_t1284 = _t1285
+						_t1312 = _t1313
 					}
-					_t1283 = _t1284
+					_t1311 = _t1312
 				}
-				_t1282 = _t1283
+				_t1310 = _t1311
 			}
-			_t1281 = _t1282
+			_t1309 = _t1310
 		}
-		_t1280 = _t1281
+		_t1308 = _t1309
 	} else {
-		_t1280 = -1
-	}
-	prediction688 := _t1280
-	var _t1286 *pb.Read
-	if prediction688 == 4 {
-		_t1287 := p.parse_export()
-		export693 := _t1287
-		_t1288 := &pb.Read{}
-		_t1288.ReadType = &pb.Read_Export{Export: export693}
-		_t1286 = _t1288
+		_t1308 = -1
+	}
+	prediction708 := _t1308
+	var _t1314 *pb.Read
+	if prediction708 == 4 {
+		_t1315 := p.parse_export()
+		export713 := _t1315
+		_t1316 := &pb.Read{}
+		_t1316.ReadType = &pb.Read_Export{Export: export713}
+		_t1314 = _t1316
 	} else {
-		var _t1289 *pb.Read
-		if prediction688 == 3 {
-			_t1290 := p.parse_abort()
-			abort692 := _t1290
-			_t1291 := &pb.Read{}
-			_t1291.ReadType = &pb.Read_Abort{Abort: abort692}
-			_t1289 = _t1291
+		var _t1317 *pb.Read
+		if prediction708 == 3 {
+			_t1318 := p.parse_abort()
+			abort712 := _t1318
+			_t1319 := &pb.Read{}
+			_t1319.ReadType = &pb.Read_Abort{Abort: abort712}
+			_t1317 = _t1319
 		} else {
-			var _t1292 *pb.Read
-			if prediction688 == 2 {
-				_t1293 := p.parse_what_if()
-				what_if691 := _t1293
-				_t1294 := &pb.Read{}
-				_t1294.ReadType = &pb.Read_WhatIf{WhatIf: what_if691}
-				_t1292 = _t1294
+			var _t1320 *pb.Read
+			if prediction708 == 2 {
+				_t1321 := p.parse_what_if()
+				what_if711 := _t1321
+				_t1322 := &pb.Read{}
+				_t1322.ReadType = &pb.Read_WhatIf{WhatIf: what_if711}
+				_t1320 = _t1322
 			} else {
-				var _t1295 *pb.Read
-				if prediction688 == 1 {
-					_t1296 := p.parse_output()
-					output690 := _t1296
-					_t1297 := &pb.Read{}
-					_t1297.ReadType = &pb.Read_Output{Output: output690}
-					_t1295 = _t1297
+				var _t1323 *pb.Read
+				if prediction708 == 1 {
+					_t1324 := p.parse_output()
+					output710 := _t1324
+					_t1325 := &pb.Read{}
+					_t1325.ReadType = &pb.Read_Output{Output: output710}
+					_t1323 = _t1325
 				} else {
-					var _t1298 *pb.Read
-					if prediction688 == 0 {
-						_t1299 := p.parse_demand()
-						demand689 := _t1299
-						_t1300 := &pb.Read{}
-						_t1300.ReadType = &pb.Read_Demand{Demand: demand689}
-						_t1298 = _t1300
+					var _t1326 *pb.Read
+					if prediction708 == 0 {
+						_t1327 := p.parse_demand()
+						demand709 := _t1327
+						_t1328 := &pb.Read{}
+						_t1328.ReadType = &pb.Read_Demand{Demand: demand709}
+						_t1326 = _t1328
 					} else {
 						panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)})
 					}
-					_t1295 = _t1298
+					_t1323 = _t1326
 				}
-				_t1292 = _t1295
+				_t1320 = _t1323
 			}
-			_t1289 = _t1292
+			_t1317 = _t1320
 		}
-		_t1286 = _t1289
+		_t1314 = _t1317
 	}
-	return _t1286
+	return _t1314
 }
 
 func (p *Parser) parse_demand() *pb.Demand {
 	p.consumeLiteral("(")
 	p.consumeLiteral("demand")
-	_t1301 := p.parse_relation_id()
-	relation_id694 := _t1301
+	_t1329 := p.parse_relation_id()
+	relation_id714 := _t1329
 	p.consumeLiteral(")")
-	_t1302 := &pb.Demand{RelationId: relation_id694}
-	return _t1302
+	_t1330 := &pb.Demand{RelationId: relation_id714}
+	return _t1330
 }
 
 func (p *Parser) parse_output() *pb.Output {
 	p.consumeLiteral("(")
 	p.consumeLiteral("output")
-	_t1303 := p.parse_name()
-	name695 := _t1303
-	_t1304 := p.parse_relation_id()
-	relation_id696 := _t1304
+	_t1331 := p.parse_name()
+	name715 := _t1331
+	_t1332 := p.parse_relation_id()
+	relation_id716 := _t1332
 	p.consumeLiteral(")")
-	_t1305 := &pb.Output{Name: name695, RelationId: relation_id696}
-	return _t1305
+	_t1333 := &pb.Output{Name: name715, RelationId: relation_id716}
+	return _t1333
 }
 
 func (p *Parser) parse_what_if() *pb.WhatIf {
 	p.consumeLiteral("(")
 	p.consumeLiteral("what_if")
-	_t1306 := p.parse_name()
-	name697 := _t1306
-	_t1307 := p.parse_epoch()
-	epoch698 := _t1307
+	_t1334 := p.parse_name()
+	name717 := _t1334
+	_t1335 := p.parse_epoch()
+	epoch718 := _t1335
 	p.consumeLiteral(")")
-	_t1308 := &pb.WhatIf{Branch: name697, Epoch: epoch698}
-	return _t1308
+	_t1336 := &pb.WhatIf{Branch: name717, Epoch: epoch718}
+	return _t1336
 }
 
 func (p *Parser) parse_abort() *pb.Abort {
 	p.consumeLiteral("(")
 	p.consumeLiteral("abort")
-	var _t1309 *string
+	var _t1337 *string
 	if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) {
-		_t1310 := p.parse_name()
-		_t1309 = ptr(_t1310)
+		_t1338 := p.parse_name()
+		_t1337 = ptr(_t1338)
 	}
-	name699 := _t1309
-	_t1311 := p.parse_relation_id()
-	relation_id700 := _t1311
+	name719 := _t1337
+	_t1339 := p.parse_relation_id()
+	relation_id720 := _t1339
 	p.consumeLiteral(")")
-	_t1312 := &pb.Abort{Name: deref(name699, "abort"), RelationId: relation_id700}
-	return _t1312
+	_t1340 := &pb.Abort{Name: deref(name719, "abort"), RelationId: relation_id720}
+	return _t1340
 }
 
 func (p *Parser) parse_export() *pb.Export {
 	p.consumeLiteral("(")
 	p.consumeLiteral("export")
-	_t1313 := p.parse_export_csv_config()
-	export_csv_config701 := _t1313
+	_t1341 := p.parse_export_csv_config()
+	export_csv_config721 := _t1341
 	p.consumeLiteral(")")
-	_t1314 := &pb.Export{}
-	_t1314.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config701}
-	return _t1314
+	_t1342 := &pb.Export{}
+	_t1342.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config721}
+	return _t1342
 }
 
 func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig {
 	p.consumeLiteral("(")
 	p.consumeLiteral("export_csv_config")
-	_t1315 := p.parse_export_csv_path()
-	export_csv_path702 := _t1315
-	_t1316 := p.parse_export_csv_columns()
-	export_csv_columns703 := _t1316
-	_t1317 := p.parse_config_dict()
-	config_dict704 := _t1317
+	_t1343 := p.parse_export_csv_path()
+	export_csv_path722 := _t1343
+	_t1344 := p.parse_export_csv_columns()
+	export_csv_columns723 := _t1344
+	_t1345 := p.parse_config_dict()
+	config_dict724 := _t1345
 	p.consumeLiteral(")")
-	_t1318 := p.export_csv_config(export_csv_path702, export_csv_columns703, config_dict704)
-	return _t1318
+	_t1346 := p.export_csv_config(export_csv_path722, export_csv_columns723, config_dict724)
+	return _t1346
 }
 
 func (p *Parser) parse_export_csv_path() string {
 	p.consumeLiteral("(")
 	p.consumeLiteral("path")
-	string705 := p.consumeTerminal("STRING").Value.str
+	string725 := p.consumeTerminal("STRING").Value.str
 	p.consumeLiteral(")")
-	return string705
+	return string725
 }
 
 func (p *Parser) parse_export_csv_columns() []*pb.ExportCSVColumn {
 	p.consumeLiteral("(")
 	p.consumeLiteral("columns")
-	xs706 := []*pb.ExportCSVColumn{}
-	cond707 := p.matchLookaheadLiteral("(", 0)
-	for cond707 {
-		_t1319 := p.parse_export_csv_column()
-		item708 := _t1319
-		xs706 = append(xs706, item708)
-		cond707 = p.matchLookaheadLiteral("(", 0)
+	xs726 := []*pb.ExportCSVColumn{}
+	cond727 := p.matchLookaheadLiteral("(", 0)
+	for cond727 {
+		_t1347 := p.parse_export_csv_column()
+		item728 := _t1347
+		xs726 = append(xs726, item728)
+		cond727 = p.matchLookaheadLiteral("(", 0)
 	}
-	export_csv_columns709 := xs706
+	export_csv_columns729 := xs726
 	p.consumeLiteral(")")
-	return export_csv_columns709
+	return export_csv_columns729
 }
 
 func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn {
 	p.consumeLiteral("(")
 	p.consumeLiteral("column")
-	string710 := p.consumeTerminal("STRING").Value.str
-	_t1320 := p.parse_relation_id()
-	relation_id711 := _t1320
+	string730 := p.consumeTerminal("STRING").Value.str
+	_t1348 := p.parse_relation_id()
+	relation_id731 := _t1348
 	p.consumeLiteral(")")
-	_t1321 := &pb.ExportCSVColumn{ColumnName: string710, ColumnData: relation_id711}
-	return _t1321
+	_t1349 := &pb.ExportCSVColumn{ColumnName: string730, ColumnData: relation_id731}
+	return _t1349
 }
 
 
diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go
index aa674969..4d3a5575 100644
--- a/sdks/go/src/pretty.go
+++ b/sdks/go/src/pretty.go
@@ -311,153 +311,153 @@ func formatBool(b bool) string {
 // --- Helper functions ---
 
 func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value {
-	_t1366 := &pb.Value{}
-	_t1366.Value = &pb.Value_IntValue{IntValue: int64(v)}
-	return _t1366
+	_t1395 := &pb.Value{}
+	_t1395.Value = &pb.Value_IntValue{IntValue: int64(v)}
+	return _t1395
 }
 
 func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value {
-	_t1367 := &pb.Value{}
-	_t1367.Value = &pb.Value_IntValue{IntValue: v}
-	return _t1367
+	_t1396 := &pb.Value{}
+	_t1396.Value = &pb.Value_IntValue{IntValue: v}
+	return _t1396
 }
 
 func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value {
-	_t1368 := &pb.Value{}
-	_t1368.Value = &pb.Value_FloatValue{FloatValue: v}
-	return _t1368
+	_t1397 := &pb.Value{}
+	_t1397.Value = &pb.Value_FloatValue{FloatValue: v}
+	return _t1397
 }
 
 func (p *PrettyPrinter) _make_value_string(v string) *pb.Value {
-	_t1369 := &pb.Value{}
-	_t1369.Value = &pb.Value_StringValue{StringValue: v}
-	return _t1369
+	_t1398 := &pb.Value{}
+	_t1398.Value = &pb.Value_StringValue{StringValue: v}
+	return _t1398
 }
 
 func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value {
-	_t1370 := &pb.Value{}
-	_t1370.Value = &pb.Value_BooleanValue{BooleanValue: v}
-	return _t1370
+	_t1399 := &pb.Value{}
+	_t1399.Value = &pb.Value_BooleanValue{BooleanValue: v}
+	return _t1399
 }
 
 func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value {
-	_t1371 := &pb.Value{}
-	_t1371.Value = &pb.Value_Uint128Value{Uint128Value: v}
-	return _t1371
+	_t1400 := &pb.Value{}
+	_t1400.Value = &pb.Value_Uint128Value{Uint128Value: v}
+	return _t1400
 }
 
 func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} {
 	result := [][]interface{}{}
 	if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO {
-		_t1372 := p._make_value_string("auto")
-		result = append(result, []interface{}{"ivm.maintenance_level", _t1372})
+		_t1401 := p._make_value_string("auto")
+		result = append(result, []interface{}{"ivm.maintenance_level", _t1401})
 	} else {
 		if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL {
-			_t1373 := p._make_value_string("all")
-			result = append(result, []interface{}{"ivm.maintenance_level", _t1373})
+			_t1402 := p._make_value_string("all")
+			result = append(result, []interface{}{"ivm.maintenance_level", _t1402})
 		} else {
 			if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF {
-				_t1374 := p._make_value_string("off")
-				result = append(result, []interface{}{"ivm.maintenance_level", _t1374})
+				_t1403 := p._make_value_string("off")
+				result = append(result, []interface{}{"ivm.maintenance_level", _t1403})
 			}
 		}
 	}
-	_t1375 := p._make_value_int64(msg.GetSemanticsVersion())
-	result = append(result, []interface{}{"semantics_version", _t1375})
+	_t1404 := p._make_value_int64(msg.GetSemanticsVersion())
+	result = append(result, []interface{}{"semantics_version", _t1404})
 	return listSort(result)
 }
 
 func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} {
 	result := [][]interface{}{}
-	_t1376 := p._make_value_int32(msg.GetHeaderRow())
-	result = append(result, []interface{}{"csv_header_row", _t1376})
-	_t1377 := p._make_value_int64(msg.GetSkip())
-	result = append(result, []interface{}{"csv_skip", _t1377})
+	_t1405 := p._make_value_int32(msg.GetHeaderRow())
+	result = append(result, []interface{}{"csv_header_row", _t1405})
+	_t1406 := p._make_value_int64(msg.GetSkip())
+	result = append(result, []interface{}{"csv_skip", _t1406})
 	if msg.GetNewLine() != "" {
-		_t1378 := p._make_value_string(msg.GetNewLine())
-		result = append(result, []interface{}{"csv_new_line", _t1378})
-	}
-	_t1379 := p._make_value_string(msg.GetDelimiter())
-	result = append(result, []interface{}{"csv_delimiter", _t1379})
-	_t1380 := p._make_value_string(msg.GetQuotechar())
-	result = append(result, []interface{}{"csv_quotechar", _t1380})
-	_t1381 := p._make_value_string(msg.GetEscapechar())
-	result = append(result, []interface{}{"csv_escapechar", _t1381})
+		_t1407 := p._make_value_string(msg.GetNewLine())
+		result = append(result, []interface{}{"csv_new_line", _t1407})
+	}
+	_t1408 := p._make_value_string(msg.GetDelimiter())
+	result = append(result, []interface{}{"csv_delimiter", _t1408})
+	_t1409 := p._make_value_string(msg.GetQuotechar())
+	result = append(result, []interface{}{"csv_quotechar", _t1409})
+	_t1410 := p._make_value_string(msg.GetEscapechar())
+	result = append(result, []interface{}{"csv_escapechar", _t1410})
 	if msg.GetComment() != "" {
-		_t1382 := p._make_value_string(msg.GetComment())
-		result = append(result, []interface{}{"csv_comment", _t1382})
+		_t1411 := p._make_value_string(msg.GetComment())
+		result = append(result, []interface{}{"csv_comment", _t1411})
 	}
 	for _, missing_string := range msg.GetMissingStrings() {
-		_t1383 := p._make_value_string(missing_string)
-		result = append(result, []interface{}{"csv_missing_strings", _t1383})
-	}
-	_t1384 := p._make_value_string(msg.GetDecimalSeparator())
-	result = append(result, []interface{}{"csv_decimal_separator", _t1384})
-	_t1385 := p._make_value_string(msg.GetEncoding())
-	result = append(result, []interface{}{"csv_encoding", _t1385})
-	_t1386 := p._make_value_string(msg.GetCompression())
-	result = append(result, []interface{}{"csv_compression", _t1386})
+		_t1412 := p._make_value_string(missing_string)
+		result = append(result, []interface{}{"csv_missing_strings", _t1412})
+	}
+	_t1413 := p._make_value_string(msg.GetDecimalSeparator())
+	result = append(result, []interface{}{"csv_decimal_separator", _t1413})
+	_t1414 := p._make_value_string(msg.GetEncoding())
+	result = append(result, []interface{}{"csv_encoding", _t1414})
+	_t1415 := p._make_value_string(msg.GetCompression())
+	result = append(result, []interface{}{"csv_compression", _t1415})
 	return listSort(result)
 }
 
 func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} {
 	result := [][]interface{}{}
-	_t1387 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon())
-	result = append(result, []interface{}{"betree_config_epsilon", _t1387})
-	_t1388 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots())
-	result = append(result, []interface{}{"betree_config_max_pivots", _t1388})
-	_t1389 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas())
-	result = append(result, []interface{}{"betree_config_max_deltas", _t1389})
-	_t1390 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf())
-	result = append(result, []interface{}{"betree_config_max_leaf", _t1390})
+	_t1416 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon())
+	result = append(result, []interface{}{"betree_config_epsilon", _t1416})
+	_t1417 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots())
+	result = append(result, []interface{}{"betree_config_max_pivots", _t1417})
+	_t1418 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas())
+	result = append(result, []interface{}{"betree_config_max_deltas", _t1418})
+	_t1419 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf())
+	result = append(result, []interface{}{"betree_config_max_leaf", _t1419})
 	if hasProtoField(msg.GetRelationLocator(), "root_pageid") {
 		if msg.GetRelationLocator().GetRootPageid() != nil {
-			_t1391 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid())
-			result = append(result, []interface{}{"betree_locator_root_pageid", _t1391})
+			_t1420 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid())
+			result = append(result, []interface{}{"betree_locator_root_pageid", _t1420})
 		}
 	}
 	if hasProtoField(msg.GetRelationLocator(), "inline_data") {
 		if msg.GetRelationLocator().GetInlineData() != nil {
-			_t1392 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData()))
-			result = append(result, []interface{}{"betree_locator_inline_data", _t1392})
+			_t1421 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData()))
+			result = append(result, []interface{}{"betree_locator_inline_data", _t1421})
 		}
 	}
-	_t1393 := p._make_value_int64(msg.GetRelationLocator().GetElementCount())
-	result = append(result, []interface{}{"betree_locator_element_count", _t1393})
-	_t1394 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight())
-	result = append(result, []interface{}{"betree_locator_tree_height", _t1394})
+	_t1422 := p._make_value_int64(msg.GetRelationLocator().GetElementCount())
+	result = append(result, []interface{}{"betree_locator_element_count", _t1422})
+	_t1423 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight())
+	result = append(result, []interface{}{"betree_locator_tree_height", _t1423})
 	return listSort(result)
 }
 
 func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} {
 	result := [][]interface{}{}
 	if msg.PartitionSize != nil {
-		_t1395 := p._make_value_int64(*msg.PartitionSize)
-		result = append(result, []interface{}{"partition_size", _t1395})
+		_t1424 := p._make_value_int64(*msg.PartitionSize)
+		result = append(result, []interface{}{"partition_size", _t1424})
 	}
 	if msg.Compression != nil {
-		_t1396 := p._make_value_string(*msg.Compression)
-		result = append(result, []interface{}{"compression", _t1396})
+		_t1425 := p._make_value_string(*msg.Compression)
+		result = append(result, []interface{}{"compression", _t1425})
 	}
 	if msg.SyntaxHeaderRow != nil {
-		_t1397 := p._make_value_boolean(*msg.SyntaxHeaderRow)
-		result = append(result, []interface{}{"syntax_header_row", _t1397})
+		_t1426 := p._make_value_boolean(*msg.SyntaxHeaderRow)
+		result = append(result, []interface{}{"syntax_header_row", _t1426})
 	}
 	if msg.SyntaxMissingString != nil {
-		_t1398 := p._make_value_string(*msg.SyntaxMissingString)
-		result = append(result, []interface{}{"syntax_missing_string", _t1398})
+		_t1427 := p._make_value_string(*msg.SyntaxMissingString)
+		result = append(result, []interface{}{"syntax_missing_string", _t1427})
 	}
 	if msg.SyntaxDelim != nil {
-		_t1399 := p._make_value_string(*msg.SyntaxDelim)
-		result = append(result, []interface{}{"syntax_delim", _t1399})
+		_t1428 := p._make_value_string(*msg.SyntaxDelim)
+		result = append(result, []interface{}{"syntax_delim", _t1428})
 	}
 	if msg.SyntaxQuotechar != nil {
-		_t1400 := p._make_value_string(*msg.SyntaxQuotechar)
-		result = append(result, []interface{}{"syntax_quotechar", _t1400})
+		_t1429 := p._make_value_string(*msg.SyntaxQuotechar)
+		result = append(result, []interface{}{"syntax_quotechar", _t1429})
 	}
 	if msg.SyntaxEscapechar != nil {
-		_t1401 := p._make_value_string(*msg.SyntaxEscapechar)
-		result = append(result, []interface{}{"syntax_escapechar", _t1401})
+		_t1430 := p._make_value_string(*msg.SyntaxEscapechar)
+		result = append(result, []interface{}{"syntax_escapechar", _t1430})
 	}
 	return listSort(result)
 }
@@ -469,11 +469,11 @@ func (p *PrettyPrinter) deconstruct_relation_id_string(msg *pb.RelationId) strin
 
 func (p *PrettyPrinter) deconstruct_relation_id_uint128(msg *pb.RelationId) *pb.UInt128Value {
 	name := p.relationIdToString(msg)
-	var _t1402 interface{}
+	var _t1431 interface{}
 	if name == nil {
 		return p.relationIdToUint128(msg)
 	}
-	_ = _t1402
+	_ = _t1431
 	return nil
 }
 
@@ -491,45 +491,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val
 // --- Pretty-print methods ---
 
 func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} {
-	flat638 := p.tryFlat(msg, func() { p.pretty_transaction(msg) })
-	if flat638 != nil {
-		p.write(*flat638)
+	flat651 := p.tryFlat(msg, func() { p.pretty_transaction(msg) })
+	if flat651 != nil {
+		p.write(*flat651)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1258 *pb.Configure
+		var _t1284 *pb.Configure
 		if hasProtoField(_dollar_dollar, "configure") {
-			_t1258 = _dollar_dollar.GetConfigure()
+			_t1284 = _dollar_dollar.GetConfigure()
 		}
-		var _t1259 *pb.Sync
+		var _t1285 *pb.Sync
 		if hasProtoField(_dollar_dollar, "sync") {
-			_t1259 = _dollar_dollar.GetSync()
+			_t1285 = _dollar_dollar.GetSync()
 		}
-		fields629 := []interface{}{_t1258, _t1259, _dollar_dollar.GetEpochs()}
-		unwrapped_fields630 := fields629
+		fields642 := []interface{}{_t1284, _t1285, _dollar_dollar.GetEpochs()}
+		unwrapped_fields643 := fields642
 		p.write("(")
 		p.write("transaction")
 		p.indentSexp()
-		field631 := unwrapped_fields630[0].(*pb.Configure)
-		if field631 != nil {
+		field644 := unwrapped_fields643[0].(*pb.Configure)
+		if field644 != nil {
 			p.newline()
-			opt_val632 := field631
-			p.pretty_configure(opt_val632)
+			opt_val645 := field644
+			p.pretty_configure(opt_val645)
 		}
-		field633 := unwrapped_fields630[1].(*pb.Sync)
-		if field633 != nil {
+		field646 := unwrapped_fields643[1].(*pb.Sync)
+		if field646 != nil {
 			p.newline()
-			opt_val634 := field633
-			p.pretty_sync(opt_val634)
+			opt_val647 := field646
+			p.pretty_sync(opt_val647)
 		}
-		field635 := unwrapped_fields630[2].([]*pb.Epoch)
-		if !(len(field635) == 0) {
+		field648 := unwrapped_fields643[2].([]*pb.Epoch)
+		if !(len(field648) == 0) {
 			p.newline()
-			for i637, elem636 := range field635 {
-				if (i637 > 0) {
+			for i650, elem649 := range field648 {
+				if (i650 > 0) {
 					p.newline()
 				}
-				p.pretty_epoch(elem636)
+				p.pretty_epoch(elem649)
 			}
 		}
 		p.dedent()
@@ -539,20 +539,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} {
-	flat641 := p.tryFlat(msg, func() { p.pretty_configure(msg) })
-	if flat641 != nil {
-		p.write(*flat641)
+	flat654 := p.tryFlat(msg, func() { p.pretty_configure(msg) })
+	if flat654 != nil {
+		p.write(*flat654)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1260 := p.deconstruct_configure(_dollar_dollar)
-		fields639 := _t1260
-		unwrapped_fields640 := fields639
+		_t1286 := p.deconstruct_configure(_dollar_dollar)
+		fields652 := _t1286
+		unwrapped_fields653 := fields652
 		p.write("(")
 		p.write("configure")
 		p.indentSexp()
 		p.newline()
-		p.pretty_config_dict(unwrapped_fields640)
+		p.pretty_config_dict(unwrapped_fields653)
 		p.dedent()
 		p.write(")")
 	}
@@ -560,21 +560,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} {
-	flat645 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) })
-	if flat645 != nil {
-		p.write(*flat645)
+	flat658 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) })
+	if flat658 != nil {
+		p.write(*flat658)
 		return nil
 	} else {
-		fields642 := msg
+		fields655 := msg
 		p.write("{")
 		p.indent()
-		if !(len(fields642) == 0) {
+		if !(len(fields655) == 0) {
 			p.newline()
-			for i644, elem643 := range fields642 {
-				if (i644 > 0) {
+			for i657, elem656 := range fields655 {
+				if (i657 > 0) {
 					p.newline()
 				}
-				p.pretty_config_key_value(elem643)
+				p.pretty_config_key_value(elem656)
 			}
 		}
 		p.dedent()
@@ -584,122 +584,122 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} {
-	flat650 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) })
-	if flat650 != nil {
-		p.write(*flat650)
+	flat663 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) })
+	if flat663 != nil {
+		p.write(*flat663)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields646 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)}
-		unwrapped_fields647 := fields646
+		fields659 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)}
+		unwrapped_fields660 := fields659
 		p.write(":")
-		field648 := unwrapped_fields647[0].(string)
-		p.write(field648)
+		field661 := unwrapped_fields660[0].(string)
+		p.write(field661)
 		p.write(" ")
-		field649 := unwrapped_fields647[1].(*pb.Value)
-		p.pretty_value(field649)
+		field662 := unwrapped_fields660[1].(*pb.Value)
+		p.pretty_value(field662)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} {
-	flat670 := p.tryFlat(msg, func() { p.pretty_value(msg) })
-	if flat670 != nil {
-		p.write(*flat670)
+	flat683 := p.tryFlat(msg, func() { p.pretty_value(msg) })
+	if flat683 != nil {
+		p.write(*flat683)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1261 *pb.DateValue
+		var _t1287 *pb.DateValue
 		if hasProtoField(_dollar_dollar, "date_value") {
-			_t1261 = _dollar_dollar.GetDateValue()
+			_t1287 = _dollar_dollar.GetDateValue()
 		}
-		deconstruct_result668 := _t1261
-		if deconstruct_result668 != nil {
-			unwrapped669 := deconstruct_result668
-			p.pretty_date(unwrapped669)
+		deconstruct_result681 := _t1287
+		if deconstruct_result681 != nil {
+			unwrapped682 := deconstruct_result681
+			p.pretty_date(unwrapped682)
 		} else {
 			_dollar_dollar := msg
-			var _t1262 *pb.DateTimeValue
+			var _t1288 *pb.DateTimeValue
 			if hasProtoField(_dollar_dollar, "datetime_value") {
-				_t1262 = _dollar_dollar.GetDatetimeValue()
+				_t1288 = _dollar_dollar.GetDatetimeValue()
 			}
-			deconstruct_result666 := _t1262
-			if deconstruct_result666 != nil {
-				unwrapped667 := deconstruct_result666
-				p.pretty_datetime(unwrapped667)
+			deconstruct_result679 := _t1288
+			if deconstruct_result679 != nil {
+				unwrapped680 := deconstruct_result679
+				p.pretty_datetime(unwrapped680)
 			} else {
 				_dollar_dollar := msg
-				var _t1263 *string
+				var _t1289 *string
 				if hasProtoField(_dollar_dollar, "string_value") {
-					_t1263 = ptr(_dollar_dollar.GetStringValue())
+					_t1289 = ptr(_dollar_dollar.GetStringValue())
 				}
-				deconstruct_result664 := _t1263
-				if deconstruct_result664 != nil {
-					unwrapped665 := *deconstruct_result664
-					p.write(p.formatStringValue(unwrapped665))
+				deconstruct_result677 := _t1289
+				if deconstruct_result677 != nil {
+					unwrapped678 := *deconstruct_result677
+					p.write(p.formatStringValue(unwrapped678))
 				} else {
 					_dollar_dollar := msg
-					var _t1264 *int64
+					var _t1290 *int64
 					if hasProtoField(_dollar_dollar, "int_value") {
-						_t1264 = ptr(_dollar_dollar.GetIntValue())
+						_t1290 = ptr(_dollar_dollar.GetIntValue())
 					}
-					deconstruct_result662 := _t1264
-					if deconstruct_result662 != nil {
-						unwrapped663 := *deconstruct_result662
-						p.write(fmt.Sprintf("%d", unwrapped663))
+					deconstruct_result675 := _t1290
+					if deconstruct_result675 != nil {
+						unwrapped676 := *deconstruct_result675
+						p.write(fmt.Sprintf("%d", unwrapped676))
 					} else {
 						_dollar_dollar := msg
-						var _t1265 *float64
+						var _t1291 *float64
 						if hasProtoField(_dollar_dollar, "float_value") {
-							_t1265 = ptr(_dollar_dollar.GetFloatValue())
+							_t1291 = ptr(_dollar_dollar.GetFloatValue())
 						}
-						deconstruct_result660 := _t1265
-						if deconstruct_result660 != nil {
-							unwrapped661 := *deconstruct_result660
-							p.write(formatFloat64(unwrapped661))
+						deconstruct_result673 := _t1291
+						if deconstruct_result673 != nil {
+							unwrapped674 := *deconstruct_result673
+							p.write(formatFloat64(unwrapped674))
 						} else {
 							_dollar_dollar := msg
-							var _t1266 *pb.UInt128Value
+							var _t1292 *pb.UInt128Value
 							if hasProtoField(_dollar_dollar, "uint128_value") {
-								_t1266 = _dollar_dollar.GetUint128Value()
+								_t1292 = _dollar_dollar.GetUint128Value()
 							}
-							deconstruct_result658 := _t1266
-							if deconstruct_result658 != nil {
-								unwrapped659 := deconstruct_result658
-								p.write(p.formatUint128(unwrapped659))
+							deconstruct_result671 := _t1292
+							if deconstruct_result671 != nil {
+								unwrapped672 := deconstruct_result671
+								p.write(p.formatUint128(unwrapped672))
 							} else {
 								_dollar_dollar := msg
-								var _t1267 *pb.Int128Value
+								var _t1293 *pb.Int128Value
 								if hasProtoField(_dollar_dollar, "int128_value") {
-									_t1267 = _dollar_dollar.GetInt128Value()
+									_t1293 = _dollar_dollar.GetInt128Value()
 								}
-								deconstruct_result656 := _t1267
-								if deconstruct_result656 != nil {
-									unwrapped657 := deconstruct_result656
-									p.write(p.formatInt128(unwrapped657))
+								deconstruct_result669 := _t1293
+								if deconstruct_result669 != nil {
+									unwrapped670 := deconstruct_result669
+									p.write(p.formatInt128(unwrapped670))
 								} else {
 									_dollar_dollar := msg
-									var _t1268 *pb.DecimalValue
+									var _t1294 *pb.DecimalValue
 									if hasProtoField(_dollar_dollar, "decimal_value") {
-										_t1268 = _dollar_dollar.GetDecimalValue()
+										_t1294 = _dollar_dollar.GetDecimalValue()
 									}
-									deconstruct_result654 := _t1268
-									if deconstruct_result654 != nil {
-										unwrapped655 := deconstruct_result654
-										p.write(p.formatDecimal(unwrapped655))
+									deconstruct_result667 := _t1294
+									if deconstruct_result667 != nil {
+										unwrapped668 := deconstruct_result667
+										p.write(p.formatDecimal(unwrapped668))
 									} else {
 										_dollar_dollar := msg
-										var _t1269 *bool
+										var _t1295 *bool
 										if hasProtoField(_dollar_dollar, "boolean_value") {
-											_t1269 = ptr(_dollar_dollar.GetBooleanValue())
+											_t1295 = ptr(_dollar_dollar.GetBooleanValue())
 										}
-										deconstruct_result652 := _t1269
-										if deconstruct_result652 != nil {
-											unwrapped653 := *deconstruct_result652
-											p.pretty_boolean_value(unwrapped653)
+										deconstruct_result665 := _t1295
+										if deconstruct_result665 != nil {
+											unwrapped666 := *deconstruct_result665
+											p.pretty_boolean_value(unwrapped666)
 										} else {
-											fields651 := msg
-											_ = fields651
+											fields664 := msg
+											_ = fields664
 											p.write("missing")
 										}
 									}
@@ -715,26 +715,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} {
-	flat676 := p.tryFlat(msg, func() { p.pretty_date(msg) })
-	if flat676 != nil {
-		p.write(*flat676)
+	flat689 := p.tryFlat(msg, func() { p.pretty_date(msg) })
+	if flat689 != nil {
+		p.write(*flat689)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields671 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())}
-		unwrapped_fields672 := fields671
+		fields684 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())}
+		unwrapped_fields685 := fields684
 		p.write("(")
 		p.write("date")
 		p.indentSexp()
 		p.newline()
-		field673 := unwrapped_fields672[0].(int64)
-		p.write(fmt.Sprintf("%d", field673))
+		field686 := unwrapped_fields685[0].(int64)
+		p.write(fmt.Sprintf("%d", field686))
 		p.newline()
-		field674 := unwrapped_fields672[1].(int64)
-		p.write(fmt.Sprintf("%d", field674))
+		field687 := unwrapped_fields685[1].(int64)
+		p.write(fmt.Sprintf("%d", field687))
 		p.newline()
-		field675 := unwrapped_fields672[2].(int64)
-		p.write(fmt.Sprintf("%d", field675))
+		field688 := unwrapped_fields685[2].(int64)
+		p.write(fmt.Sprintf("%d", field688))
 		p.dedent()
 		p.write(")")
 	}
@@ -742,40 +742,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} {
-	flat687 := p.tryFlat(msg, func() { p.pretty_datetime(msg) })
-	if flat687 != nil {
-		p.write(*flat687)
+	flat700 := p.tryFlat(msg, func() { p.pretty_datetime(msg) })
+	if flat700 != nil {
+		p.write(*flat700)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields677 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))}
-		unwrapped_fields678 := fields677
+		fields690 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))}
+		unwrapped_fields691 := fields690
 		p.write("(")
 		p.write("datetime")
 		p.indentSexp()
 		p.newline()
-		field679 := unwrapped_fields678[0].(int64)
-		p.write(fmt.Sprintf("%d", field679))
+		field692 := unwrapped_fields691[0].(int64)
+		p.write(fmt.Sprintf("%d", field692))
 		p.newline()
-		field680 := unwrapped_fields678[1].(int64)
-		p.write(fmt.Sprintf("%d", field680))
+		field693 := unwrapped_fields691[1].(int64)
+		p.write(fmt.Sprintf("%d", field693))
 		p.newline()
-		field681 := unwrapped_fields678[2].(int64)
-		p.write(fmt.Sprintf("%d", field681))
+		field694 := unwrapped_fields691[2].(int64)
+		p.write(fmt.Sprintf("%d", field694))
 		p.newline()
-		field682 := unwrapped_fields678[3].(int64)
-		p.write(fmt.Sprintf("%d", field682))
+		field695 := unwrapped_fields691[3].(int64)
+		p.write(fmt.Sprintf("%d", field695))
 		p.newline()
-		field683 := unwrapped_fields678[4].(int64)
-		p.write(fmt.Sprintf("%d", field683))
+		field696 := unwrapped_fields691[4].(int64)
+		p.write(fmt.Sprintf("%d", field696))
 		p.newline()
-		field684 := unwrapped_fields678[5].(int64)
-		p.write(fmt.Sprintf("%d", field684))
-		field685 := unwrapped_fields678[6].(*int64)
-		if field685 != nil {
+		field697 := unwrapped_fields691[5].(int64)
+		p.write(fmt.Sprintf("%d", field697))
+		field698 := unwrapped_fields691[6].(*int64)
+		if field698 != nil {
 			p.newline()
-			opt_val686 := *field685
-			p.write(fmt.Sprintf("%d", opt_val686))
+			opt_val699 := *field698
+			p.write(fmt.Sprintf("%d", opt_val699))
 		}
 		p.dedent()
 		p.write(")")
@@ -785,25 +785,25 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} {
 
 func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} {
 	_dollar_dollar := msg
-	var _t1270 []interface{}
+	var _t1296 []interface{}
 	if _dollar_dollar {
-		_t1270 = []interface{}{}
+		_t1296 = []interface{}{}
 	}
-	deconstruct_result690 := _t1270
-	if deconstruct_result690 != nil {
-		unwrapped691 := deconstruct_result690
-		_ = unwrapped691
+	deconstruct_result703 := _t1296
+	if deconstruct_result703 != nil {
+		unwrapped704 := deconstruct_result703
+		_ = unwrapped704
 		p.write("true")
 	} else {
 		_dollar_dollar := msg
-		var _t1271 []interface{}
+		var _t1297 []interface{}
 		if !(_dollar_dollar) {
-			_t1271 = []interface{}{}
+			_t1297 = []interface{}{}
 		}
-		deconstruct_result688 := _t1271
-		if deconstruct_result688 != nil {
-			unwrapped689 := deconstruct_result688
-			_ = unwrapped689
+		deconstruct_result701 := _t1297
+		if deconstruct_result701 != nil {
+			unwrapped702 := deconstruct_result701
+			_ = unwrapped702
 			p.write("false")
 		} else {
 			panic(ParseError{msg: "No matching rule for boolean_value"})
@@ -813,24 +813,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} {
-	flat696 := p.tryFlat(msg, func() { p.pretty_sync(msg) })
-	if flat696 != nil {
-		p.write(*flat696)
+	flat709 := p.tryFlat(msg, func() { p.pretty_sync(msg) })
+	if flat709 != nil {
+		p.write(*flat709)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields692 := _dollar_dollar.GetFragments()
-		unwrapped_fields693 := fields692
+		fields705 := _dollar_dollar.GetFragments()
+		unwrapped_fields706 := fields705
 		p.write("(")
 		p.write("sync")
 		p.indentSexp()
-		if !(len(unwrapped_fields693) == 0) {
+		if !(len(unwrapped_fields706) == 0) {
 			p.newline()
-			for i695, elem694 := range unwrapped_fields693 {
-				if (i695 > 0) {
+			for i708, elem707 := range unwrapped_fields706 {
+				if (i708 > 0) {
 					p.newline()
 				}
-				p.pretty_fragment_id(elem694)
+				p.pretty_fragment_id(elem707)
 			}
 		}
 		p.dedent()
@@ -840,51 +840,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} {
-	flat699 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) })
-	if flat699 != nil {
-		p.write(*flat699)
+	flat712 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) })
+	if flat712 != nil {
+		p.write(*flat712)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields697 := p.fragmentIdToString(_dollar_dollar)
-		unwrapped_fields698 := fields697
+		fields710 := p.fragmentIdToString(_dollar_dollar)
+		unwrapped_fields711 := fields710
 		p.write(":")
-		p.write(unwrapped_fields698)
+		p.write(unwrapped_fields711)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} {
-	flat706 := p.tryFlat(msg, func() { p.pretty_epoch(msg) })
-	if flat706 != nil {
-		p.write(*flat706)
+	flat719 := p.tryFlat(msg, func() { p.pretty_epoch(msg) })
+	if flat719 != nil {
+		p.write(*flat719)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1272 []*pb.Write
+		var _t1298 []*pb.Write
 		if !(len(_dollar_dollar.GetWrites()) == 0) {
-			_t1272 = _dollar_dollar.GetWrites()
+			_t1298 = _dollar_dollar.GetWrites()
 		}
-		var _t1273 []*pb.Read
+		var _t1299 []*pb.Read
 		if !(len(_dollar_dollar.GetReads()) == 0) {
-			_t1273 = _dollar_dollar.GetReads()
+			_t1299 = _dollar_dollar.GetReads()
 		}
-		fields700 := []interface{}{_t1272, _t1273}
-		unwrapped_fields701 := fields700
+		fields713 := []interface{}{_t1298, _t1299}
+		unwrapped_fields714 := fields713
 		p.write("(")
 		p.write("epoch")
 		p.indentSexp()
-		field702 := unwrapped_fields701[0].([]*pb.Write)
-		if field702 != nil {
+		field715 := unwrapped_fields714[0].([]*pb.Write)
+		if field715 != nil {
 			p.newline()
-			opt_val703 := field702
-			p.pretty_epoch_writes(opt_val703)
+			opt_val716 := field715
+			p.pretty_epoch_writes(opt_val716)
 		}
-		field704 := unwrapped_fields701[1].([]*pb.Read)
-		if field704 != nil {
+		field717 := unwrapped_fields714[1].([]*pb.Read)
+		if field717 != nil {
 			p.newline()
-			opt_val705 := field704
-			p.pretty_epoch_reads(opt_val705)
+			opt_val718 := field717
+			p.pretty_epoch_reads(opt_val718)
 		}
 		p.dedent()
 		p.write(")")
@@ -893,22 +893,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} {
-	flat710 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) })
-	if flat710 != nil {
-		p.write(*flat710)
+	flat723 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) })
+	if flat723 != nil {
+		p.write(*flat723)
 		return nil
 	} else {
-		fields707 := msg
+		fields720 := msg
 		p.write("(")
 		p.write("writes")
 		p.indentSexp()
-		if !(len(fields707) == 0) {
+		if !(len(fields720) == 0) {
 			p.newline()
-			for i709, elem708 := range fields707 {
-				if (i709 > 0) {
+			for i722, elem721 := range fields720 {
+				if (i722 > 0) {
 					p.newline()
 				}
-				p.pretty_write(elem708)
+				p.pretty_write(elem721)
 			}
 		}
 		p.dedent()
@@ -918,50 +918,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} {
-	flat719 := p.tryFlat(msg, func() { p.pretty_write(msg) })
-	if flat719 != nil {
-		p.write(*flat719)
+	flat732 := p.tryFlat(msg, func() { p.pretty_write(msg) })
+	if flat732 != nil {
+		p.write(*flat732)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1274 *pb.Define
+		var _t1300 *pb.Define
 		if hasProtoField(_dollar_dollar, "define") {
-			_t1274 = _dollar_dollar.GetDefine()
+			_t1300 = _dollar_dollar.GetDefine()
 		}
-		deconstruct_result717 := _t1274
-		if deconstruct_result717 != nil {
-			unwrapped718 := deconstruct_result717
-			p.pretty_define(unwrapped718)
+		deconstruct_result730 := _t1300
+		if deconstruct_result730 != nil {
+			unwrapped731 := deconstruct_result730
+			p.pretty_define(unwrapped731)
 		} else {
 			_dollar_dollar := msg
-			var _t1275 *pb.Undefine
+			var _t1301 *pb.Undefine
 			if hasProtoField(_dollar_dollar, "undefine") {
-				_t1275 = _dollar_dollar.GetUndefine()
+				_t1301 = _dollar_dollar.GetUndefine()
 			}
-			deconstruct_result715 := _t1275
-			if deconstruct_result715 != nil {
-				unwrapped716 := deconstruct_result715
-				p.pretty_undefine(unwrapped716)
+			deconstruct_result728 := _t1301
+			if deconstruct_result728 != nil {
+				unwrapped729 := deconstruct_result728
+				p.pretty_undefine(unwrapped729)
 			} else {
 				_dollar_dollar := msg
-				var _t1276 *pb.Context
+				var _t1302 *pb.Context
 				if hasProtoField(_dollar_dollar, "context") {
-					_t1276 = _dollar_dollar.GetContext()
+					_t1302 = _dollar_dollar.GetContext()
 				}
-				deconstruct_result713 := _t1276
-				if deconstruct_result713 != nil {
-					unwrapped714 := deconstruct_result713
-					p.pretty_context(unwrapped714)
+				deconstruct_result726 := _t1302
+				if deconstruct_result726 != nil {
+					unwrapped727 := deconstruct_result726
+					p.pretty_context(unwrapped727)
 				} else {
 					_dollar_dollar := msg
-					var _t1277 *pb.Snapshot
+					var _t1303 *pb.Snapshot
 					if hasProtoField(_dollar_dollar, "snapshot") {
-						_t1277 = _dollar_dollar.GetSnapshot()
+						_t1303 = _dollar_dollar.GetSnapshot()
 					}
-					deconstruct_result711 := _t1277
-					if deconstruct_result711 != nil {
-						unwrapped712 := deconstruct_result711
-						p.pretty_snapshot(unwrapped712)
+					deconstruct_result724 := _t1303
+					if deconstruct_result724 != nil {
+						unwrapped725 := deconstruct_result724
+						p.pretty_snapshot(unwrapped725)
 					} else {
 						panic(ParseError{msg: "No matching rule for write"})
 					}
@@ -973,19 +973,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} {
-	flat722 := p.tryFlat(msg, func() { p.pretty_define(msg) })
-	if flat722 != nil {
-		p.write(*flat722)
+	flat735 := p.tryFlat(msg, func() { p.pretty_define(msg) })
+	if flat735 != nil {
+		p.write(*flat735)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields720 := _dollar_dollar.GetFragment()
-		unwrapped_fields721 := fields720
+		fields733 := _dollar_dollar.GetFragment()
+		unwrapped_fields734 := fields733
 		p.write("(")
 		p.write("define")
 		p.indentSexp()
 		p.newline()
-		p.pretty_fragment(unwrapped_fields721)
+		p.pretty_fragment(unwrapped_fields734)
 		p.dedent()
 		p.write(")")
 	}
@@ -993,29 +993,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} {
-	flat729 := p.tryFlat(msg, func() { p.pretty_fragment(msg) })
-	if flat729 != nil {
-		p.write(*flat729)
+	flat742 := p.tryFlat(msg, func() { p.pretty_fragment(msg) })
+	if flat742 != nil {
+		p.write(*flat742)
 		return nil
 	} else {
 		_dollar_dollar := msg
 		p.startPrettyFragment(_dollar_dollar)
-		fields723 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()}
-		unwrapped_fields724 := fields723
+		fields736 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()}
+		unwrapped_fields737 := fields736
 		p.write("(")
 		p.write("fragment")
 		p.indentSexp()
 		p.newline()
-		field725 := unwrapped_fields724[0].(*pb.FragmentId)
-		p.pretty_new_fragment_id(field725)
-		field726 := unwrapped_fields724[1].([]*pb.Declaration)
-		if !(len(field726) == 0) {
+		field738 := unwrapped_fields737[0].(*pb.FragmentId)
+		p.pretty_new_fragment_id(field738)
+		field739 := unwrapped_fields737[1].([]*pb.Declaration)
+		if !(len(field739) == 0) {
 			p.newline()
-			for i728, elem727 := range field726 {
-				if (i728 > 0) {
+			for i741, elem740 := range field739 {
+				if (i741 > 0) {
 					p.newline()
 				}
-				p.pretty_declaration(elem727)
+				p.pretty_declaration(elem740)
 			}
 		}
 		p.dedent()
@@ -1025,62 +1025,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} {
-	flat731 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) })
-	if flat731 != nil {
-		p.write(*flat731)
+	flat744 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) })
+	if flat744 != nil {
+		p.write(*flat744)
 		return nil
 	} else {
-		fields730 := msg
-		p.pretty_fragment_id(fields730)
+		fields743 := msg
+		p.pretty_fragment_id(fields743)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} {
-	flat740 := p.tryFlat(msg, func() { p.pretty_declaration(msg) })
-	if flat740 != nil {
-		p.write(*flat740)
+	flat753 := p.tryFlat(msg, func() { p.pretty_declaration(msg) })
+	if flat753 != nil {
+		p.write(*flat753)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1278 *pb.Def
+		var _t1304 *pb.Def
 		if hasProtoField(_dollar_dollar, "def") {
-			_t1278 = _dollar_dollar.GetDef()
+			_t1304 = _dollar_dollar.GetDef()
 		}
-		deconstruct_result738 := _t1278
-		if deconstruct_result738 != nil {
-			unwrapped739 := deconstruct_result738
-			p.pretty_def(unwrapped739)
+		deconstruct_result751 := _t1304
+		if deconstruct_result751 != nil {
+			unwrapped752 := deconstruct_result751
+			p.pretty_def(unwrapped752)
 		} else {
 			_dollar_dollar := msg
-			var _t1279 *pb.Algorithm
+			var _t1305 *pb.Algorithm
 			if hasProtoField(_dollar_dollar, "algorithm") {
-				_t1279 = _dollar_dollar.GetAlgorithm()
+				_t1305 = _dollar_dollar.GetAlgorithm()
 			}
-			deconstruct_result736 := _t1279
-			if deconstruct_result736 != nil {
-				unwrapped737 := deconstruct_result736
-				p.pretty_algorithm(unwrapped737)
+			deconstruct_result749 := _t1305
+			if deconstruct_result749 != nil {
+				unwrapped750 := deconstruct_result749
+				p.pretty_algorithm(unwrapped750)
 			} else {
 				_dollar_dollar := msg
-				var _t1280 *pb.Constraint
+				var _t1306 *pb.Constraint
 				if hasProtoField(_dollar_dollar, "constraint") {
-					_t1280 = _dollar_dollar.GetConstraint()
+					_t1306 = _dollar_dollar.GetConstraint()
 				}
-				deconstruct_result734 := _t1280
-				if deconstruct_result734 != nil {
-					unwrapped735 := deconstruct_result734
-					p.pretty_constraint(unwrapped735)
+				deconstruct_result747 := _t1306
+				if deconstruct_result747 != nil {
+					unwrapped748 := deconstruct_result747
+					p.pretty_constraint(unwrapped748)
 				} else {
 					_dollar_dollar := msg
-					var _t1281 *pb.Data
+					var _t1307 *pb.Data
 					if hasProtoField(_dollar_dollar, "data") {
-						_t1281 = _dollar_dollar.GetData()
+						_t1307 = _dollar_dollar.GetData()
 					}
-					deconstruct_result732 := _t1281
-					if deconstruct_result732 != nil {
-						unwrapped733 := deconstruct_result732
-						p.pretty_data(unwrapped733)
+					deconstruct_result745 := _t1307
+					if deconstruct_result745 != nil {
+						unwrapped746 := deconstruct_result745
+						p.pretty_data(unwrapped746)
 					} else {
 						panic(ParseError{msg: "No matching rule for declaration"})
 					}
@@ -1092,32 +1092,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} {
-	flat747 := p.tryFlat(msg, func() { p.pretty_def(msg) })
-	if flat747 != nil {
-		p.write(*flat747)
+	flat760 := p.tryFlat(msg, func() { p.pretty_def(msg) })
+	if flat760 != nil {
+		p.write(*flat760)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1282 []*pb.Attribute
+		var _t1308 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1282 = _dollar_dollar.GetAttrs()
+			_t1308 = _dollar_dollar.GetAttrs()
 		}
-		fields741 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1282}
-		unwrapped_fields742 := fields741
+		fields754 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1308}
+		unwrapped_fields755 := fields754
 		p.write("(")
 		p.write("def")
 		p.indentSexp()
 		p.newline()
-		field743 := unwrapped_fields742[0].(*pb.RelationId)
-		p.pretty_relation_id(field743)
+		field756 := unwrapped_fields755[0].(*pb.RelationId)
+		p.pretty_relation_id(field756)
 		p.newline()
-		field744 := unwrapped_fields742[1].(*pb.Abstraction)
-		p.pretty_abstraction(field744)
-		field745 := unwrapped_fields742[2].([]*pb.Attribute)
-		if field745 != nil {
+		field757 := unwrapped_fields755[1].(*pb.Abstraction)
+		p.pretty_abstraction(field757)
+		field758 := unwrapped_fields755[2].([]*pb.Attribute)
+		if field758 != nil {
 			p.newline()
-			opt_val746 := field745
-			p.pretty_attrs(opt_val746)
+			opt_val759 := field758
+			p.pretty_attrs(opt_val759)
 		}
 		p.dedent()
 		p.write(")")
@@ -1126,29 +1126,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} {
-	flat752 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) })
-	if flat752 != nil {
-		p.write(*flat752)
+	flat765 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) })
+	if flat765 != nil {
+		p.write(*flat765)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1283 *string
+		var _t1309 *string
 		if p.relationIdToString(_dollar_dollar) != nil {
-			_t1284 := p.deconstruct_relation_id_string(_dollar_dollar)
-			_t1283 = ptr(_t1284)
+			_t1310 := p.deconstruct_relation_id_string(_dollar_dollar)
+			_t1309 = ptr(_t1310)
 		}
-		deconstruct_result750 := _t1283
-		if deconstruct_result750 != nil {
-			unwrapped751 := *deconstruct_result750
+		deconstruct_result763 := _t1309
+		if deconstruct_result763 != nil {
+			unwrapped764 := *deconstruct_result763
 			p.write(":")
-			p.write(unwrapped751)
+			p.write(unwrapped764)
 		} else {
 			_dollar_dollar := msg
-			_t1285 := p.deconstruct_relation_id_uint128(_dollar_dollar)
-			deconstruct_result748 := _t1285
-			if deconstruct_result748 != nil {
-				unwrapped749 := deconstruct_result748
-				p.write(p.formatUint128(unwrapped749))
+			_t1311 := p.deconstruct_relation_id_uint128(_dollar_dollar)
+			deconstruct_result761 := _t1311
+			if deconstruct_result761 != nil {
+				unwrapped762 := deconstruct_result761
+				p.write(p.formatUint128(unwrapped762))
 			} else {
 				panic(ParseError{msg: "No matching rule for relation_id"})
 			}
@@ -1158,22 +1158,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} {
-	flat757 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) })
-	if flat757 != nil {
-		p.write(*flat757)
+	flat770 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) })
+	if flat770 != nil {
+		p.write(*flat770)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1286 := p.deconstruct_bindings(_dollar_dollar)
-		fields753 := []interface{}{_t1286, _dollar_dollar.GetValue()}
-		unwrapped_fields754 := fields753
+		_t1312 := p.deconstruct_bindings(_dollar_dollar)
+		fields766 := []interface{}{_t1312, _dollar_dollar.GetValue()}
+		unwrapped_fields767 := fields766
 		p.write("(")
 		p.indent()
-		field755 := unwrapped_fields754[0].([]interface{})
-		p.pretty_bindings(field755)
+		field768 := unwrapped_fields767[0].([]interface{})
+		p.pretty_bindings(field768)
 		p.newline()
-		field756 := unwrapped_fields754[1].(*pb.Formula)
-		p.pretty_formula(field756)
+		field769 := unwrapped_fields767[1].(*pb.Formula)
+		p.pretty_formula(field769)
 		p.dedent()
 		p.write(")")
 	}
@@ -1181,32 +1181,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} {
-	flat765 := p.tryFlat(msg, func() { p.pretty_bindings(msg) })
-	if flat765 != nil {
-		p.write(*flat765)
+	flat778 := p.tryFlat(msg, func() { p.pretty_bindings(msg) })
+	if flat778 != nil {
+		p.write(*flat778)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1287 []*pb.Binding
+		var _t1313 []*pb.Binding
 		if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) {
-			_t1287 = _dollar_dollar[1].([]*pb.Binding)
+			_t1313 = _dollar_dollar[1].([]*pb.Binding)
 		}
-		fields758 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1287}
-		unwrapped_fields759 := fields758
+		fields771 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1313}
+		unwrapped_fields772 := fields771
 		p.write("[")
 		p.indent()
-		field760 := unwrapped_fields759[0].([]*pb.Binding)
-		for i762, elem761 := range field760 {
-			if (i762 > 0) {
+		field773 := unwrapped_fields772[0].([]*pb.Binding)
+		for i775, elem774 := range field773 {
+			if (i775 > 0) {
 				p.newline()
 			}
-			p.pretty_binding(elem761)
+			p.pretty_binding(elem774)
 		}
-		field763 := unwrapped_fields759[1].([]*pb.Binding)
-		if field763 != nil {
+		field776 := unwrapped_fields772[1].([]*pb.Binding)
+		if field776 != nil {
 			p.newline()
-			opt_val764 := field763
-			p.pretty_value_bindings(opt_val764)
+			opt_val777 := field776
+			p.pretty_value_bindings(opt_val777)
 		}
 		p.dedent()
 		p.write("]")
@@ -1215,138 +1215,138 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} {
-	flat770 := p.tryFlat(msg, func() { p.pretty_binding(msg) })
-	if flat770 != nil {
-		p.write(*flat770)
+	flat783 := p.tryFlat(msg, func() { p.pretty_binding(msg) })
+	if flat783 != nil {
+		p.write(*flat783)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields766 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()}
-		unwrapped_fields767 := fields766
-		field768 := unwrapped_fields767[0].(string)
-		p.write(field768)
+		fields779 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()}
+		unwrapped_fields780 := fields779
+		field781 := unwrapped_fields780[0].(string)
+		p.write(field781)
 		p.write("::")
-		field769 := unwrapped_fields767[1].(*pb.Type)
-		p.pretty_type(field769)
+		field782 := unwrapped_fields780[1].(*pb.Type)
+		p.pretty_type(field782)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} {
-	flat793 := p.tryFlat(msg, func() { p.pretty_type(msg) })
-	if flat793 != nil {
-		p.write(*flat793)
+	flat806 := p.tryFlat(msg, func() { p.pretty_type(msg) })
+	if flat806 != nil {
+		p.write(*flat806)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1288 *pb.UnspecifiedType
+		var _t1314 *pb.UnspecifiedType
 		if hasProtoField(_dollar_dollar, "unspecified_type") {
-			_t1288 = _dollar_dollar.GetUnspecifiedType()
+			_t1314 = _dollar_dollar.GetUnspecifiedType()
 		}
-		deconstruct_result791 := _t1288
-		if deconstruct_result791 != nil {
-			unwrapped792 := deconstruct_result791
-			p.pretty_unspecified_type(unwrapped792)
+		deconstruct_result804 := _t1314
+		if deconstruct_result804 != nil {
+			unwrapped805 := deconstruct_result804
+			p.pretty_unspecified_type(unwrapped805)
 		} else {
 			_dollar_dollar := msg
-			var _t1289 *pb.StringType
+			var _t1315 *pb.StringType
 			if hasProtoField(_dollar_dollar, "string_type") {
-				_t1289 = _dollar_dollar.GetStringType()
+				_t1315 = _dollar_dollar.GetStringType()
 			}
-			deconstruct_result789 := _t1289
-			if deconstruct_result789 != nil {
-				unwrapped790 := deconstruct_result789
-				p.pretty_string_type(unwrapped790)
+			deconstruct_result802 := _t1315
+			if deconstruct_result802 != nil {
+				unwrapped803 := deconstruct_result802
+				p.pretty_string_type(unwrapped803)
 			} else {
 				_dollar_dollar := msg
-				var _t1290 *pb.IntType
+				var _t1316 *pb.IntType
 				if hasProtoField(_dollar_dollar, "int_type") {
-					_t1290 = _dollar_dollar.GetIntType()
+					_t1316 = _dollar_dollar.GetIntType()
 				}
-				deconstruct_result787 := _t1290
-				if deconstruct_result787 != nil {
-					unwrapped788 := deconstruct_result787
-					p.pretty_int_type(unwrapped788)
+				deconstruct_result800 := _t1316
+				if deconstruct_result800 != nil {
+					unwrapped801 := deconstruct_result800
+					p.pretty_int_type(unwrapped801)
 				} else {
 					_dollar_dollar := msg
-					var _t1291 *pb.FloatType
+					var _t1317 *pb.FloatType
 					if hasProtoField(_dollar_dollar, "float_type") {
-						_t1291 = _dollar_dollar.GetFloatType()
+						_t1317 = _dollar_dollar.GetFloatType()
 					}
-					deconstruct_result785 := _t1291
-					if deconstruct_result785 != nil {
-						unwrapped786 := deconstruct_result785
-						p.pretty_float_type(unwrapped786)
+					deconstruct_result798 := _t1317
+					if deconstruct_result798 != nil {
+						unwrapped799 := deconstruct_result798
+						p.pretty_float_type(unwrapped799)
 					} else {
 						_dollar_dollar := msg
-						var _t1292 *pb.UInt128Type
+						var _t1318 *pb.UInt128Type
 						if hasProtoField(_dollar_dollar, "uint128_type") {
-							_t1292 = _dollar_dollar.GetUint128Type()
+							_t1318 = _dollar_dollar.GetUint128Type()
 						}
-						deconstruct_result783 := _t1292
-						if deconstruct_result783 != nil {
-							unwrapped784 := deconstruct_result783
-							p.pretty_uint128_type(unwrapped784)
+						deconstruct_result796 := _t1318
+						if deconstruct_result796 != nil {
+							unwrapped797 := deconstruct_result796
+							p.pretty_uint128_type(unwrapped797)
 						} else {
 							_dollar_dollar := msg
-							var _t1293 *pb.Int128Type
+							var _t1319 *pb.Int128Type
 							if hasProtoField(_dollar_dollar, "int128_type") {
-								_t1293 = _dollar_dollar.GetInt128Type()
+								_t1319 = _dollar_dollar.GetInt128Type()
 							}
-							deconstruct_result781 := _t1293
-							if deconstruct_result781 != nil {
-								unwrapped782 := deconstruct_result781
-								p.pretty_int128_type(unwrapped782)
+							deconstruct_result794 := _t1319
+							if deconstruct_result794 != nil {
+								unwrapped795 := deconstruct_result794
+								p.pretty_int128_type(unwrapped795)
 							} else {
 								_dollar_dollar := msg
-								var _t1294 *pb.DateType
+								var _t1320 *pb.DateType
 								if hasProtoField(_dollar_dollar, "date_type") {
-									_t1294 = _dollar_dollar.GetDateType()
+									_t1320 = _dollar_dollar.GetDateType()
 								}
-								deconstruct_result779 := _t1294
-								if deconstruct_result779 != nil {
-									unwrapped780 := deconstruct_result779
-									p.pretty_date_type(unwrapped780)
+								deconstruct_result792 := _t1320
+								if deconstruct_result792 != nil {
+									unwrapped793 := deconstruct_result792
+									p.pretty_date_type(unwrapped793)
 								} else {
 									_dollar_dollar := msg
-									var _t1295 *pb.DateTimeType
+									var _t1321 *pb.DateTimeType
 									if hasProtoField(_dollar_dollar, "datetime_type") {
-										_t1295 = _dollar_dollar.GetDatetimeType()
+										_t1321 = _dollar_dollar.GetDatetimeType()
 									}
-									deconstruct_result777 := _t1295
-									if deconstruct_result777 != nil {
-										unwrapped778 := deconstruct_result777
-										p.pretty_datetime_type(unwrapped778)
+									deconstruct_result790 := _t1321
+									if deconstruct_result790 != nil {
+										unwrapped791 := deconstruct_result790
+										p.pretty_datetime_type(unwrapped791)
 									} else {
 										_dollar_dollar := msg
-										var _t1296 *pb.MissingType
+										var _t1322 *pb.MissingType
 										if hasProtoField(_dollar_dollar, "missing_type") {
-											_t1296 = _dollar_dollar.GetMissingType()
+											_t1322 = _dollar_dollar.GetMissingType()
 										}
-										deconstruct_result775 := _t1296
-										if deconstruct_result775 != nil {
-											unwrapped776 := deconstruct_result775
-											p.pretty_missing_type(unwrapped776)
+										deconstruct_result788 := _t1322
+										if deconstruct_result788 != nil {
+											unwrapped789 := deconstruct_result788
+											p.pretty_missing_type(unwrapped789)
 										} else {
 											_dollar_dollar := msg
-											var _t1297 *pb.DecimalType
+											var _t1323 *pb.DecimalType
 											if hasProtoField(_dollar_dollar, "decimal_type") {
-												_t1297 = _dollar_dollar.GetDecimalType()
+												_t1323 = _dollar_dollar.GetDecimalType()
 											}
-											deconstruct_result773 := _t1297
-											if deconstruct_result773 != nil {
-												unwrapped774 := deconstruct_result773
-												p.pretty_decimal_type(unwrapped774)
+											deconstruct_result786 := _t1323
+											if deconstruct_result786 != nil {
+												unwrapped787 := deconstruct_result786
+												p.pretty_decimal_type(unwrapped787)
 											} else {
 												_dollar_dollar := msg
-												var _t1298 *pb.BooleanType
+												var _t1324 *pb.BooleanType
 												if hasProtoField(_dollar_dollar, "boolean_type") {
-													_t1298 = _dollar_dollar.GetBooleanType()
+													_t1324 = _dollar_dollar.GetBooleanType()
 												}
-												deconstruct_result771 := _t1298
-												if deconstruct_result771 != nil {
-													unwrapped772 := deconstruct_result771
-													p.pretty_boolean_type(unwrapped772)
+												deconstruct_result784 := _t1324
+												if deconstruct_result784 != nil {
+													unwrapped785 := deconstruct_result784
+													p.pretty_boolean_type(unwrapped785)
 												} else {
 													panic(ParseError{msg: "No matching rule for type"})
 												}
@@ -1365,86 +1365,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} {
-	fields794 := msg
-	_ = fields794
+	fields807 := msg
+	_ = fields807
 	p.write("UNKNOWN")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} {
-	fields795 := msg
-	_ = fields795
+	fields808 := msg
+	_ = fields808
 	p.write("STRING")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} {
-	fields796 := msg
-	_ = fields796
+	fields809 := msg
+	_ = fields809
 	p.write("INT")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} {
-	fields797 := msg
-	_ = fields797
+	fields810 := msg
+	_ = fields810
 	p.write("FLOAT")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} {
-	fields798 := msg
-	_ = fields798
+	fields811 := msg
+	_ = fields811
 	p.write("UINT128")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} {
-	fields799 := msg
-	_ = fields799
+	fields812 := msg
+	_ = fields812
 	p.write("INT128")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} {
-	fields800 := msg
-	_ = fields800
+	fields813 := msg
+	_ = fields813
 	p.write("DATE")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} {
-	fields801 := msg
-	_ = fields801
+	fields814 := msg
+	_ = fields814
 	p.write("DATETIME")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} {
-	fields802 := msg
-	_ = fields802
+	fields815 := msg
+	_ = fields815
 	p.write("MISSING")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} {
-	flat807 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) })
-	if flat807 != nil {
-		p.write(*flat807)
+	flat820 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) })
+	if flat820 != nil {
+		p.write(*flat820)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields803 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())}
-		unwrapped_fields804 := fields803
+		fields816 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())}
+		unwrapped_fields817 := fields816
 		p.write("(")
 		p.write("DECIMAL")
 		p.indentSexp()
 		p.newline()
-		field805 := unwrapped_fields804[0].(int64)
-		p.write(fmt.Sprintf("%d", field805))
+		field818 := unwrapped_fields817[0].(int64)
+		p.write(fmt.Sprintf("%d", field818))
 		p.newline()
-		field806 := unwrapped_fields804[1].(int64)
-		p.write(fmt.Sprintf("%d", field806))
+		field819 := unwrapped_fields817[1].(int64)
+		p.write(fmt.Sprintf("%d", field819))
 		p.dedent()
 		p.write(")")
 	}
@@ -1452,27 +1452,27 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} {
-	fields808 := msg
-	_ = fields808
+	fields821 := msg
+	_ = fields821
 	p.write("BOOLEAN")
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} {
-	flat812 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) })
-	if flat812 != nil {
-		p.write(*flat812)
+	flat825 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) })
+	if flat825 != nil {
+		p.write(*flat825)
 		return nil
 	} else {
-		fields809 := msg
+		fields822 := msg
 		p.write("|")
-		if !(len(fields809) == 0) {
+		if !(len(fields822) == 0) {
 			p.write(" ")
-			for i811, elem810 := range fields809 {
-				if (i811 > 0) {
+			for i824, elem823 := range fields822 {
+				if (i824 > 0) {
 					p.newline()
 				}
-				p.pretty_binding(elem810)
+				p.pretty_binding(elem823)
 			}
 		}
 	}
@@ -1480,140 +1480,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} {
-	flat839 := p.tryFlat(msg, func() { p.pretty_formula(msg) })
-	if flat839 != nil {
-		p.write(*flat839)
+	flat852 := p.tryFlat(msg, func() { p.pretty_formula(msg) })
+	if flat852 != nil {
+		p.write(*flat852)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1299 *pb.Conjunction
+		var _t1325 *pb.Conjunction
 		if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) {
-			_t1299 = _dollar_dollar.GetConjunction()
+			_t1325 = _dollar_dollar.GetConjunction()
 		}
-		deconstruct_result837 := _t1299
-		if deconstruct_result837 != nil {
-			unwrapped838 := deconstruct_result837
-			p.pretty_true(unwrapped838)
+		deconstruct_result850 := _t1325
+		if deconstruct_result850 != nil {
+			unwrapped851 := deconstruct_result850
+			p.pretty_true(unwrapped851)
 		} else {
 			_dollar_dollar := msg
-			var _t1300 *pb.Disjunction
+			var _t1326 *pb.Disjunction
 			if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) {
-				_t1300 = _dollar_dollar.GetDisjunction()
+				_t1326 = _dollar_dollar.GetDisjunction()
 			}
-			deconstruct_result835 := _t1300
-			if deconstruct_result835 != nil {
-				unwrapped836 := deconstruct_result835
-				p.pretty_false(unwrapped836)
+			deconstruct_result848 := _t1326
+			if deconstruct_result848 != nil {
+				unwrapped849 := deconstruct_result848
+				p.pretty_false(unwrapped849)
 			} else {
 				_dollar_dollar := msg
-				var _t1301 *pb.Exists
+				var _t1327 *pb.Exists
 				if hasProtoField(_dollar_dollar, "exists") {
-					_t1301 = _dollar_dollar.GetExists()
+					_t1327 = _dollar_dollar.GetExists()
 				}
-				deconstruct_result833 := _t1301
-				if deconstruct_result833 != nil {
-					unwrapped834 := deconstruct_result833
-					p.pretty_exists(unwrapped834)
+				deconstruct_result846 := _t1327
+				if deconstruct_result846 != nil {
+					unwrapped847 := deconstruct_result846
+					p.pretty_exists(unwrapped847)
 				} else {
 					_dollar_dollar := msg
-					var _t1302 *pb.Reduce
+					var _t1328 *pb.Reduce
 					if hasProtoField(_dollar_dollar, "reduce") {
-						_t1302 = _dollar_dollar.GetReduce()
+						_t1328 = _dollar_dollar.GetReduce()
 					}
-					deconstruct_result831 := _t1302
-					if deconstruct_result831 != nil {
-						unwrapped832 := deconstruct_result831
-						p.pretty_reduce(unwrapped832)
+					deconstruct_result844 := _t1328
+					if deconstruct_result844 != nil {
+						unwrapped845 := deconstruct_result844
+						p.pretty_reduce(unwrapped845)
 					} else {
 						_dollar_dollar := msg
-						var _t1303 *pb.Conjunction
+						var _t1329 *pb.Conjunction
 						if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) {
-							_t1303 = _dollar_dollar.GetConjunction()
+							_t1329 = _dollar_dollar.GetConjunction()
 						}
-						deconstruct_result829 := _t1303
-						if deconstruct_result829 != nil {
-							unwrapped830 := deconstruct_result829
-							p.pretty_conjunction(unwrapped830)
+						deconstruct_result842 := _t1329
+						if deconstruct_result842 != nil {
+							unwrapped843 := deconstruct_result842
+							p.pretty_conjunction(unwrapped843)
 						} else {
 							_dollar_dollar := msg
-							var _t1304 *pb.Disjunction
+							var _t1330 *pb.Disjunction
 							if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) {
-								_t1304 = _dollar_dollar.GetDisjunction()
+								_t1330 = _dollar_dollar.GetDisjunction()
 							}
-							deconstruct_result827 := _t1304
-							if deconstruct_result827 != nil {
-								unwrapped828 := deconstruct_result827
-								p.pretty_disjunction(unwrapped828)
+							deconstruct_result840 := _t1330
+							if deconstruct_result840 != nil {
+								unwrapped841 := deconstruct_result840
+								p.pretty_disjunction(unwrapped841)
 							} else {
 								_dollar_dollar := msg
-								var _t1305 *pb.Not
+								var _t1331 *pb.Not
 								if hasProtoField(_dollar_dollar, "not") {
-									_t1305 = _dollar_dollar.GetNot()
+									_t1331 = _dollar_dollar.GetNot()
 								}
-								deconstruct_result825 := _t1305
-								if deconstruct_result825 != nil {
-									unwrapped826 := deconstruct_result825
-									p.pretty_not(unwrapped826)
+								deconstruct_result838 := _t1331
+								if deconstruct_result838 != nil {
+									unwrapped839 := deconstruct_result838
+									p.pretty_not(unwrapped839)
 								} else {
 									_dollar_dollar := msg
-									var _t1306 *pb.FFI
+									var _t1332 *pb.FFI
 									if hasProtoField(_dollar_dollar, "ffi") {
-										_t1306 = _dollar_dollar.GetFfi()
+										_t1332 = _dollar_dollar.GetFfi()
 									}
-									deconstruct_result823 := _t1306
-									if deconstruct_result823 != nil {
-										unwrapped824 := deconstruct_result823
-										p.pretty_ffi(unwrapped824)
+									deconstruct_result836 := _t1332
+									if deconstruct_result836 != nil {
+										unwrapped837 := deconstruct_result836
+										p.pretty_ffi(unwrapped837)
 									} else {
 										_dollar_dollar := msg
-										var _t1307 *pb.Atom
+										var _t1333 *pb.Atom
 										if hasProtoField(_dollar_dollar, "atom") {
-											_t1307 = _dollar_dollar.GetAtom()
+											_t1333 = _dollar_dollar.GetAtom()
 										}
-										deconstruct_result821 := _t1307
-										if deconstruct_result821 != nil {
-											unwrapped822 := deconstruct_result821
-											p.pretty_atom(unwrapped822)
+										deconstruct_result834 := _t1333
+										if deconstruct_result834 != nil {
+											unwrapped835 := deconstruct_result834
+											p.pretty_atom(unwrapped835)
 										} else {
 											_dollar_dollar := msg
-											var _t1308 *pb.Pragma
+											var _t1334 *pb.Pragma
 											if hasProtoField(_dollar_dollar, "pragma") {
-												_t1308 = _dollar_dollar.GetPragma()
+												_t1334 = _dollar_dollar.GetPragma()
 											}
-											deconstruct_result819 := _t1308
-											if deconstruct_result819 != nil {
-												unwrapped820 := deconstruct_result819
-												p.pretty_pragma(unwrapped820)
+											deconstruct_result832 := _t1334
+											if deconstruct_result832 != nil {
+												unwrapped833 := deconstruct_result832
+												p.pretty_pragma(unwrapped833)
 											} else {
 												_dollar_dollar := msg
-												var _t1309 *pb.Primitive
+												var _t1335 *pb.Primitive
 												if hasProtoField(_dollar_dollar, "primitive") {
-													_t1309 = _dollar_dollar.GetPrimitive()
+													_t1335 = _dollar_dollar.GetPrimitive()
 												}
-												deconstruct_result817 := _t1309
-												if deconstruct_result817 != nil {
-													unwrapped818 := deconstruct_result817
-													p.pretty_primitive(unwrapped818)
+												deconstruct_result830 := _t1335
+												if deconstruct_result830 != nil {
+													unwrapped831 := deconstruct_result830
+													p.pretty_primitive(unwrapped831)
 												} else {
 													_dollar_dollar := msg
-													var _t1310 *pb.RelAtom
+													var _t1336 *pb.RelAtom
 													if hasProtoField(_dollar_dollar, "rel_atom") {
-														_t1310 = _dollar_dollar.GetRelAtom()
+														_t1336 = _dollar_dollar.GetRelAtom()
 													}
-													deconstruct_result815 := _t1310
-													if deconstruct_result815 != nil {
-														unwrapped816 := deconstruct_result815
-														p.pretty_rel_atom(unwrapped816)
+													deconstruct_result828 := _t1336
+													if deconstruct_result828 != nil {
+														unwrapped829 := deconstruct_result828
+														p.pretty_rel_atom(unwrapped829)
 													} else {
 														_dollar_dollar := msg
-														var _t1311 *pb.Cast
+														var _t1337 *pb.Cast
 														if hasProtoField(_dollar_dollar, "cast") {
-															_t1311 = _dollar_dollar.GetCast()
+															_t1337 = _dollar_dollar.GetCast()
 														}
-														deconstruct_result813 := _t1311
-														if deconstruct_result813 != nil {
-															unwrapped814 := deconstruct_result813
-															p.pretty_cast(unwrapped814)
+														deconstruct_result826 := _t1337
+														if deconstruct_result826 != nil {
+															unwrapped827 := deconstruct_result826
+															p.pretty_cast(unwrapped827)
 														} else {
 															panic(ParseError{msg: "No matching rule for formula"})
 														}
@@ -1634,8 +1634,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} {
-	fields840 := msg
-	_ = fields840
+	fields853 := msg
+	_ = fields853
 	p.write("(")
 	p.write("true")
 	p.write(")")
@@ -1643,8 +1643,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} {
-	fields841 := msg
-	_ = fields841
+	fields854 := msg
+	_ = fields854
 	p.write("(")
 	p.write("false")
 	p.write(")")
@@ -1652,24 +1652,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} {
-	flat846 := p.tryFlat(msg, func() { p.pretty_exists(msg) })
-	if flat846 != nil {
-		p.write(*flat846)
+	flat859 := p.tryFlat(msg, func() { p.pretty_exists(msg) })
+	if flat859 != nil {
+		p.write(*flat859)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1312 := p.deconstruct_bindings(_dollar_dollar.GetBody())
-		fields842 := []interface{}{_t1312, _dollar_dollar.GetBody().GetValue()}
-		unwrapped_fields843 := fields842
+		_t1338 := p.deconstruct_bindings(_dollar_dollar.GetBody())
+		fields855 := []interface{}{_t1338, _dollar_dollar.GetBody().GetValue()}
+		unwrapped_fields856 := fields855
 		p.write("(")
 		p.write("exists")
 		p.indentSexp()
 		p.newline()
-		field844 := unwrapped_fields843[0].([]interface{})
-		p.pretty_bindings(field844)
+		field857 := unwrapped_fields856[0].([]interface{})
+		p.pretty_bindings(field857)
 		p.newline()
-		field845 := unwrapped_fields843[1].(*pb.Formula)
-		p.pretty_formula(field845)
+		field858 := unwrapped_fields856[1].(*pb.Formula)
+		p.pretty_formula(field858)
 		p.dedent()
 		p.write(")")
 	}
@@ -1677,26 +1677,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} {
-	flat852 := p.tryFlat(msg, func() { p.pretty_reduce(msg) })
-	if flat852 != nil {
-		p.write(*flat852)
+	flat865 := p.tryFlat(msg, func() { p.pretty_reduce(msg) })
+	if flat865 != nil {
+		p.write(*flat865)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields847 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()}
-		unwrapped_fields848 := fields847
+		fields860 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()}
+		unwrapped_fields861 := fields860
 		p.write("(")
 		p.write("reduce")
 		p.indentSexp()
 		p.newline()
-		field849 := unwrapped_fields848[0].(*pb.Abstraction)
-		p.pretty_abstraction(field849)
+		field862 := unwrapped_fields861[0].(*pb.Abstraction)
+		p.pretty_abstraction(field862)
 		p.newline()
-		field850 := unwrapped_fields848[1].(*pb.Abstraction)
-		p.pretty_abstraction(field850)
+		field863 := unwrapped_fields861[1].(*pb.Abstraction)
+		p.pretty_abstraction(field863)
 		p.newline()
-		field851 := unwrapped_fields848[2].([]*pb.Term)
-		p.pretty_terms(field851)
+		field864 := unwrapped_fields861[2].([]*pb.Term)
+		p.pretty_terms(field864)
 		p.dedent()
 		p.write(")")
 	}
@@ -1704,22 +1704,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} {
-	flat856 := p.tryFlat(msg, func() { p.pretty_terms(msg) })
-	if flat856 != nil {
-		p.write(*flat856)
+	flat869 := p.tryFlat(msg, func() { p.pretty_terms(msg) })
+	if flat869 != nil {
+		p.write(*flat869)
 		return nil
 	} else {
-		fields853 := msg
+		fields866 := msg
 		p.write("(")
 		p.write("terms")
 		p.indentSexp()
-		if !(len(fields853) == 0) {
+		if !(len(fields866) == 0) {
 			p.newline()
-			for i855, elem854 := range fields853 {
-				if (i855 > 0) {
+			for i868, elem867 := range fields866 {
+				if (i868 > 0) {
 					p.newline()
 				}
-				p.pretty_term(elem854)
+				p.pretty_term(elem867)
 			}
 		}
 		p.dedent()
@@ -1729,30 +1729,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} {
-	flat861 := p.tryFlat(msg, func() { p.pretty_term(msg) })
-	if flat861 != nil {
-		p.write(*flat861)
+	flat874 := p.tryFlat(msg, func() { p.pretty_term(msg) })
+	if flat874 != nil {
+		p.write(*flat874)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1313 *pb.Var
+		var _t1339 *pb.Var
 		if hasProtoField(_dollar_dollar, "var") {
-			_t1313 = _dollar_dollar.GetVar()
+			_t1339 = _dollar_dollar.GetVar()
 		}
-		deconstruct_result859 := _t1313
-		if deconstruct_result859 != nil {
-			unwrapped860 := deconstruct_result859
-			p.pretty_var(unwrapped860)
+		deconstruct_result872 := _t1339
+		if deconstruct_result872 != nil {
+			unwrapped873 := deconstruct_result872
+			p.pretty_var(unwrapped873)
 		} else {
 			_dollar_dollar := msg
-			var _t1314 *pb.Value
+			var _t1340 *pb.Value
 			if hasProtoField(_dollar_dollar, "constant") {
-				_t1314 = _dollar_dollar.GetConstant()
+				_t1340 = _dollar_dollar.GetConstant()
 			}
-			deconstruct_result857 := _t1314
-			if deconstruct_result857 != nil {
-				unwrapped858 := deconstruct_result857
-				p.pretty_constant(unwrapped858)
+			deconstruct_result870 := _t1340
+			if deconstruct_result870 != nil {
+				unwrapped871 := deconstruct_result870
+				p.pretty_constant(unwrapped871)
 			} else {
 				panic(ParseError{msg: "No matching rule for term"})
 			}
@@ -1762,50 +1762,50 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} {
-	flat864 := p.tryFlat(msg, func() { p.pretty_var(msg) })
-	if flat864 != nil {
-		p.write(*flat864)
+	flat877 := p.tryFlat(msg, func() { p.pretty_var(msg) })
+	if flat877 != nil {
+		p.write(*flat877)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields862 := _dollar_dollar.GetName()
-		unwrapped_fields863 := fields862
-		p.write(unwrapped_fields863)
+		fields875 := _dollar_dollar.GetName()
+		unwrapped_fields876 := fields875
+		p.write(unwrapped_fields876)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_constant(msg *pb.Value) interface{} {
-	flat866 := p.tryFlat(msg, func() { p.pretty_constant(msg) })
-	if flat866 != nil {
-		p.write(*flat866)
+	flat879 := p.tryFlat(msg, func() { p.pretty_constant(msg) })
+	if flat879 != nil {
+		p.write(*flat879)
 		return nil
 	} else {
-		fields865 := msg
-		p.pretty_value(fields865)
+		fields878 := msg
+		p.pretty_value(fields878)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} {
-	flat871 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) })
-	if flat871 != nil {
-		p.write(*flat871)
+	flat884 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) })
+	if flat884 != nil {
+		p.write(*flat884)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields867 := _dollar_dollar.GetArgs()
-		unwrapped_fields868 := fields867
+		fields880 := _dollar_dollar.GetArgs()
+		unwrapped_fields881 := fields880
 		p.write("(")
 		p.write("and")
 		p.indentSexp()
-		if !(len(unwrapped_fields868) == 0) {
+		if !(len(unwrapped_fields881) == 0) {
 			p.newline()
-			for i870, elem869 := range unwrapped_fields868 {
-				if (i870 > 0) {
+			for i883, elem882 := range unwrapped_fields881 {
+				if (i883 > 0) {
 					p.newline()
 				}
-				p.pretty_formula(elem869)
+				p.pretty_formula(elem882)
 			}
 		}
 		p.dedent()
@@ -1815,24 +1815,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} {
-	flat876 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) })
-	if flat876 != nil {
-		p.write(*flat876)
+	flat889 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) })
+	if flat889 != nil {
+		p.write(*flat889)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields872 := _dollar_dollar.GetArgs()
-		unwrapped_fields873 := fields872
+		fields885 := _dollar_dollar.GetArgs()
+		unwrapped_fields886 := fields885
 		p.write("(")
 		p.write("or")
 		p.indentSexp()
-		if !(len(unwrapped_fields873) == 0) {
+		if !(len(unwrapped_fields886) == 0) {
 			p.newline()
-			for i875, elem874 := range unwrapped_fields873 {
-				if (i875 > 0) {
+			for i888, elem887 := range unwrapped_fields886 {
+				if (i888 > 0) {
 					p.newline()
 				}
-				p.pretty_formula(elem874)
+				p.pretty_formula(elem887)
 			}
 		}
 		p.dedent()
@@ -1842,19 +1842,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} {
-	flat879 := p.tryFlat(msg, func() { p.pretty_not(msg) })
-	if flat879 != nil {
-		p.write(*flat879)
+	flat892 := p.tryFlat(msg, func() { p.pretty_not(msg) })
+	if flat892 != nil {
+		p.write(*flat892)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields877 := _dollar_dollar.GetArg()
-		unwrapped_fields878 := fields877
+		fields890 := _dollar_dollar.GetArg()
+		unwrapped_fields891 := fields890
 		p.write("(")
 		p.write("not")
 		p.indentSexp()
 		p.newline()
-		p.pretty_formula(unwrapped_fields878)
+		p.pretty_formula(unwrapped_fields891)
 		p.dedent()
 		p.write(")")
 	}
@@ -1862,26 +1862,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} {
-	flat885 := p.tryFlat(msg, func() { p.pretty_ffi(msg) })
-	if flat885 != nil {
-		p.write(*flat885)
+	flat898 := p.tryFlat(msg, func() { p.pretty_ffi(msg) })
+	if flat898 != nil {
+		p.write(*flat898)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields880 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()}
-		unwrapped_fields881 := fields880
+		fields893 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()}
+		unwrapped_fields894 := fields893
 		p.write("(")
 		p.write("ffi")
 		p.indentSexp()
 		p.newline()
-		field882 := unwrapped_fields881[0].(string)
-		p.pretty_name(field882)
+		field895 := unwrapped_fields894[0].(string)
+		p.pretty_name(field895)
 		p.newline()
-		field883 := unwrapped_fields881[1].([]*pb.Abstraction)
-		p.pretty_ffi_args(field883)
+		field896 := unwrapped_fields894[1].([]*pb.Abstraction)
+		p.pretty_ffi_args(field896)
 		p.newline()
-		field884 := unwrapped_fields881[2].([]*pb.Term)
-		p.pretty_terms(field884)
+		field897 := unwrapped_fields894[2].([]*pb.Term)
+		p.pretty_terms(field897)
 		p.dedent()
 		p.write(")")
 	}
@@ -1889,35 +1889,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_name(msg string) interface{} {
-	flat887 := p.tryFlat(msg, func() { p.pretty_name(msg) })
-	if flat887 != nil {
-		p.write(*flat887)
+	flat900 := p.tryFlat(msg, func() { p.pretty_name(msg) })
+	if flat900 != nil {
+		p.write(*flat900)
 		return nil
 	} else {
-		fields886 := msg
+		fields899 := msg
 		p.write(":")
-		p.write(fields886)
+		p.write(fields899)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} {
-	flat891 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) })
-	if flat891 != nil {
-		p.write(*flat891)
+	flat904 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) })
+	if flat904 != nil {
+		p.write(*flat904)
 		return nil
 	} else {
-		fields888 := msg
+		fields901 := msg
 		p.write("(")
 		p.write("args")
 		p.indentSexp()
-		if !(len(fields888) == 0) {
+		if !(len(fields901) == 0) {
 			p.newline()
-			for i890, elem889 := range fields888 {
-				if (i890 > 0) {
+			for i903, elem902 := range fields901 {
+				if (i903 > 0) {
 					p.newline()
 				}
-				p.pretty_abstraction(elem889)
+				p.pretty_abstraction(elem902)
 			}
 		}
 		p.dedent()
@@ -1927,28 +1927,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} {
-	flat898 := p.tryFlat(msg, func() { p.pretty_atom(msg) })
-	if flat898 != nil {
-		p.write(*flat898)
+	flat911 := p.tryFlat(msg, func() { p.pretty_atom(msg) })
+	if flat911 != nil {
+		p.write(*flat911)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields892 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
-		unwrapped_fields893 := fields892
+		fields905 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
+		unwrapped_fields906 := fields905
 		p.write("(")
 		p.write("atom")
 		p.indentSexp()
 		p.newline()
-		field894 := unwrapped_fields893[0].(*pb.RelationId)
-		p.pretty_relation_id(field894)
-		field895 := unwrapped_fields893[1].([]*pb.Term)
-		if !(len(field895) == 0) {
+		field907 := unwrapped_fields906[0].(*pb.RelationId)
+		p.pretty_relation_id(field907)
+		field908 := unwrapped_fields906[1].([]*pb.Term)
+		if !(len(field908) == 0) {
 			p.newline()
-			for i897, elem896 := range field895 {
-				if (i897 > 0) {
+			for i910, elem909 := range field908 {
+				if (i910 > 0) {
 					p.newline()
 				}
-				p.pretty_term(elem896)
+				p.pretty_term(elem909)
 			}
 		}
 		p.dedent()
@@ -1958,28 +1958,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} {
-	flat905 := p.tryFlat(msg, func() { p.pretty_pragma(msg) })
-	if flat905 != nil {
-		p.write(*flat905)
+	flat918 := p.tryFlat(msg, func() { p.pretty_pragma(msg) })
+	if flat918 != nil {
+		p.write(*flat918)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields899 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
-		unwrapped_fields900 := fields899
+		fields912 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
+		unwrapped_fields913 := fields912
 		p.write("(")
 		p.write("pragma")
 		p.indentSexp()
 		p.newline()
-		field901 := unwrapped_fields900[0].(string)
-		p.pretty_name(field901)
-		field902 := unwrapped_fields900[1].([]*pb.Term)
-		if !(len(field902) == 0) {
+		field914 := unwrapped_fields913[0].(string)
+		p.pretty_name(field914)
+		field915 := unwrapped_fields913[1].([]*pb.Term)
+		if !(len(field915) == 0) {
 			p.newline()
-			for i904, elem903 := range field902 {
-				if (i904 > 0) {
+			for i917, elem916 := range field915 {
+				if (i917 > 0) {
 					p.newline()
 				}
-				p.pretty_term(elem903)
+				p.pretty_term(elem916)
 			}
 		}
 		p.dedent()
@@ -1989,109 +1989,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} {
-	flat921 := p.tryFlat(msg, func() { p.pretty_primitive(msg) })
-	if flat921 != nil {
-		p.write(*flat921)
+	flat934 := p.tryFlat(msg, func() { p.pretty_primitive(msg) })
+	if flat934 != nil {
+		p.write(*flat934)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1315 []interface{}
+		var _t1341 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_eq" {
-			_t1315 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1341 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		guard_result920 := _t1315
-		if guard_result920 != nil {
+		guard_result933 := _t1341
+		if guard_result933 != nil {
 			p.pretty_eq(msg)
 		} else {
 			_dollar_dollar := msg
-			var _t1316 []interface{}
+			var _t1342 []interface{}
 			if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" {
-				_t1316 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+				_t1342 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 			}
-			guard_result919 := _t1316
-			if guard_result919 != nil {
+			guard_result932 := _t1342
+			if guard_result932 != nil {
 				p.pretty_lt(msg)
 			} else {
 				_dollar_dollar := msg
-				var _t1317 []interface{}
+				var _t1343 []interface{}
 				if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" {
-					_t1317 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+					_t1343 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 				}
-				guard_result918 := _t1317
-				if guard_result918 != nil {
+				guard_result931 := _t1343
+				if guard_result931 != nil {
 					p.pretty_lt_eq(msg)
 				} else {
 					_dollar_dollar := msg
-					var _t1318 []interface{}
+					var _t1344 []interface{}
 					if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" {
-						_t1318 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+						_t1344 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 					}
-					guard_result917 := _t1318
-					if guard_result917 != nil {
+					guard_result930 := _t1344
+					if guard_result930 != nil {
 						p.pretty_gt(msg)
 					} else {
 						_dollar_dollar := msg
-						var _t1319 []interface{}
+						var _t1345 []interface{}
 						if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" {
-							_t1319 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+							_t1345 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 						}
-						guard_result916 := _t1319
-						if guard_result916 != nil {
+						guard_result929 := _t1345
+						if guard_result929 != nil {
 							p.pretty_gt_eq(msg)
 						} else {
 							_dollar_dollar := msg
-							var _t1320 []interface{}
+							var _t1346 []interface{}
 							if _dollar_dollar.GetName() == "rel_primitive_add_monotype" {
-								_t1320 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+								_t1346 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 							}
-							guard_result915 := _t1320
-							if guard_result915 != nil {
+							guard_result928 := _t1346
+							if guard_result928 != nil {
 								p.pretty_add(msg)
 							} else {
 								_dollar_dollar := msg
-								var _t1321 []interface{}
+								var _t1347 []interface{}
 								if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" {
-									_t1321 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+									_t1347 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 								}
-								guard_result914 := _t1321
-								if guard_result914 != nil {
+								guard_result927 := _t1347
+								if guard_result927 != nil {
 									p.pretty_minus(msg)
 								} else {
 									_dollar_dollar := msg
-									var _t1322 []interface{}
+									var _t1348 []interface{}
 									if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" {
-										_t1322 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+										_t1348 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 									}
-									guard_result913 := _t1322
-									if guard_result913 != nil {
+									guard_result926 := _t1348
+									if guard_result926 != nil {
 										p.pretty_multiply(msg)
 									} else {
 										_dollar_dollar := msg
-										var _t1323 []interface{}
+										var _t1349 []interface{}
 										if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" {
-											_t1323 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+											_t1349 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 										}
-										guard_result912 := _t1323
-										if guard_result912 != nil {
+										guard_result925 := _t1349
+										if guard_result925 != nil {
 											p.pretty_divide(msg)
 										} else {
 											_dollar_dollar := msg
-											fields906 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
-											unwrapped_fields907 := fields906
+											fields919 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
+											unwrapped_fields920 := fields919
 											p.write("(")
 											p.write("primitive")
 											p.indentSexp()
 											p.newline()
-											field908 := unwrapped_fields907[0].(string)
-											p.pretty_name(field908)
-											field909 := unwrapped_fields907[1].([]*pb.RelTerm)
-											if !(len(field909) == 0) {
+											field921 := unwrapped_fields920[0].(string)
+											p.pretty_name(field921)
+											field922 := unwrapped_fields920[1].([]*pb.RelTerm)
+											if !(len(field922) == 0) {
 												p.newline()
-												for i911, elem910 := range field909 {
-													if (i911 > 0) {
+												for i924, elem923 := range field922 {
+													if (i924 > 0) {
 														p.newline()
 													}
-													p.pretty_rel_term(elem910)
+													p.pretty_rel_term(elem923)
 												}
 											}
 											p.dedent()
@@ -2110,27 +2110,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} {
-	flat926 := p.tryFlat(msg, func() { p.pretty_eq(msg) })
-	if flat926 != nil {
-		p.write(*flat926)
+	flat939 := p.tryFlat(msg, func() { p.pretty_eq(msg) })
+	if flat939 != nil {
+		p.write(*flat939)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1324 []interface{}
+		var _t1350 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_eq" {
-			_t1324 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1350 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		fields922 := _t1324
-		unwrapped_fields923 := fields922
+		fields935 := _t1350
+		unwrapped_fields936 := fields935
 		p.write("(")
 		p.write("=")
 		p.indentSexp()
 		p.newline()
-		field924 := unwrapped_fields923[0].(*pb.Term)
-		p.pretty_term(field924)
+		field937 := unwrapped_fields936[0].(*pb.Term)
+		p.pretty_term(field937)
 		p.newline()
-		field925 := unwrapped_fields923[1].(*pb.Term)
-		p.pretty_term(field925)
+		field938 := unwrapped_fields936[1].(*pb.Term)
+		p.pretty_term(field938)
 		p.dedent()
 		p.write(")")
 	}
@@ -2138,27 +2138,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} {
-	flat931 := p.tryFlat(msg, func() { p.pretty_lt(msg) })
-	if flat931 != nil {
-		p.write(*flat931)
+	flat944 := p.tryFlat(msg, func() { p.pretty_lt(msg) })
+	if flat944 != nil {
+		p.write(*flat944)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1325 []interface{}
+		var _t1351 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" {
-			_t1325 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1351 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		fields927 := _t1325
-		unwrapped_fields928 := fields927
+		fields940 := _t1351
+		unwrapped_fields941 := fields940
 		p.write("(")
 		p.write("<")
 		p.indentSexp()
 		p.newline()
-		field929 := unwrapped_fields928[0].(*pb.Term)
-		p.pretty_term(field929)
+		field942 := unwrapped_fields941[0].(*pb.Term)
+		p.pretty_term(field942)
 		p.newline()
-		field930 := unwrapped_fields928[1].(*pb.Term)
-		p.pretty_term(field930)
+		field943 := unwrapped_fields941[1].(*pb.Term)
+		p.pretty_term(field943)
 		p.dedent()
 		p.write(")")
 	}
@@ -2166,27 +2166,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} {
-	flat936 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) })
-	if flat936 != nil {
-		p.write(*flat936)
+	flat949 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) })
+	if flat949 != nil {
+		p.write(*flat949)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1326 []interface{}
+		var _t1352 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" {
-			_t1326 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1352 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		fields932 := _t1326
-		unwrapped_fields933 := fields932
+		fields945 := _t1352
+		unwrapped_fields946 := fields945
 		p.write("(")
 		p.write("<=")
 		p.indentSexp()
 		p.newline()
-		field934 := unwrapped_fields933[0].(*pb.Term)
-		p.pretty_term(field934)
+		field947 := unwrapped_fields946[0].(*pb.Term)
+		p.pretty_term(field947)
 		p.newline()
-		field935 := unwrapped_fields933[1].(*pb.Term)
-		p.pretty_term(field935)
+		field948 := unwrapped_fields946[1].(*pb.Term)
+		p.pretty_term(field948)
 		p.dedent()
 		p.write(")")
 	}
@@ -2194,27 +2194,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} {
-	flat941 := p.tryFlat(msg, func() { p.pretty_gt(msg) })
-	if flat941 != nil {
-		p.write(*flat941)
+	flat954 := p.tryFlat(msg, func() { p.pretty_gt(msg) })
+	if flat954 != nil {
+		p.write(*flat954)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1327 []interface{}
+		var _t1353 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" {
-			_t1327 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1353 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		fields937 := _t1327
-		unwrapped_fields938 := fields937
+		fields950 := _t1353
+		unwrapped_fields951 := fields950
 		p.write("(")
 		p.write(">")
 		p.indentSexp()
 		p.newline()
-		field939 := unwrapped_fields938[0].(*pb.Term)
-		p.pretty_term(field939)
+		field952 := unwrapped_fields951[0].(*pb.Term)
+		p.pretty_term(field952)
 		p.newline()
-		field940 := unwrapped_fields938[1].(*pb.Term)
-		p.pretty_term(field940)
+		field953 := unwrapped_fields951[1].(*pb.Term)
+		p.pretty_term(field953)
 		p.dedent()
 		p.write(")")
 	}
@@ -2222,27 +2222,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} {
-	flat946 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) })
-	if flat946 != nil {
-		p.write(*flat946)
+	flat959 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) })
+	if flat959 != nil {
+		p.write(*flat959)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1328 []interface{}
+		var _t1354 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" {
-			_t1328 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
+			_t1354 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()}
 		}
-		fields942 := _t1328
-		unwrapped_fields943 := fields942
+		fields955 := _t1354
+		unwrapped_fields956 := fields955
 		p.write("(")
 		p.write(">=")
 		p.indentSexp()
 		p.newline()
-		field944 := unwrapped_fields943[0].(*pb.Term)
-		p.pretty_term(field944)
+		field957 := unwrapped_fields956[0].(*pb.Term)
+		p.pretty_term(field957)
 		p.newline()
-		field945 := unwrapped_fields943[1].(*pb.Term)
-		p.pretty_term(field945)
+		field958 := unwrapped_fields956[1].(*pb.Term)
+		p.pretty_term(field958)
 		p.dedent()
 		p.write(")")
 	}
@@ -2250,30 +2250,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} {
-	flat952 := p.tryFlat(msg, func() { p.pretty_add(msg) })
-	if flat952 != nil {
-		p.write(*flat952)
+	flat965 := p.tryFlat(msg, func() { p.pretty_add(msg) })
+	if flat965 != nil {
+		p.write(*flat965)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1329 []interface{}
+		var _t1355 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_add_monotype" {
-			_t1329 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+			_t1355 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 		}
-		fields947 := _t1329
-		unwrapped_fields948 := fields947
+		fields960 := _t1355
+		unwrapped_fields961 := fields960
 		p.write("(")
 		p.write("+")
 		p.indentSexp()
 		p.newline()
-		field949 := unwrapped_fields948[0].(*pb.Term)
-		p.pretty_term(field949)
+		field962 := unwrapped_fields961[0].(*pb.Term)
+		p.pretty_term(field962)
 		p.newline()
-		field950 := unwrapped_fields948[1].(*pb.Term)
-		p.pretty_term(field950)
+		field963 := unwrapped_fields961[1].(*pb.Term)
+		p.pretty_term(field963)
 		p.newline()
-		field951 := unwrapped_fields948[2].(*pb.Term)
-		p.pretty_term(field951)
+		field964 := unwrapped_fields961[2].(*pb.Term)
+		p.pretty_term(field964)
 		p.dedent()
 		p.write(")")
 	}
@@ -2281,30 +2281,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} {
-	flat958 := p.tryFlat(msg, func() { p.pretty_minus(msg) })
-	if flat958 != nil {
-		p.write(*flat958)
+	flat971 := p.tryFlat(msg, func() { p.pretty_minus(msg) })
+	if flat971 != nil {
+		p.write(*flat971)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1330 []interface{}
+		var _t1356 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" {
-			_t1330 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+			_t1356 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 		}
-		fields953 := _t1330
-		unwrapped_fields954 := fields953
+		fields966 := _t1356
+		unwrapped_fields967 := fields966
 		p.write("(")
 		p.write("-")
 		p.indentSexp()
 		p.newline()
-		field955 := unwrapped_fields954[0].(*pb.Term)
-		p.pretty_term(field955)
+		field968 := unwrapped_fields967[0].(*pb.Term)
+		p.pretty_term(field968)
 		p.newline()
-		field956 := unwrapped_fields954[1].(*pb.Term)
-		p.pretty_term(field956)
+		field969 := unwrapped_fields967[1].(*pb.Term)
+		p.pretty_term(field969)
 		p.newline()
-		field957 := unwrapped_fields954[2].(*pb.Term)
-		p.pretty_term(field957)
+		field970 := unwrapped_fields967[2].(*pb.Term)
+		p.pretty_term(field970)
 		p.dedent()
 		p.write(")")
 	}
@@ -2312,30 +2312,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} {
-	flat964 := p.tryFlat(msg, func() { p.pretty_multiply(msg) })
-	if flat964 != nil {
-		p.write(*flat964)
+	flat977 := p.tryFlat(msg, func() { p.pretty_multiply(msg) })
+	if flat977 != nil {
+		p.write(*flat977)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1331 []interface{}
+		var _t1357 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" {
-			_t1331 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+			_t1357 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 		}
-		fields959 := _t1331
-		unwrapped_fields960 := fields959
+		fields972 := _t1357
+		unwrapped_fields973 := fields972
 		p.write("(")
 		p.write("*")
 		p.indentSexp()
 		p.newline()
-		field961 := unwrapped_fields960[0].(*pb.Term)
-		p.pretty_term(field961)
+		field974 := unwrapped_fields973[0].(*pb.Term)
+		p.pretty_term(field974)
 		p.newline()
-		field962 := unwrapped_fields960[1].(*pb.Term)
-		p.pretty_term(field962)
+		field975 := unwrapped_fields973[1].(*pb.Term)
+		p.pretty_term(field975)
 		p.newline()
-		field963 := unwrapped_fields960[2].(*pb.Term)
-		p.pretty_term(field963)
+		field976 := unwrapped_fields973[2].(*pb.Term)
+		p.pretty_term(field976)
 		p.dedent()
 		p.write(")")
 	}
@@ -2343,30 +2343,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} {
-	flat970 := p.tryFlat(msg, func() { p.pretty_divide(msg) })
-	if flat970 != nil {
-		p.write(*flat970)
+	flat983 := p.tryFlat(msg, func() { p.pretty_divide(msg) })
+	if flat983 != nil {
+		p.write(*flat983)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1332 []interface{}
+		var _t1358 []interface{}
 		if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" {
-			_t1332 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
+			_t1358 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()}
 		}
-		fields965 := _t1332
-		unwrapped_fields966 := fields965
+		fields978 := _t1358
+		unwrapped_fields979 := fields978
 		p.write("(")
 		p.write("/")
 		p.indentSexp()
 		p.newline()
-		field967 := unwrapped_fields966[0].(*pb.Term)
-		p.pretty_term(field967)
+		field980 := unwrapped_fields979[0].(*pb.Term)
+		p.pretty_term(field980)
 		p.newline()
-		field968 := unwrapped_fields966[1].(*pb.Term)
-		p.pretty_term(field968)
+		field981 := unwrapped_fields979[1].(*pb.Term)
+		p.pretty_term(field981)
 		p.newline()
-		field969 := unwrapped_fields966[2].(*pb.Term)
-		p.pretty_term(field969)
+		field982 := unwrapped_fields979[2].(*pb.Term)
+		p.pretty_term(field982)
 		p.dedent()
 		p.write(")")
 	}
@@ -2374,30 +2374,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} {
-	flat975 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) })
-	if flat975 != nil {
-		p.write(*flat975)
+	flat988 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) })
+	if flat988 != nil {
+		p.write(*flat988)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1333 *pb.Value
+		var _t1359 *pb.Value
 		if hasProtoField(_dollar_dollar, "specialized_value") {
-			_t1333 = _dollar_dollar.GetSpecializedValue()
+			_t1359 = _dollar_dollar.GetSpecializedValue()
 		}
-		deconstruct_result973 := _t1333
-		if deconstruct_result973 != nil {
-			unwrapped974 := deconstruct_result973
-			p.pretty_specialized_value(unwrapped974)
+		deconstruct_result986 := _t1359
+		if deconstruct_result986 != nil {
+			unwrapped987 := deconstruct_result986
+			p.pretty_specialized_value(unwrapped987)
 		} else {
 			_dollar_dollar := msg
-			var _t1334 *pb.Term
+			var _t1360 *pb.Term
 			if hasProtoField(_dollar_dollar, "term") {
-				_t1334 = _dollar_dollar.GetTerm()
+				_t1360 = _dollar_dollar.GetTerm()
 			}
-			deconstruct_result971 := _t1334
-			if deconstruct_result971 != nil {
-				unwrapped972 := deconstruct_result971
-				p.pretty_term(unwrapped972)
+			deconstruct_result984 := _t1360
+			if deconstruct_result984 != nil {
+				unwrapped985 := deconstruct_result984
+				p.pretty_term(unwrapped985)
 			} else {
 				panic(ParseError{msg: "No matching rule for rel_term"})
 			}
@@ -2407,41 +2407,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} {
-	flat977 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) })
-	if flat977 != nil {
-		p.write(*flat977)
+	flat990 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) })
+	if flat990 != nil {
+		p.write(*flat990)
 		return nil
 	} else {
-		fields976 := msg
+		fields989 := msg
 		p.write("#")
-		p.pretty_value(fields976)
+		p.pretty_value(fields989)
 	}
 	return nil
 }
 
 func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} {
-	flat984 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) })
-	if flat984 != nil {
-		p.write(*flat984)
+	flat997 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) })
+	if flat997 != nil {
+		p.write(*flat997)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields978 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
-		unwrapped_fields979 := fields978
+		fields991 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()}
+		unwrapped_fields992 := fields991
 		p.write("(")
 		p.write("relatom")
 		p.indentSexp()
 		p.newline()
-		field980 := unwrapped_fields979[0].(string)
-		p.pretty_name(field980)
-		field981 := unwrapped_fields979[1].([]*pb.RelTerm)
-		if !(len(field981) == 0) {
+		field993 := unwrapped_fields992[0].(string)
+		p.pretty_name(field993)
+		field994 := unwrapped_fields992[1].([]*pb.RelTerm)
+		if !(len(field994) == 0) {
 			p.newline()
-			for i983, elem982 := range field981 {
-				if (i983 > 0) {
+			for i996, elem995 := range field994 {
+				if (i996 > 0) {
 					p.newline()
 				}
-				p.pretty_rel_term(elem982)
+				p.pretty_rel_term(elem995)
 			}
 		}
 		p.dedent()
@@ -2451,23 +2451,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} {
-	flat989 := p.tryFlat(msg, func() { p.pretty_cast(msg) })
-	if flat989 != nil {
-		p.write(*flat989)
+	flat1002 := p.tryFlat(msg, func() { p.pretty_cast(msg) })
+	if flat1002 != nil {
+		p.write(*flat1002)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields985 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()}
-		unwrapped_fields986 := fields985
+		fields998 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()}
+		unwrapped_fields999 := fields998
 		p.write("(")
 		p.write("cast")
 		p.indentSexp()
 		p.newline()
-		field987 := unwrapped_fields986[0].(*pb.Term)
-		p.pretty_term(field987)
+		field1000 := unwrapped_fields999[0].(*pb.Term)
+		p.pretty_term(field1000)
 		p.newline()
-		field988 := unwrapped_fields986[1].(*pb.Term)
-		p.pretty_term(field988)
+		field1001 := unwrapped_fields999[1].(*pb.Term)
+		p.pretty_term(field1001)
 		p.dedent()
 		p.write(")")
 	}
@@ -2475,22 +2475,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} {
-	flat993 := p.tryFlat(msg, func() { p.pretty_attrs(msg) })
-	if flat993 != nil {
-		p.write(*flat993)
+	flat1006 := p.tryFlat(msg, func() { p.pretty_attrs(msg) })
+	if flat1006 != nil {
+		p.write(*flat1006)
 		return nil
 	} else {
-		fields990 := msg
+		fields1003 := msg
 		p.write("(")
 		p.write("attrs")
 		p.indentSexp()
-		if !(len(fields990) == 0) {
+		if !(len(fields1003) == 0) {
 			p.newline()
-			for i992, elem991 := range fields990 {
-				if (i992 > 0) {
+			for i1005, elem1004 := range fields1003 {
+				if (i1005 > 0) {
 					p.newline()
 				}
-				p.pretty_attribute(elem991)
+				p.pretty_attribute(elem1004)
 			}
 		}
 		p.dedent()
@@ -2500,28 +2500,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} {
-	flat1000 := p.tryFlat(msg, func() { p.pretty_attribute(msg) })
-	if flat1000 != nil {
-		p.write(*flat1000)
+	flat1013 := p.tryFlat(msg, func() { p.pretty_attribute(msg) })
+	if flat1013 != nil {
+		p.write(*flat1013)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields994 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()}
-		unwrapped_fields995 := fields994
+		fields1007 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()}
+		unwrapped_fields1008 := fields1007
 		p.write("(")
 		p.write("attribute")
 		p.indentSexp()
 		p.newline()
-		field996 := unwrapped_fields995[0].(string)
-		p.pretty_name(field996)
-		field997 := unwrapped_fields995[1].([]*pb.Value)
-		if !(len(field997) == 0) {
+		field1009 := unwrapped_fields1008[0].(string)
+		p.pretty_name(field1009)
+		field1010 := unwrapped_fields1008[1].([]*pb.Value)
+		if !(len(field1010) == 0) {
 			p.newline()
-			for i999, elem998 := range field997 {
-				if (i999 > 0) {
+			for i1012, elem1011 := range field1010 {
+				if (i1012 > 0) {
 					p.newline()
 				}
-				p.pretty_value(elem998)
+				p.pretty_value(elem1011)
 			}
 		}
 		p.dedent()
@@ -2531,30 +2531,30 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} {
-	flat1007 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) })
-	if flat1007 != nil {
-		p.write(*flat1007)
+	flat1020 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) })
+	if flat1020 != nil {
+		p.write(*flat1020)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1001 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()}
-		unwrapped_fields1002 := fields1001
+		fields1014 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody()}
+		unwrapped_fields1015 := fields1014
 		p.write("(")
 		p.write("algorithm")
 		p.indentSexp()
-		field1003 := unwrapped_fields1002[0].([]*pb.RelationId)
-		if !(len(field1003) == 0) {
+		field1016 := unwrapped_fields1015[0].([]*pb.RelationId)
+		if !(len(field1016) == 0) {
 			p.newline()
-			for i1005, elem1004 := range field1003 {
-				if (i1005 > 0) {
+			for i1018, elem1017 := range field1016 {
+				if (i1018 > 0) {
 					p.newline()
 				}
-				p.pretty_relation_id(elem1004)
+				p.pretty_relation_id(elem1017)
 			}
 		}
 		p.newline()
-		field1006 := unwrapped_fields1002[1].(*pb.Script)
-		p.pretty_script(field1006)
+		field1019 := unwrapped_fields1015[1].(*pb.Script)
+		p.pretty_script(field1019)
 		p.dedent()
 		p.write(")")
 	}
@@ -2562,24 +2562,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} {
-	flat1012 := p.tryFlat(msg, func() { p.pretty_script(msg) })
-	if flat1012 != nil {
-		p.write(*flat1012)
+	flat1025 := p.tryFlat(msg, func() { p.pretty_script(msg) })
+	if flat1025 != nil {
+		p.write(*flat1025)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1008 := _dollar_dollar.GetConstructs()
-		unwrapped_fields1009 := fields1008
+		fields1021 := _dollar_dollar.GetConstructs()
+		unwrapped_fields1022 := fields1021
 		p.write("(")
 		p.write("script")
 		p.indentSexp()
-		if !(len(unwrapped_fields1009) == 0) {
+		if !(len(unwrapped_fields1022) == 0) {
 			p.newline()
-			for i1011, elem1010 := range unwrapped_fields1009 {
-				if (i1011 > 0) {
+			for i1024, elem1023 := range unwrapped_fields1022 {
+				if (i1024 > 0) {
 					p.newline()
 				}
-				p.pretty_construct(elem1010)
+				p.pretty_construct(elem1023)
 			}
 		}
 		p.dedent()
@@ -2589,30 +2589,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} {
-	flat1017 := p.tryFlat(msg, func() { p.pretty_construct(msg) })
-	if flat1017 != nil {
-		p.write(*flat1017)
+	flat1030 := p.tryFlat(msg, func() { p.pretty_construct(msg) })
+	if flat1030 != nil {
+		p.write(*flat1030)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1335 *pb.Loop
+		var _t1361 *pb.Loop
 		if hasProtoField(_dollar_dollar, "loop") {
-			_t1335 = _dollar_dollar.GetLoop()
+			_t1361 = _dollar_dollar.GetLoop()
 		}
-		deconstruct_result1015 := _t1335
-		if deconstruct_result1015 != nil {
-			unwrapped1016 := deconstruct_result1015
-			p.pretty_loop(unwrapped1016)
+		deconstruct_result1028 := _t1361
+		if deconstruct_result1028 != nil {
+			unwrapped1029 := deconstruct_result1028
+			p.pretty_loop(unwrapped1029)
 		} else {
 			_dollar_dollar := msg
-			var _t1336 *pb.Instruction
+			var _t1362 *pb.Instruction
 			if hasProtoField(_dollar_dollar, "instruction") {
-				_t1336 = _dollar_dollar.GetInstruction()
+				_t1362 = _dollar_dollar.GetInstruction()
 			}
-			deconstruct_result1013 := _t1336
-			if deconstruct_result1013 != nil {
-				unwrapped1014 := deconstruct_result1013
-				p.pretty_instruction(unwrapped1014)
+			deconstruct_result1026 := _t1362
+			if deconstruct_result1026 != nil {
+				unwrapped1027 := deconstruct_result1026
+				p.pretty_instruction(unwrapped1027)
 			} else {
 				panic(ParseError{msg: "No matching rule for construct"})
 			}
@@ -2622,23 +2622,23 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} {
-	flat1022 := p.tryFlat(msg, func() { p.pretty_loop(msg) })
-	if flat1022 != nil {
-		p.write(*flat1022)
+	flat1035 := p.tryFlat(msg, func() { p.pretty_loop(msg) })
+	if flat1035 != nil {
+		p.write(*flat1035)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1018 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()}
-		unwrapped_fields1019 := fields1018
+		fields1031 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody()}
+		unwrapped_fields1032 := fields1031
 		p.write("(")
 		p.write("loop")
 		p.indentSexp()
 		p.newline()
-		field1020 := unwrapped_fields1019[0].([]*pb.Instruction)
-		p.pretty_init(field1020)
+		field1033 := unwrapped_fields1032[0].([]*pb.Instruction)
+		p.pretty_init(field1033)
 		p.newline()
-		field1021 := unwrapped_fields1019[1].(*pb.Script)
-		p.pretty_script(field1021)
+		field1034 := unwrapped_fields1032[1].(*pb.Script)
+		p.pretty_script(field1034)
 		p.dedent()
 		p.write(")")
 	}
@@ -2646,22 +2646,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} {
-	flat1026 := p.tryFlat(msg, func() { p.pretty_init(msg) })
-	if flat1026 != nil {
-		p.write(*flat1026)
+	flat1039 := p.tryFlat(msg, func() { p.pretty_init(msg) })
+	if flat1039 != nil {
+		p.write(*flat1039)
 		return nil
 	} else {
-		fields1023 := msg
+		fields1036 := msg
 		p.write("(")
 		p.write("init")
 		p.indentSexp()
-		if !(len(fields1023) == 0) {
+		if !(len(fields1036) == 0) {
 			p.newline()
-			for i1025, elem1024 := range fields1023 {
-				if (i1025 > 0) {
+			for i1038, elem1037 := range fields1036 {
+				if (i1038 > 0) {
 					p.newline()
 				}
-				p.pretty_instruction(elem1024)
+				p.pretty_instruction(elem1037)
 			}
 		}
 		p.dedent()
@@ -2671,60 +2671,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} {
-	flat1037 := p.tryFlat(msg, func() { p.pretty_instruction(msg) })
-	if flat1037 != nil {
-		p.write(*flat1037)
+	flat1050 := p.tryFlat(msg, func() { p.pretty_instruction(msg) })
+	if flat1050 != nil {
+		p.write(*flat1050)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1337 *pb.Assign
+		var _t1363 *pb.Assign
 		if hasProtoField(_dollar_dollar, "assign") {
-			_t1337 = _dollar_dollar.GetAssign()
+			_t1363 = _dollar_dollar.GetAssign()
 		}
-		deconstruct_result1035 := _t1337
-		if deconstruct_result1035 != nil {
-			unwrapped1036 := deconstruct_result1035
-			p.pretty_assign(unwrapped1036)
+		deconstruct_result1048 := _t1363
+		if deconstruct_result1048 != nil {
+			unwrapped1049 := deconstruct_result1048
+			p.pretty_assign(unwrapped1049)
 		} else {
 			_dollar_dollar := msg
-			var _t1338 *pb.Upsert
+			var _t1364 *pb.Upsert
 			if hasProtoField(_dollar_dollar, "upsert") {
-				_t1338 = _dollar_dollar.GetUpsert()
+				_t1364 = _dollar_dollar.GetUpsert()
 			}
-			deconstruct_result1033 := _t1338
-			if deconstruct_result1033 != nil {
-				unwrapped1034 := deconstruct_result1033
-				p.pretty_upsert(unwrapped1034)
+			deconstruct_result1046 := _t1364
+			if deconstruct_result1046 != nil {
+				unwrapped1047 := deconstruct_result1046
+				p.pretty_upsert(unwrapped1047)
 			} else {
 				_dollar_dollar := msg
-				var _t1339 *pb.Break
+				var _t1365 *pb.Break
 				if hasProtoField(_dollar_dollar, "break") {
-					_t1339 = _dollar_dollar.GetBreak()
+					_t1365 = _dollar_dollar.GetBreak()
 				}
-				deconstruct_result1031 := _t1339
-				if deconstruct_result1031 != nil {
-					unwrapped1032 := deconstruct_result1031
-					p.pretty_break(unwrapped1032)
+				deconstruct_result1044 := _t1365
+				if deconstruct_result1044 != nil {
+					unwrapped1045 := deconstruct_result1044
+					p.pretty_break(unwrapped1045)
 				} else {
 					_dollar_dollar := msg
-					var _t1340 *pb.MonoidDef
+					var _t1366 *pb.MonoidDef
 					if hasProtoField(_dollar_dollar, "monoid_def") {
-						_t1340 = _dollar_dollar.GetMonoidDef()
+						_t1366 = _dollar_dollar.GetMonoidDef()
 					}
-					deconstruct_result1029 := _t1340
-					if deconstruct_result1029 != nil {
-						unwrapped1030 := deconstruct_result1029
-						p.pretty_monoid_def(unwrapped1030)
+					deconstruct_result1042 := _t1366
+					if deconstruct_result1042 != nil {
+						unwrapped1043 := deconstruct_result1042
+						p.pretty_monoid_def(unwrapped1043)
 					} else {
 						_dollar_dollar := msg
-						var _t1341 *pb.MonusDef
+						var _t1367 *pb.MonusDef
 						if hasProtoField(_dollar_dollar, "monus_def") {
-							_t1341 = _dollar_dollar.GetMonusDef()
+							_t1367 = _dollar_dollar.GetMonusDef()
 						}
-						deconstruct_result1027 := _t1341
-						if deconstruct_result1027 != nil {
-							unwrapped1028 := deconstruct_result1027
-							p.pretty_monus_def(unwrapped1028)
+						deconstruct_result1040 := _t1367
+						if deconstruct_result1040 != nil {
+							unwrapped1041 := deconstruct_result1040
+							p.pretty_monus_def(unwrapped1041)
 						} else {
 							panic(ParseError{msg: "No matching rule for instruction"})
 						}
@@ -2737,32 +2737,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} {
-	flat1044 := p.tryFlat(msg, func() { p.pretty_assign(msg) })
-	if flat1044 != nil {
-		p.write(*flat1044)
+	flat1057 := p.tryFlat(msg, func() { p.pretty_assign(msg) })
+	if flat1057 != nil {
+		p.write(*flat1057)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1342 []*pb.Attribute
+		var _t1368 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1342 = _dollar_dollar.GetAttrs()
+			_t1368 = _dollar_dollar.GetAttrs()
 		}
-		fields1038 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1342}
-		unwrapped_fields1039 := fields1038
+		fields1051 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1368}
+		unwrapped_fields1052 := fields1051
 		p.write("(")
 		p.write("assign")
 		p.indentSexp()
 		p.newline()
-		field1040 := unwrapped_fields1039[0].(*pb.RelationId)
-		p.pretty_relation_id(field1040)
+		field1053 := unwrapped_fields1052[0].(*pb.RelationId)
+		p.pretty_relation_id(field1053)
 		p.newline()
-		field1041 := unwrapped_fields1039[1].(*pb.Abstraction)
-		p.pretty_abstraction(field1041)
-		field1042 := unwrapped_fields1039[2].([]*pb.Attribute)
-		if field1042 != nil {
+		field1054 := unwrapped_fields1052[1].(*pb.Abstraction)
+		p.pretty_abstraction(field1054)
+		field1055 := unwrapped_fields1052[2].([]*pb.Attribute)
+		if field1055 != nil {
 			p.newline()
-			opt_val1043 := field1042
-			p.pretty_attrs(opt_val1043)
+			opt_val1056 := field1055
+			p.pretty_attrs(opt_val1056)
 		}
 		p.dedent()
 		p.write(")")
@@ -2771,32 +2771,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} {
-	flat1051 := p.tryFlat(msg, func() { p.pretty_upsert(msg) })
-	if flat1051 != nil {
-		p.write(*flat1051)
+	flat1064 := p.tryFlat(msg, func() { p.pretty_upsert(msg) })
+	if flat1064 != nil {
+		p.write(*flat1064)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1343 []*pb.Attribute
+		var _t1369 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1343 = _dollar_dollar.GetAttrs()
+			_t1369 = _dollar_dollar.GetAttrs()
 		}
-		fields1045 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1343}
-		unwrapped_fields1046 := fields1045
+		fields1058 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1369}
+		unwrapped_fields1059 := fields1058
 		p.write("(")
 		p.write("upsert")
 		p.indentSexp()
 		p.newline()
-		field1047 := unwrapped_fields1046[0].(*pb.RelationId)
-		p.pretty_relation_id(field1047)
+		field1060 := unwrapped_fields1059[0].(*pb.RelationId)
+		p.pretty_relation_id(field1060)
 		p.newline()
-		field1048 := unwrapped_fields1046[1].([]interface{})
-		p.pretty_abstraction_with_arity(field1048)
-		field1049 := unwrapped_fields1046[2].([]*pb.Attribute)
-		if field1049 != nil {
+		field1061 := unwrapped_fields1059[1].([]interface{})
+		p.pretty_abstraction_with_arity(field1061)
+		field1062 := unwrapped_fields1059[2].([]*pb.Attribute)
+		if field1062 != nil {
 			p.newline()
-			opt_val1050 := field1049
-			p.pretty_attrs(opt_val1050)
+			opt_val1063 := field1062
+			p.pretty_attrs(opt_val1063)
 		}
 		p.dedent()
 		p.write(")")
@@ -2805,22 +2805,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} {
-	flat1056 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) })
-	if flat1056 != nil {
-		p.write(*flat1056)
+	flat1069 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) })
+	if flat1069 != nil {
+		p.write(*flat1069)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1344 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64))
-		fields1052 := []interface{}{_t1344, _dollar_dollar[0].(*pb.Abstraction).GetValue()}
-		unwrapped_fields1053 := fields1052
+		_t1370 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64))
+		fields1065 := []interface{}{_t1370, _dollar_dollar[0].(*pb.Abstraction).GetValue()}
+		unwrapped_fields1066 := fields1065
 		p.write("(")
 		p.indent()
-		field1054 := unwrapped_fields1053[0].([]interface{})
-		p.pretty_bindings(field1054)
+		field1067 := unwrapped_fields1066[0].([]interface{})
+		p.pretty_bindings(field1067)
 		p.newline()
-		field1055 := unwrapped_fields1053[1].(*pb.Formula)
-		p.pretty_formula(field1055)
+		field1068 := unwrapped_fields1066[1].(*pb.Formula)
+		p.pretty_formula(field1068)
 		p.dedent()
 		p.write(")")
 	}
@@ -2828,32 +2828,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa
 }
 
 func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} {
-	flat1063 := p.tryFlat(msg, func() { p.pretty_break(msg) })
-	if flat1063 != nil {
-		p.write(*flat1063)
+	flat1076 := p.tryFlat(msg, func() { p.pretty_break(msg) })
+	if flat1076 != nil {
+		p.write(*flat1076)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1345 []*pb.Attribute
+		var _t1371 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1345 = _dollar_dollar.GetAttrs()
+			_t1371 = _dollar_dollar.GetAttrs()
 		}
-		fields1057 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1345}
-		unwrapped_fields1058 := fields1057
+		fields1070 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1371}
+		unwrapped_fields1071 := fields1070
 		p.write("(")
 		p.write("break")
 		p.indentSexp()
 		p.newline()
-		field1059 := unwrapped_fields1058[0].(*pb.RelationId)
-		p.pretty_relation_id(field1059)
+		field1072 := unwrapped_fields1071[0].(*pb.RelationId)
+		p.pretty_relation_id(field1072)
 		p.newline()
-		field1060 := unwrapped_fields1058[1].(*pb.Abstraction)
-		p.pretty_abstraction(field1060)
-		field1061 := unwrapped_fields1058[2].([]*pb.Attribute)
-		if field1061 != nil {
+		field1073 := unwrapped_fields1071[1].(*pb.Abstraction)
+		p.pretty_abstraction(field1073)
+		field1074 := unwrapped_fields1071[2].([]*pb.Attribute)
+		if field1074 != nil {
 			p.newline()
-			opt_val1062 := field1061
-			p.pretty_attrs(opt_val1062)
+			opt_val1075 := field1074
+			p.pretty_attrs(opt_val1075)
 		}
 		p.dedent()
 		p.write(")")
@@ -2862,35 +2862,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} {
-	flat1071 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) })
-	if flat1071 != nil {
-		p.write(*flat1071)
+	flat1084 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) })
+	if flat1084 != nil {
+		p.write(*flat1084)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1346 []*pb.Attribute
+		var _t1372 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1346 = _dollar_dollar.GetAttrs()
+			_t1372 = _dollar_dollar.GetAttrs()
 		}
-		fields1064 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1346}
-		unwrapped_fields1065 := fields1064
+		fields1077 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1372}
+		unwrapped_fields1078 := fields1077
 		p.write("(")
 		p.write("monoid")
 		p.indentSexp()
 		p.newline()
-		field1066 := unwrapped_fields1065[0].(*pb.Monoid)
-		p.pretty_monoid(field1066)
+		field1079 := unwrapped_fields1078[0].(*pb.Monoid)
+		p.pretty_monoid(field1079)
 		p.newline()
-		field1067 := unwrapped_fields1065[1].(*pb.RelationId)
-		p.pretty_relation_id(field1067)
+		field1080 := unwrapped_fields1078[1].(*pb.RelationId)
+		p.pretty_relation_id(field1080)
 		p.newline()
-		field1068 := unwrapped_fields1065[2].([]interface{})
-		p.pretty_abstraction_with_arity(field1068)
-		field1069 := unwrapped_fields1065[3].([]*pb.Attribute)
-		if field1069 != nil {
+		field1081 := unwrapped_fields1078[2].([]interface{})
+		p.pretty_abstraction_with_arity(field1081)
+		field1082 := unwrapped_fields1078[3].([]*pb.Attribute)
+		if field1082 != nil {
 			p.newline()
-			opt_val1070 := field1069
-			p.pretty_attrs(opt_val1070)
+			opt_val1083 := field1082
+			p.pretty_attrs(opt_val1083)
 		}
 		p.dedent()
 		p.write(")")
@@ -2899,50 +2899,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} {
-	flat1080 := p.tryFlat(msg, func() { p.pretty_monoid(msg) })
-	if flat1080 != nil {
-		p.write(*flat1080)
+	flat1093 := p.tryFlat(msg, func() { p.pretty_monoid(msg) })
+	if flat1093 != nil {
+		p.write(*flat1093)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1347 *pb.OrMonoid
+		var _t1373 *pb.OrMonoid
 		if hasProtoField(_dollar_dollar, "or_monoid") {
-			_t1347 = _dollar_dollar.GetOrMonoid()
+			_t1373 = _dollar_dollar.GetOrMonoid()
 		}
-		deconstruct_result1078 := _t1347
-		if deconstruct_result1078 != nil {
-			unwrapped1079 := deconstruct_result1078
-			p.pretty_or_monoid(unwrapped1079)
+		deconstruct_result1091 := _t1373
+		if deconstruct_result1091 != nil {
+			unwrapped1092 := deconstruct_result1091
+			p.pretty_or_monoid(unwrapped1092)
 		} else {
 			_dollar_dollar := msg
-			var _t1348 *pb.MinMonoid
+			var _t1374 *pb.MinMonoid
 			if hasProtoField(_dollar_dollar, "min_monoid") {
-				_t1348 = _dollar_dollar.GetMinMonoid()
+				_t1374 = _dollar_dollar.GetMinMonoid()
 			}
-			deconstruct_result1076 := _t1348
-			if deconstruct_result1076 != nil {
-				unwrapped1077 := deconstruct_result1076
-				p.pretty_min_monoid(unwrapped1077)
+			deconstruct_result1089 := _t1374
+			if deconstruct_result1089 != nil {
+				unwrapped1090 := deconstruct_result1089
+				p.pretty_min_monoid(unwrapped1090)
 			} else {
 				_dollar_dollar := msg
-				var _t1349 *pb.MaxMonoid
+				var _t1375 *pb.MaxMonoid
 				if hasProtoField(_dollar_dollar, "max_monoid") {
-					_t1349 = _dollar_dollar.GetMaxMonoid()
+					_t1375 = _dollar_dollar.GetMaxMonoid()
 				}
-				deconstruct_result1074 := _t1349
-				if deconstruct_result1074 != nil {
-					unwrapped1075 := deconstruct_result1074
-					p.pretty_max_monoid(unwrapped1075)
+				deconstruct_result1087 := _t1375
+				if deconstruct_result1087 != nil {
+					unwrapped1088 := deconstruct_result1087
+					p.pretty_max_monoid(unwrapped1088)
 				} else {
 					_dollar_dollar := msg
-					var _t1350 *pb.SumMonoid
+					var _t1376 *pb.SumMonoid
 					if hasProtoField(_dollar_dollar, "sum_monoid") {
-						_t1350 = _dollar_dollar.GetSumMonoid()
+						_t1376 = _dollar_dollar.GetSumMonoid()
 					}
-					deconstruct_result1072 := _t1350
-					if deconstruct_result1072 != nil {
-						unwrapped1073 := deconstruct_result1072
-						p.pretty_sum_monoid(unwrapped1073)
+					deconstruct_result1085 := _t1376
+					if deconstruct_result1085 != nil {
+						unwrapped1086 := deconstruct_result1085
+						p.pretty_sum_monoid(unwrapped1086)
 					} else {
 						panic(ParseError{msg: "No matching rule for monoid"})
 					}
@@ -2954,8 +2954,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} {
-	fields1081 := msg
-	_ = fields1081
+	fields1094 := msg
+	_ = fields1094
 	p.write("(")
 	p.write("or")
 	p.write(")")
@@ -2963,19 +2963,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} {
-	flat1084 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) })
-	if flat1084 != nil {
-		p.write(*flat1084)
+	flat1097 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) })
+	if flat1097 != nil {
+		p.write(*flat1097)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1082 := _dollar_dollar.GetType()
-		unwrapped_fields1083 := fields1082
+		fields1095 := _dollar_dollar.GetType()
+		unwrapped_fields1096 := fields1095
 		p.write("(")
 		p.write("min")
 		p.indentSexp()
 		p.newline()
-		p.pretty_type(unwrapped_fields1083)
+		p.pretty_type(unwrapped_fields1096)
 		p.dedent()
 		p.write(")")
 	}
@@ -2983,19 +2983,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} {
-	flat1087 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) })
-	if flat1087 != nil {
-		p.write(*flat1087)
+	flat1100 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) })
+	if flat1100 != nil {
+		p.write(*flat1100)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1085 := _dollar_dollar.GetType()
-		unwrapped_fields1086 := fields1085
+		fields1098 := _dollar_dollar.GetType()
+		unwrapped_fields1099 := fields1098
 		p.write("(")
 		p.write("max")
 		p.indentSexp()
 		p.newline()
-		p.pretty_type(unwrapped_fields1086)
+		p.pretty_type(unwrapped_fields1099)
 		p.dedent()
 		p.write(")")
 	}
@@ -3003,19 +3003,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} {
-	flat1090 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) })
-	if flat1090 != nil {
-		p.write(*flat1090)
+	flat1103 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) })
+	if flat1103 != nil {
+		p.write(*flat1103)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1088 := _dollar_dollar.GetType()
-		unwrapped_fields1089 := fields1088
+		fields1101 := _dollar_dollar.GetType()
+		unwrapped_fields1102 := fields1101
 		p.write("(")
 		p.write("sum")
 		p.indentSexp()
 		p.newline()
-		p.pretty_type(unwrapped_fields1089)
+		p.pretty_type(unwrapped_fields1102)
 		p.dedent()
 		p.write(")")
 	}
@@ -3023,35 +3023,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} {
-	flat1098 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) })
-	if flat1098 != nil {
-		p.write(*flat1098)
+	flat1111 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) })
+	if flat1111 != nil {
+		p.write(*flat1111)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1351 []*pb.Attribute
+		var _t1377 []*pb.Attribute
 		if !(len(_dollar_dollar.GetAttrs()) == 0) {
-			_t1351 = _dollar_dollar.GetAttrs()
+			_t1377 = _dollar_dollar.GetAttrs()
 		}
-		fields1091 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1351}
-		unwrapped_fields1092 := fields1091
+		fields1104 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1377}
+		unwrapped_fields1105 := fields1104
 		p.write("(")
 		p.write("monus")
 		p.indentSexp()
 		p.newline()
-		field1093 := unwrapped_fields1092[0].(*pb.Monoid)
-		p.pretty_monoid(field1093)
+		field1106 := unwrapped_fields1105[0].(*pb.Monoid)
+		p.pretty_monoid(field1106)
 		p.newline()
-		field1094 := unwrapped_fields1092[1].(*pb.RelationId)
-		p.pretty_relation_id(field1094)
+		field1107 := unwrapped_fields1105[1].(*pb.RelationId)
+		p.pretty_relation_id(field1107)
 		p.newline()
-		field1095 := unwrapped_fields1092[2].([]interface{})
-		p.pretty_abstraction_with_arity(field1095)
-		field1096 := unwrapped_fields1092[3].([]*pb.Attribute)
-		if field1096 != nil {
+		field1108 := unwrapped_fields1105[2].([]interface{})
+		p.pretty_abstraction_with_arity(field1108)
+		field1109 := unwrapped_fields1105[3].([]*pb.Attribute)
+		if field1109 != nil {
 			p.newline()
-			opt_val1097 := field1096
-			p.pretty_attrs(opt_val1097)
+			opt_val1110 := field1109
+			p.pretty_attrs(opt_val1110)
 		}
 		p.dedent()
 		p.write(")")
@@ -3060,29 +3060,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} {
-	flat1105 := p.tryFlat(msg, func() { p.pretty_constraint(msg) })
-	if flat1105 != nil {
-		p.write(*flat1105)
+	flat1118 := p.tryFlat(msg, func() { p.pretty_constraint(msg) })
+	if flat1118 != nil {
+		p.write(*flat1118)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1099 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()}
-		unwrapped_fields1100 := fields1099
+		fields1112 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()}
+		unwrapped_fields1113 := fields1112
 		p.write("(")
 		p.write("functional_dependency")
 		p.indentSexp()
 		p.newline()
-		field1101 := unwrapped_fields1100[0].(*pb.RelationId)
-		p.pretty_relation_id(field1101)
+		field1114 := unwrapped_fields1113[0].(*pb.RelationId)
+		p.pretty_relation_id(field1114)
 		p.newline()
-		field1102 := unwrapped_fields1100[1].(*pb.Abstraction)
-		p.pretty_abstraction(field1102)
+		field1115 := unwrapped_fields1113[1].(*pb.Abstraction)
+		p.pretty_abstraction(field1115)
 		p.newline()
-		field1103 := unwrapped_fields1100[2].([]*pb.Var)
-		p.pretty_functional_dependency_keys(field1103)
+		field1116 := unwrapped_fields1113[2].([]*pb.Var)
+		p.pretty_functional_dependency_keys(field1116)
 		p.newline()
-		field1104 := unwrapped_fields1100[3].([]*pb.Var)
-		p.pretty_functional_dependency_values(field1104)
+		field1117 := unwrapped_fields1113[3].([]*pb.Var)
+		p.pretty_functional_dependency_values(field1117)
 		p.dedent()
 		p.write(")")
 	}
@@ -3090,22 +3090,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} {
-	flat1109 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) })
-	if flat1109 != nil {
-		p.write(*flat1109)
+	flat1122 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) })
+	if flat1122 != nil {
+		p.write(*flat1122)
 		return nil
 	} else {
-		fields1106 := msg
+		fields1119 := msg
 		p.write("(")
 		p.write("keys")
 		p.indentSexp()
-		if !(len(fields1106) == 0) {
+		if !(len(fields1119) == 0) {
 			p.newline()
-			for i1108, elem1107 := range fields1106 {
-				if (i1108 > 0) {
+			for i1121, elem1120 := range fields1119 {
+				if (i1121 > 0) {
 					p.newline()
 				}
-				p.pretty_var(elem1107)
+				p.pretty_var(elem1120)
 			}
 		}
 		p.dedent()
@@ -3115,22 +3115,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa
 }
 
 func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} {
-	flat1113 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) })
-	if flat1113 != nil {
-		p.write(*flat1113)
+	flat1126 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) })
+	if flat1126 != nil {
+		p.write(*flat1126)
 		return nil
 	} else {
-		fields1110 := msg
+		fields1123 := msg
 		p.write("(")
 		p.write("values")
 		p.indentSexp()
-		if !(len(fields1110) == 0) {
+		if !(len(fields1123) == 0) {
 			p.newline()
-			for i1112, elem1111 := range fields1110 {
-				if (i1112 > 0) {
+			for i1125, elem1124 := range fields1123 {
+				if (i1125 > 0) {
 					p.newline()
 				}
-				p.pretty_var(elem1111)
+				p.pretty_var(elem1124)
 			}
 		}
 		p.dedent()
@@ -3140,40 +3140,40 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter
 }
 
 func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} {
-	flat1120 := p.tryFlat(msg, func() { p.pretty_data(msg) })
-	if flat1120 != nil {
-		p.write(*flat1120)
+	flat1133 := p.tryFlat(msg, func() { p.pretty_data(msg) })
+	if flat1133 != nil {
+		p.write(*flat1133)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1352 *pb.RelEDB
-		if hasProtoField(_dollar_dollar, "rel_edb") {
-			_t1352 = _dollar_dollar.GetRelEdb()
+		var _t1378 *pb.EDB
+		if hasProtoField(_dollar_dollar, "edb") {
+			_t1378 = _dollar_dollar.GetEdb()
 		}
-		deconstruct_result1118 := _t1352
-		if deconstruct_result1118 != nil {
-			unwrapped1119 := deconstruct_result1118
-			p.pretty_rel_edb(unwrapped1119)
+		deconstruct_result1131 := _t1378
+		if deconstruct_result1131 != nil {
+			unwrapped1132 := deconstruct_result1131
+			p.pretty_edb(unwrapped1132)
 		} else {
 			_dollar_dollar := msg
-			var _t1353 *pb.BeTreeRelation
+			var _t1379 *pb.BeTreeRelation
 			if hasProtoField(_dollar_dollar, "betree_relation") {
-				_t1353 = _dollar_dollar.GetBetreeRelation()
+				_t1379 = _dollar_dollar.GetBetreeRelation()
 			}
-			deconstruct_result1116 := _t1353
-			if deconstruct_result1116 != nil {
-				unwrapped1117 := deconstruct_result1116
-				p.pretty_betree_relation(unwrapped1117)
+			deconstruct_result1129 := _t1379
+			if deconstruct_result1129 != nil {
+				unwrapped1130 := deconstruct_result1129
+				p.pretty_betree_relation(unwrapped1130)
 			} else {
 				_dollar_dollar := msg
-				var _t1354 *pb.CSVData
+				var _t1380 *pb.CSVData
 				if hasProtoField(_dollar_dollar, "csv_data") {
-					_t1354 = _dollar_dollar.GetCsvData()
+					_t1380 = _dollar_dollar.GetCsvData()
 				}
-				deconstruct_result1114 := _t1354
-				if deconstruct_result1114 != nil {
-					unwrapped1115 := deconstruct_result1114
-					p.pretty_csv_data(unwrapped1115)
+				deconstruct_result1127 := _t1380
+				if deconstruct_result1127 != nil {
+					unwrapped1128 := deconstruct_result1127
+					p.pretty_csv_data(unwrapped1128)
 				} else {
 					panic(ParseError{msg: "No matching rule for data"})
 				}
@@ -3183,47 +3183,47 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} {
 	return nil
 }
 
-func (p *PrettyPrinter) pretty_rel_edb(msg *pb.RelEDB) interface{} {
-	flat1126 := p.tryFlat(msg, func() { p.pretty_rel_edb(msg) })
-	if flat1126 != nil {
-		p.write(*flat1126)
+func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} {
+	flat1139 := p.tryFlat(msg, func() { p.pretty_edb(msg) })
+	if flat1139 != nil {
+		p.write(*flat1139)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1121 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()}
-		unwrapped_fields1122 := fields1121
+		fields1134 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()}
+		unwrapped_fields1135 := fields1134
 		p.write("(")
-		p.write("rel_edb")
+		p.write("edb")
 		p.indentSexp()
 		p.newline()
-		field1123 := unwrapped_fields1122[0].(*pb.RelationId)
-		p.pretty_relation_id(field1123)
+		field1136 := unwrapped_fields1135[0].(*pb.RelationId)
+		p.pretty_relation_id(field1136)
 		p.newline()
-		field1124 := unwrapped_fields1122[1].([]string)
-		p.pretty_rel_edb_path(field1124)
+		field1137 := unwrapped_fields1135[1].([]string)
+		p.pretty_edb_path(field1137)
 		p.newline()
-		field1125 := unwrapped_fields1122[2].([]*pb.Type)
-		p.pretty_rel_edb_types(field1125)
+		field1138 := unwrapped_fields1135[2].([]*pb.Type)
+		p.pretty_edb_types(field1138)
 		p.dedent()
 		p.write(")")
 	}
 	return nil
 }
 
-func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} {
-	flat1130 := p.tryFlat(msg, func() { p.pretty_rel_edb_path(msg) })
-	if flat1130 != nil {
-		p.write(*flat1130)
+func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} {
+	flat1143 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) })
+	if flat1143 != nil {
+		p.write(*flat1143)
 		return nil
 	} else {
-		fields1127 := msg
+		fields1140 := msg
 		p.write("[")
 		p.indent()
-		for i1129, elem1128 := range fields1127 {
-			if (i1129 > 0) {
+		for i1142, elem1141 := range fields1140 {
+			if (i1142 > 0) {
 				p.newline()
 			}
-			p.write(p.formatStringValue(elem1128))
+			p.write(p.formatStringValue(elem1141))
 		}
 		p.dedent()
 		p.write("]")
@@ -3231,20 +3231,20 @@ func (p *PrettyPrinter) pretty_rel_edb_path(msg []string) interface{} {
 	return nil
 }
 
-func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} {
-	flat1134 := p.tryFlat(msg, func() { p.pretty_rel_edb_types(msg) })
-	if flat1134 != nil {
-		p.write(*flat1134)
+func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} {
+	flat1147 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) })
+	if flat1147 != nil {
+		p.write(*flat1147)
 		return nil
 	} else {
-		fields1131 := msg
+		fields1144 := msg
 		p.write("[")
 		p.indent()
-		for i1133, elem1132 := range fields1131 {
-			if (i1133 > 0) {
+		for i1146, elem1145 := range fields1144 {
+			if (i1146 > 0) {
 				p.newline()
 			}
-			p.pretty_type(elem1132)
+			p.pretty_type(elem1145)
 		}
 		p.dedent()
 		p.write("]")
@@ -3253,23 +3253,23 @@ func (p *PrettyPrinter) pretty_rel_edb_types(msg []*pb.Type) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} {
-	flat1139 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) })
-	if flat1139 != nil {
-		p.write(*flat1139)
+	flat1152 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) })
+	if flat1152 != nil {
+		p.write(*flat1152)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1135 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()}
-		unwrapped_fields1136 := fields1135
+		fields1148 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()}
+		unwrapped_fields1149 := fields1148
 		p.write("(")
 		p.write("betree_relation")
 		p.indentSexp()
 		p.newline()
-		field1137 := unwrapped_fields1136[0].(*pb.RelationId)
-		p.pretty_relation_id(field1137)
+		field1150 := unwrapped_fields1149[0].(*pb.RelationId)
+		p.pretty_relation_id(field1150)
 		p.newline()
-		field1138 := unwrapped_fields1136[1].(*pb.BeTreeInfo)
-		p.pretty_betree_info(field1138)
+		field1151 := unwrapped_fields1149[1].(*pb.BeTreeInfo)
+		p.pretty_betree_info(field1151)
 		p.dedent()
 		p.write(")")
 	}
@@ -3277,27 +3277,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface
 }
 
 func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} {
-	flat1145 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) })
-	if flat1145 != nil {
-		p.write(*flat1145)
+	flat1158 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) })
+	if flat1158 != nil {
+		p.write(*flat1158)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1355 := p.deconstruct_betree_info_config(_dollar_dollar)
-		fields1140 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1355}
-		unwrapped_fields1141 := fields1140
+		_t1381 := p.deconstruct_betree_info_config(_dollar_dollar)
+		fields1153 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1381}
+		unwrapped_fields1154 := fields1153
 		p.write("(")
 		p.write("betree_info")
 		p.indentSexp()
 		p.newline()
-		field1142 := unwrapped_fields1141[0].([]*pb.Type)
-		p.pretty_betree_info_key_types(field1142)
+		field1155 := unwrapped_fields1154[0].([]*pb.Type)
+		p.pretty_betree_info_key_types(field1155)
 		p.newline()
-		field1143 := unwrapped_fields1141[1].([]*pb.Type)
-		p.pretty_betree_info_value_types(field1143)
+		field1156 := unwrapped_fields1154[1].([]*pb.Type)
+		p.pretty_betree_info_value_types(field1156)
 		p.newline()
-		field1144 := unwrapped_fields1141[2].([][]interface{})
-		p.pretty_config_dict(field1144)
+		field1157 := unwrapped_fields1154[2].([][]interface{})
+		p.pretty_config_dict(field1157)
 		p.dedent()
 		p.write(")")
 	}
@@ -3305,22 +3305,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} {
-	flat1149 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) })
-	if flat1149 != nil {
-		p.write(*flat1149)
+	flat1162 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) })
+	if flat1162 != nil {
+		p.write(*flat1162)
 		return nil
 	} else {
-		fields1146 := msg
+		fields1159 := msg
 		p.write("(")
 		p.write("key_types")
 		p.indentSexp()
-		if !(len(fields1146) == 0) {
+		if !(len(fields1159) == 0) {
 			p.newline()
-			for i1148, elem1147 := range fields1146 {
-				if (i1148 > 0) {
+			for i1161, elem1160 := range fields1159 {
+				if (i1161 > 0) {
 					p.newline()
 				}
-				p.pretty_type(elem1147)
+				p.pretty_type(elem1160)
 			}
 		}
 		p.dedent()
@@ -3330,22 +3330,22 @@ func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{}
 }
 
 func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface{} {
-	flat1153 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) })
-	if flat1153 != nil {
-		p.write(*flat1153)
+	flat1166 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) })
+	if flat1166 != nil {
+		p.write(*flat1166)
 		return nil
 	} else {
-		fields1150 := msg
+		fields1163 := msg
 		p.write("(")
 		p.write("value_types")
 		p.indentSexp()
-		if !(len(fields1150) == 0) {
+		if !(len(fields1163) == 0) {
 			p.newline()
-			for i1152, elem1151 := range fields1150 {
-				if (i1152 > 0) {
+			for i1165, elem1164 := range fields1163 {
+				if (i1165 > 0) {
 					p.newline()
 				}
-				p.pretty_type(elem1151)
+				p.pretty_type(elem1164)
 			}
 		}
 		p.dedent()
@@ -3355,29 +3355,29 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface
 }
 
 func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} {
-	flat1160 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) })
-	if flat1160 != nil {
-		p.write(*flat1160)
+	flat1173 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) })
+	if flat1173 != nil {
+		p.write(*flat1173)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1154 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()}
-		unwrapped_fields1155 := fields1154
+		fields1167 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()}
+		unwrapped_fields1168 := fields1167
 		p.write("(")
 		p.write("csv_data")
 		p.indentSexp()
 		p.newline()
-		field1156 := unwrapped_fields1155[0].(*pb.CSVLocator)
-		p.pretty_csvlocator(field1156)
+		field1169 := unwrapped_fields1168[0].(*pb.CSVLocator)
+		p.pretty_csvlocator(field1169)
 		p.newline()
-		field1157 := unwrapped_fields1155[1].(*pb.CSVConfig)
-		p.pretty_csv_config(field1157)
+		field1170 := unwrapped_fields1168[1].(*pb.CSVConfig)
+		p.pretty_csv_config(field1170)
 		p.newline()
-		field1158 := unwrapped_fields1155[2].([]*pb.CSVColumn)
-		p.pretty_csv_columns(field1158)
+		field1171 := unwrapped_fields1168[2].([]*pb.GNFColumn)
+		p.pretty_gnf_columns(field1171)
 		p.newline()
-		field1159 := unwrapped_fields1155[3].(string)
-		p.pretty_csv_asof(field1159)
+		field1172 := unwrapped_fields1168[3].(string)
+		p.pretty_csv_asof(field1172)
 		p.dedent()
 		p.write(")")
 	}
@@ -3385,36 +3385,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} {
-	flat1167 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) })
-	if flat1167 != nil {
-		p.write(*flat1167)
+	flat1180 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) })
+	if flat1180 != nil {
+		p.write(*flat1180)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1356 []string
+		var _t1382 []string
 		if !(len(_dollar_dollar.GetPaths()) == 0) {
-			_t1356 = _dollar_dollar.GetPaths()
+			_t1382 = _dollar_dollar.GetPaths()
 		}
-		var _t1357 *string
+		var _t1383 *string
 		if string(_dollar_dollar.GetInlineData()) != "" {
-			_t1357 = ptr(string(_dollar_dollar.GetInlineData()))
+			_t1383 = ptr(string(_dollar_dollar.GetInlineData()))
 		}
-		fields1161 := []interface{}{_t1356, _t1357}
-		unwrapped_fields1162 := fields1161
+		fields1174 := []interface{}{_t1382, _t1383}
+		unwrapped_fields1175 := fields1174
 		p.write("(")
 		p.write("csv_locator")
 		p.indentSexp()
-		field1163 := unwrapped_fields1162[0].([]string)
-		if field1163 != nil {
+		field1176 := unwrapped_fields1175[0].([]string)
+		if field1176 != nil {
 			p.newline()
-			opt_val1164 := field1163
-			p.pretty_csv_locator_paths(opt_val1164)
+			opt_val1177 := field1176
+			p.pretty_csv_locator_paths(opt_val1177)
 		}
-		field1165 := unwrapped_fields1162[1].(*string)
-		if field1165 != nil {
+		field1178 := unwrapped_fields1175[1].(*string)
+		if field1178 != nil {
 			p.newline()
-			opt_val1166 := *field1165
-			p.pretty_csv_locator_inline_data(opt_val1166)
+			opt_val1179 := *field1178
+			p.pretty_csv_locator_inline_data(opt_val1179)
 		}
 		p.dedent()
 		p.write(")")
@@ -3423,22 +3423,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} {
-	flat1171 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) })
-	if flat1171 != nil {
-		p.write(*flat1171)
+	flat1184 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) })
+	if flat1184 != nil {
+		p.write(*flat1184)
 		return nil
 	} else {
-		fields1168 := msg
+		fields1181 := msg
 		p.write("(")
 		p.write("paths")
 		p.indentSexp()
-		if !(len(fields1168) == 0) {
+		if !(len(fields1181) == 0) {
 			p.newline()
-			for i1170, elem1169 := range fields1168 {
-				if (i1170 > 0) {
+			for i1183, elem1182 := range fields1181 {
+				if (i1183 > 0) {
 					p.newline()
 				}
-				p.write(p.formatStringValue(elem1169))
+				p.write(p.formatStringValue(elem1182))
 			}
 		}
 		p.dedent()
@@ -3448,17 +3448,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} {
-	flat1173 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) })
-	if flat1173 != nil {
-		p.write(*flat1173)
+	flat1186 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) })
+	if flat1186 != nil {
+		p.write(*flat1186)
 		return nil
 	} else {
-		fields1172 := msg
+		fields1185 := msg
 		p.write("(")
 		p.write("inline_data")
 		p.indentSexp()
 		p.newline()
-		p.write(p.formatStringValue(fields1172))
+		p.write(p.formatStringValue(fields1185))
 		p.dedent()
 		p.write(")")
 	}
@@ -3466,43 +3466,43 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} {
-	flat1176 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) })
-	if flat1176 != nil {
-		p.write(*flat1176)
+	flat1189 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) })
+	if flat1189 != nil {
+		p.write(*flat1189)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1358 := p.deconstruct_csv_config(_dollar_dollar)
-		fields1174 := _t1358
-		unwrapped_fields1175 := fields1174
+		_t1384 := p.deconstruct_csv_config(_dollar_dollar)
+		fields1187 := _t1384
+		unwrapped_fields1188 := fields1187
 		p.write("(")
 		p.write("csv_config")
 		p.indentSexp()
 		p.newline()
-		p.pretty_config_dict(unwrapped_fields1175)
+		p.pretty_config_dict(unwrapped_fields1188)
 		p.dedent()
 		p.write(")")
 	}
 	return nil
 }
 
-func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} {
-	flat1180 := p.tryFlat(msg, func() { p.pretty_csv_columns(msg) })
-	if flat1180 != nil {
-		p.write(*flat1180)
+func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} {
+	flat1193 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) })
+	if flat1193 != nil {
+		p.write(*flat1193)
 		return nil
 	} else {
-		fields1177 := msg
+		fields1190 := msg
 		p.write("(")
 		p.write("columns")
 		p.indentSexp()
-		if !(len(fields1177) == 0) {
+		if !(len(fields1190) == 0) {
 			p.newline()
-			for i1179, elem1178 := range fields1177 {
-				if (i1179 > 0) {
+			for i1192, elem1191 := range fields1190 {
+				if (i1192 > 0) {
 					p.newline()
 				}
-				p.pretty_csv_column(elem1178)
+				p.pretty_gnf_column(elem1191)
 			}
 		}
 		p.dedent()
@@ -3511,32 +3511,39 @@ func (p *PrettyPrinter) pretty_csv_columns(msg []*pb.CSVColumn) interface{} {
 	return nil
 }
 
-func (p *PrettyPrinter) pretty_csv_column(msg *pb.CSVColumn) interface{} {
-	flat1188 := p.tryFlat(msg, func() { p.pretty_csv_column(msg) })
-	if flat1188 != nil {
-		p.write(*flat1188)
+func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} {
+	flat1202 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) })
+	if flat1202 != nil {
+		p.write(*flat1202)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1181 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetTargetId(), _dollar_dollar.GetTypes()}
-		unwrapped_fields1182 := fields1181
+		var _t1385 *pb.RelationId
+		if hasProtoField(_dollar_dollar, "target_id") {
+			_t1385 = _dollar_dollar.GetTargetId()
+		}
+		fields1194 := []interface{}{_dollar_dollar.GetColumnPath(), _t1385, _dollar_dollar.GetTypes()}
+		unwrapped_fields1195 := fields1194
 		p.write("(")
 		p.write("column")
 		p.indentSexp()
 		p.newline()
-		field1183 := unwrapped_fields1182[0].(string)
-		p.write(p.formatStringValue(field1183))
-		p.newline()
-		field1184 := unwrapped_fields1182[1].(*pb.RelationId)
-		p.pretty_relation_id(field1184)
+		field1196 := unwrapped_fields1195[0].([]string)
+		p.pretty_gnf_column_path(field1196)
+		field1197 := unwrapped_fields1195[1].(*pb.RelationId)
+		if field1197 != nil {
+			p.newline()
+			opt_val1198 := field1197
+			p.pretty_relation_id(opt_val1198)
+		}
 		p.newline()
 		p.write("[")
-		field1185 := unwrapped_fields1182[2].([]*pb.Type)
-		for i1187, elem1186 := range field1185 {
-			if (i1187 > 0) {
+		field1199 := unwrapped_fields1195[2].([]*pb.Type)
+		for i1201, elem1200 := range field1199 {
+			if (i1201 > 0) {
 				p.newline()
 			}
-			p.pretty_type(elem1186)
+			p.pretty_type(elem1200)
 		}
 		p.write("]")
 		p.dedent()
@@ -3545,18 +3552,60 @@ func (p *PrettyPrinter) pretty_csv_column(msg *pb.CSVColumn) interface{} {
 	return nil
 }
 
+func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} {
+	flat1209 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) })
+	if flat1209 != nil {
+		p.write(*flat1209)
+		return nil
+	} else {
+		_dollar_dollar := msg
+		var _t1386 *string
+		if int64(len(_dollar_dollar)) == 1 {
+			_t1386 = ptr(_dollar_dollar[0])
+		}
+		deconstruct_result1207 := _t1386
+		if deconstruct_result1207 != nil {
+			unwrapped1208 := *deconstruct_result1207
+			p.write(p.formatStringValue(unwrapped1208))
+		} else {
+			_dollar_dollar := msg
+			var _t1387 []string
+			if int64(len(_dollar_dollar)) != 1 {
+				_t1387 = _dollar_dollar
+			}
+			deconstruct_result1203 := _t1387
+			if deconstruct_result1203 != nil {
+				unwrapped1204 := deconstruct_result1203
+				p.write("[")
+				p.indent()
+				for i1206, elem1205 := range unwrapped1204 {
+					if (i1206 > 0) {
+						p.newline()
+					}
+					p.write(p.formatStringValue(elem1205))
+				}
+				p.dedent()
+				p.write("]")
+			} else {
+				panic(ParseError{msg: "No matching rule for gnf_column_path"})
+			}
+		}
+	}
+	return nil
+}
+
 func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} {
-	flat1190 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) })
-	if flat1190 != nil {
-		p.write(*flat1190)
+	flat1211 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) })
+	if flat1211 != nil {
+		p.write(*flat1211)
 		return nil
 	} else {
-		fields1189 := msg
+		fields1210 := msg
 		p.write("(")
 		p.write("asof")
 		p.indentSexp()
 		p.newline()
-		p.write(p.formatStringValue(fields1189))
+		p.write(p.formatStringValue(fields1210))
 		p.dedent()
 		p.write(")")
 	}
@@ -3564,19 +3613,19 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} {
-	flat1193 := p.tryFlat(msg, func() { p.pretty_undefine(msg) })
-	if flat1193 != nil {
-		p.write(*flat1193)
+	flat1214 := p.tryFlat(msg, func() { p.pretty_undefine(msg) })
+	if flat1214 != nil {
+		p.write(*flat1214)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1191 := _dollar_dollar.GetFragmentId()
-		unwrapped_fields1192 := fields1191
+		fields1212 := _dollar_dollar.GetFragmentId()
+		unwrapped_fields1213 := fields1212
 		p.write("(")
 		p.write("undefine")
 		p.indentSexp()
 		p.newline()
-		p.pretty_fragment_id(unwrapped_fields1192)
+		p.pretty_fragment_id(unwrapped_fields1213)
 		p.dedent()
 		p.write(")")
 	}
@@ -3584,24 +3633,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} {
-	flat1198 := p.tryFlat(msg, func() { p.pretty_context(msg) })
-	if flat1198 != nil {
-		p.write(*flat1198)
+	flat1219 := p.tryFlat(msg, func() { p.pretty_context(msg) })
+	if flat1219 != nil {
+		p.write(*flat1219)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1194 := _dollar_dollar.GetRelations()
-		unwrapped_fields1195 := fields1194
+		fields1215 := _dollar_dollar.GetRelations()
+		unwrapped_fields1216 := fields1215
 		p.write("(")
 		p.write("context")
 		p.indentSexp()
-		if !(len(unwrapped_fields1195) == 0) {
+		if !(len(unwrapped_fields1216) == 0) {
 			p.newline()
-			for i1197, elem1196 := range unwrapped_fields1195 {
-				if (i1197 > 0) {
+			for i1218, elem1217 := range unwrapped_fields1216 {
+				if (i1218 > 0) {
 					p.newline()
 				}
-				p.pretty_relation_id(elem1196)
+				p.pretty_relation_id(elem1217)
 			}
 		}
 		p.dedent()
@@ -3611,46 +3660,67 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} {
-	flat1203 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) })
-	if flat1203 != nil {
-		p.write(*flat1203)
+	flat1224 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) })
+	if flat1224 != nil {
+		p.write(*flat1224)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1199 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()}
-		unwrapped_fields1200 := fields1199
+		fields1220 := _dollar_dollar.GetMappings()
+		unwrapped_fields1221 := fields1220
 		p.write("(")
 		p.write("snapshot")
 		p.indentSexp()
-		p.newline()
-		field1201 := unwrapped_fields1200[0].([]string)
-		p.pretty_rel_edb_path(field1201)
-		p.newline()
-		field1202 := unwrapped_fields1200[1].(*pb.RelationId)
-		p.pretty_relation_id(field1202)
+		if !(len(unwrapped_fields1221) == 0) {
+			p.newline()
+			for i1223, elem1222 := range unwrapped_fields1221 {
+				if (i1223 > 0) {
+					p.newline()
+				}
+				p.pretty_snapshot_mapping(elem1222)
+			}
+		}
 		p.dedent()
 		p.write(")")
 	}
 	return nil
 }
 
+func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} {
+	flat1229 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) })
+	if flat1229 != nil {
+		p.write(*flat1229)
+		return nil
+	} else {
+		_dollar_dollar := msg
+		fields1225 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()}
+		unwrapped_fields1226 := fields1225
+		field1227 := unwrapped_fields1226[0].([]string)
+		p.pretty_edb_path(field1227)
+		p.write(" ")
+		field1228 := unwrapped_fields1226[1].(*pb.RelationId)
+		p.pretty_relation_id(field1228)
+	}
+	return nil
+}
+
 func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} {
-	flat1207 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) })
-	if flat1207 != nil {
-		p.write(*flat1207)
+	flat1233 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) })
+	if flat1233 != nil {
+		p.write(*flat1233)
 		return nil
 	} else {
-		fields1204 := msg
+		fields1230 := msg
 		p.write("(")
 		p.write("reads")
 		p.indentSexp()
-		if !(len(fields1204) == 0) {
+		if !(len(fields1230) == 0) {
 			p.newline()
-			for i1206, elem1205 := range fields1204 {
-				if (i1206 > 0) {
+			for i1232, elem1231 := range fields1230 {
+				if (i1232 > 0) {
 					p.newline()
 				}
-				p.pretty_read(elem1205)
+				p.pretty_read(elem1231)
 			}
 		}
 		p.dedent()
@@ -3660,60 +3730,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} {
-	flat1218 := p.tryFlat(msg, func() { p.pretty_read(msg) })
-	if flat1218 != nil {
-		p.write(*flat1218)
+	flat1244 := p.tryFlat(msg, func() { p.pretty_read(msg) })
+	if flat1244 != nil {
+		p.write(*flat1244)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1359 *pb.Demand
+		var _t1388 *pb.Demand
 		if hasProtoField(_dollar_dollar, "demand") {
-			_t1359 = _dollar_dollar.GetDemand()
+			_t1388 = _dollar_dollar.GetDemand()
 		}
-		deconstruct_result1216 := _t1359
-		if deconstruct_result1216 != nil {
-			unwrapped1217 := deconstruct_result1216
-			p.pretty_demand(unwrapped1217)
+		deconstruct_result1242 := _t1388
+		if deconstruct_result1242 != nil {
+			unwrapped1243 := deconstruct_result1242
+			p.pretty_demand(unwrapped1243)
 		} else {
 			_dollar_dollar := msg
-			var _t1360 *pb.Output
+			var _t1389 *pb.Output
 			if hasProtoField(_dollar_dollar, "output") {
-				_t1360 = _dollar_dollar.GetOutput()
+				_t1389 = _dollar_dollar.GetOutput()
 			}
-			deconstruct_result1214 := _t1360
-			if deconstruct_result1214 != nil {
-				unwrapped1215 := deconstruct_result1214
-				p.pretty_output(unwrapped1215)
+			deconstruct_result1240 := _t1389
+			if deconstruct_result1240 != nil {
+				unwrapped1241 := deconstruct_result1240
+				p.pretty_output(unwrapped1241)
 			} else {
 				_dollar_dollar := msg
-				var _t1361 *pb.WhatIf
+				var _t1390 *pb.WhatIf
 				if hasProtoField(_dollar_dollar, "what_if") {
-					_t1361 = _dollar_dollar.GetWhatIf()
+					_t1390 = _dollar_dollar.GetWhatIf()
 				}
-				deconstruct_result1212 := _t1361
-				if deconstruct_result1212 != nil {
-					unwrapped1213 := deconstruct_result1212
-					p.pretty_what_if(unwrapped1213)
+				deconstruct_result1238 := _t1390
+				if deconstruct_result1238 != nil {
+					unwrapped1239 := deconstruct_result1238
+					p.pretty_what_if(unwrapped1239)
 				} else {
 					_dollar_dollar := msg
-					var _t1362 *pb.Abort
+					var _t1391 *pb.Abort
 					if hasProtoField(_dollar_dollar, "abort") {
-						_t1362 = _dollar_dollar.GetAbort()
+						_t1391 = _dollar_dollar.GetAbort()
 					}
-					deconstruct_result1210 := _t1362
-					if deconstruct_result1210 != nil {
-						unwrapped1211 := deconstruct_result1210
-						p.pretty_abort(unwrapped1211)
+					deconstruct_result1236 := _t1391
+					if deconstruct_result1236 != nil {
+						unwrapped1237 := deconstruct_result1236
+						p.pretty_abort(unwrapped1237)
 					} else {
 						_dollar_dollar := msg
-						var _t1363 *pb.Export
+						var _t1392 *pb.Export
 						if hasProtoField(_dollar_dollar, "export") {
-							_t1363 = _dollar_dollar.GetExport()
+							_t1392 = _dollar_dollar.GetExport()
 						}
-						deconstruct_result1208 := _t1363
-						if deconstruct_result1208 != nil {
-							unwrapped1209 := deconstruct_result1208
-							p.pretty_export(unwrapped1209)
+						deconstruct_result1234 := _t1392
+						if deconstruct_result1234 != nil {
+							unwrapped1235 := deconstruct_result1234
+							p.pretty_export(unwrapped1235)
 						} else {
 							panic(ParseError{msg: "No matching rule for read"})
 						}
@@ -3726,19 +3796,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} {
-	flat1221 := p.tryFlat(msg, func() { p.pretty_demand(msg) })
-	if flat1221 != nil {
-		p.write(*flat1221)
+	flat1247 := p.tryFlat(msg, func() { p.pretty_demand(msg) })
+	if flat1247 != nil {
+		p.write(*flat1247)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1219 := _dollar_dollar.GetRelationId()
-		unwrapped_fields1220 := fields1219
+		fields1245 := _dollar_dollar.GetRelationId()
+		unwrapped_fields1246 := fields1245
 		p.write("(")
 		p.write("demand")
 		p.indentSexp()
 		p.newline()
-		p.pretty_relation_id(unwrapped_fields1220)
+		p.pretty_relation_id(unwrapped_fields1246)
 		p.dedent()
 		p.write(")")
 	}
@@ -3746,23 +3816,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} {
-	flat1226 := p.tryFlat(msg, func() { p.pretty_output(msg) })
-	if flat1226 != nil {
-		p.write(*flat1226)
+	flat1252 := p.tryFlat(msg, func() { p.pretty_output(msg) })
+	if flat1252 != nil {
+		p.write(*flat1252)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1222 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()}
-		unwrapped_fields1223 := fields1222
+		fields1248 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()}
+		unwrapped_fields1249 := fields1248
 		p.write("(")
 		p.write("output")
 		p.indentSexp()
 		p.newline()
-		field1224 := unwrapped_fields1223[0].(string)
-		p.pretty_name(field1224)
+		field1250 := unwrapped_fields1249[0].(string)
+		p.pretty_name(field1250)
 		p.newline()
-		field1225 := unwrapped_fields1223[1].(*pb.RelationId)
-		p.pretty_relation_id(field1225)
+		field1251 := unwrapped_fields1249[1].(*pb.RelationId)
+		p.pretty_relation_id(field1251)
 		p.dedent()
 		p.write(")")
 	}
@@ -3770,23 +3840,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} {
-	flat1231 := p.tryFlat(msg, func() { p.pretty_what_if(msg) })
-	if flat1231 != nil {
-		p.write(*flat1231)
+	flat1257 := p.tryFlat(msg, func() { p.pretty_what_if(msg) })
+	if flat1257 != nil {
+		p.write(*flat1257)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1227 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()}
-		unwrapped_fields1228 := fields1227
+		fields1253 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()}
+		unwrapped_fields1254 := fields1253
 		p.write("(")
 		p.write("what_if")
 		p.indentSexp()
 		p.newline()
-		field1229 := unwrapped_fields1228[0].(string)
-		p.pretty_name(field1229)
+		field1255 := unwrapped_fields1254[0].(string)
+		p.pretty_name(field1255)
 		p.newline()
-		field1230 := unwrapped_fields1228[1].(*pb.Epoch)
-		p.pretty_epoch(field1230)
+		field1256 := unwrapped_fields1254[1].(*pb.Epoch)
+		p.pretty_epoch(field1256)
 		p.dedent()
 		p.write(")")
 	}
@@ -3794,30 +3864,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} {
-	flat1237 := p.tryFlat(msg, func() { p.pretty_abort(msg) })
-	if flat1237 != nil {
-		p.write(*flat1237)
+	flat1263 := p.tryFlat(msg, func() { p.pretty_abort(msg) })
+	if flat1263 != nil {
+		p.write(*flat1263)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		var _t1364 *string
+		var _t1393 *string
 		if _dollar_dollar.GetName() != "abort" {
-			_t1364 = ptr(_dollar_dollar.GetName())
+			_t1393 = ptr(_dollar_dollar.GetName())
 		}
-		fields1232 := []interface{}{_t1364, _dollar_dollar.GetRelationId()}
-		unwrapped_fields1233 := fields1232
+		fields1258 := []interface{}{_t1393, _dollar_dollar.GetRelationId()}
+		unwrapped_fields1259 := fields1258
 		p.write("(")
 		p.write("abort")
 		p.indentSexp()
-		field1234 := unwrapped_fields1233[0].(*string)
-		if field1234 != nil {
+		field1260 := unwrapped_fields1259[0].(*string)
+		if field1260 != nil {
 			p.newline()
-			opt_val1235 := *field1234
-			p.pretty_name(opt_val1235)
+			opt_val1261 := *field1260
+			p.pretty_name(opt_val1261)
 		}
 		p.newline()
-		field1236 := unwrapped_fields1233[1].(*pb.RelationId)
-		p.pretty_relation_id(field1236)
+		field1262 := unwrapped_fields1259[1].(*pb.RelationId)
+		p.pretty_relation_id(field1262)
 		p.dedent()
 		p.write(")")
 	}
@@ -3825,19 +3895,19 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} {
-	flat1240 := p.tryFlat(msg, func() { p.pretty_export(msg) })
-	if flat1240 != nil {
-		p.write(*flat1240)
+	flat1266 := p.tryFlat(msg, func() { p.pretty_export(msg) })
+	if flat1266 != nil {
+		p.write(*flat1266)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1238 := _dollar_dollar.GetCsvConfig()
-		unwrapped_fields1239 := fields1238
+		fields1264 := _dollar_dollar.GetCsvConfig()
+		unwrapped_fields1265 := fields1264
 		p.write("(")
 		p.write("export")
 		p.indentSexp()
 		p.newline()
-		p.pretty_export_csv_config(unwrapped_fields1239)
+		p.pretty_export_csv_config(unwrapped_fields1265)
 		p.dedent()
 		p.write(")")
 	}
@@ -3845,27 +3915,27 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} {
-	flat1246 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) })
-	if flat1246 != nil {
-		p.write(*flat1246)
+	flat1272 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) })
+	if flat1272 != nil {
+		p.write(*flat1272)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		_t1365 := p.deconstruct_export_csv_config(_dollar_dollar)
-		fields1241 := []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1365}
-		unwrapped_fields1242 := fields1241
+		_t1394 := p.deconstruct_export_csv_config(_dollar_dollar)
+		fields1267 := []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1394}
+		unwrapped_fields1268 := fields1267
 		p.write("(")
 		p.write("export_csv_config")
 		p.indentSexp()
 		p.newline()
-		field1243 := unwrapped_fields1242[0].(string)
-		p.pretty_export_csv_path(field1243)
+		field1269 := unwrapped_fields1268[0].(string)
+		p.pretty_export_csv_path(field1269)
 		p.newline()
-		field1244 := unwrapped_fields1242[1].([]*pb.ExportCSVColumn)
-		p.pretty_export_csv_columns(field1244)
+		field1270 := unwrapped_fields1268[1].([]*pb.ExportCSVColumn)
+		p.pretty_export_csv_columns(field1270)
 		p.newline()
-		field1245 := unwrapped_fields1242[2].([][]interface{})
-		p.pretty_config_dict(field1245)
+		field1271 := unwrapped_fields1268[2].([][]interface{})
+		p.pretty_config_dict(field1271)
 		p.dedent()
 		p.write(")")
 	}
@@ -3873,17 +3943,17 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf
 }
 
 func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} {
-	flat1248 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) })
-	if flat1248 != nil {
-		p.write(*flat1248)
+	flat1274 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) })
+	if flat1274 != nil {
+		p.write(*flat1274)
 		return nil
 	} else {
-		fields1247 := msg
+		fields1273 := msg
 		p.write("(")
 		p.write("path")
 		p.indentSexp()
 		p.newline()
-		p.write(p.formatStringValue(fields1247))
+		p.write(p.formatStringValue(fields1273))
 		p.dedent()
 		p.write(")")
 	}
@@ -3891,22 +3961,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} {
 }
 
 func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) interface{} {
-	flat1252 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) })
-	if flat1252 != nil {
-		p.write(*flat1252)
+	flat1278 := p.tryFlat(msg, func() { p.pretty_export_csv_columns(msg) })
+	if flat1278 != nil {
+		p.write(*flat1278)
 		return nil
 	} else {
-		fields1249 := msg
+		fields1275 := msg
 		p.write("(")
 		p.write("columns")
 		p.indentSexp()
-		if !(len(fields1249) == 0) {
+		if !(len(fields1275) == 0) {
 			p.newline()
-			for i1251, elem1250 := range fields1249 {
-				if (i1251 > 0) {
+			for i1277, elem1276 := range fields1275 {
+				if (i1277 > 0) {
 					p.newline()
 				}
-				p.pretty_export_csv_column(elem1250)
+				p.pretty_export_csv_column(elem1276)
 			}
 		}
 		p.dedent()
@@ -3916,23 +3986,23 @@ func (p *PrettyPrinter) pretty_export_csv_columns(msg []*pb.ExportCSVColumn) int
 }
 
 func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} {
-	flat1257 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) })
-	if flat1257 != nil {
-		p.write(*flat1257)
+	flat1283 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) })
+	if flat1283 != nil {
+		p.write(*flat1283)
 		return nil
 	} else {
 		_dollar_dollar := msg
-		fields1253 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()}
-		unwrapped_fields1254 := fields1253
+		fields1279 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()}
+		unwrapped_fields1280 := fields1279
 		p.write("(")
 		p.write("column")
 		p.indentSexp()
 		p.newline()
-		field1255 := unwrapped_fields1254[0].(string)
-		p.write(p.formatStringValue(field1255))
+		field1281 := unwrapped_fields1280[0].(string)
+		p.write(p.formatStringValue(field1281))
 		p.newline()
-		field1256 := unwrapped_fields1254[1].(*pb.RelationId)
-		p.pretty_relation_id(field1256)
+		field1282 := unwrapped_fields1280[1].(*pb.RelationId)
+		p.pretty_relation_id(field1282)
 		p.dedent()
 		p.write(")")
 	}
@@ -3948,8 +4018,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} {
 	for _idx, _rid := range msg.GetIds() {
 		p.newline()
 		p.write("(")
-		_t1403 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()}
-		p.pprintDispatch(_t1403)
+		_t1432 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()}
+		p.pprintDispatch(_t1432)
 		p.write(" ")
 		p.write(p.formatStringValue(msg.GetOrigNames()[_idx]))
 		p.write(")")
@@ -4236,12 +4306,12 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) {
 		p.pretty_functional_dependency_keys(m)
 	case *pb.Data:
 		p.pretty_data(m)
-	case *pb.RelEDB:
-		p.pretty_rel_edb(m)
+	case *pb.EDB:
+		p.pretty_edb(m)
 	case []string:
-		p.pretty_rel_edb_path(m)
+		p.pretty_edb_path(m)
 	case []*pb.Type:
-		p.pretty_rel_edb_types(m)
+		p.pretty_edb_types(m)
 	case *pb.BeTreeRelation:
 		p.pretty_betree_relation(m)
 	case *pb.BeTreeInfo:
@@ -4252,16 +4322,18 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) {
 		p.pretty_csvlocator(m)
 	case *pb.CSVConfig:
 		p.pretty_csv_config(m)
-	case []*pb.CSVColumn:
-		p.pretty_csv_columns(m)
-	case *pb.CSVColumn:
-		p.pretty_csv_column(m)
+	case []*pb.GNFColumn:
+		p.pretty_gnf_columns(m)
+	case *pb.GNFColumn:
+		p.pretty_gnf_column(m)
 	case *pb.Undefine:
 		p.pretty_undefine(m)
 	case *pb.Context:
 		p.pretty_context(m)
 	case *pb.Snapshot:
 		p.pretty_snapshot(m)
+	case *pb.SnapshotMapping:
+		p.pretty_snapshot_mapping(m)
 	case []*pb.Read:
 		p.pretty_epoch_reads(m)
 	case *pb.Read:
diff --git a/sdks/go/test/extra_print_test.go b/sdks/go/test/extra_print_test.go
index c16eb560..6e09253b 100644
--- a/sdks/go/test/extra_print_test.go
+++ b/sdks/go/test/extra_print_test.go
@@ -234,18 +234,18 @@ func TestInstructionAssign(t *testing.T) {
 	}
 }
 
-func TestDataRelEDB(t *testing.T) {
+func TestDataEDB(t *testing.T) {
 	msg := &pb.Data{
-		DataType: &pb.Data_RelEdb{
-			RelEdb: &pb.RelEDB{
+		DataType: &pb.Data_Edb{
+			Edb: &pb.EDB{
 				TargetId: &pb.RelationId{IdLow: 1, IdHigh: 0},
 				Path:     []string{"base", "rel"},
 			},
 		},
 	}
 	got := lqp.MsgToStr(msg)
-	if len(got) < 8 || got[:8] != "(rel_edb" {
-		t.Errorf("Data rel_edb: got %q", got)
+	if len(got) < 4 || got[:4] != "(edb" {
+		t.Errorf("Data edb: got %q", got)
 	}
 }
 
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl
index 8f12a6ee..7218a1cb 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/LogicalQueryProtocol.jl
@@ -22,12 +22,12 @@ const LQPSyntax = Union{
     RelAtom,Abstraction,Algorithm,Assign,Break,Conjunction,Def,Disjunction,
     Exists,FFI,MonoidDef,MonusDef,Not,Reduce,Script,Upsert,Construct,Declaration,
     Loop,Formula,Instruction,FragmentId,DebugInfo,Fragment,ExportCSVColumn,
-    ExportCSVConfig,Demand,Undefine,Configure,Snapshot,Define,Context,Sync,Abort,Output,Write,
+    ExportCSVConfig,Demand,Undefine,Configure,SnapshotMapping,Snapshot,Define,Context,Sync,Abort,Output,Write,
     Export,Epoch,Read,Transaction,WhatIf,Constraint,FunctionalDependency,
     DateTimeValue,DateValue,DecimalValue,
     BeTreeInfo,BeTreeRelation,
-    CSVLocator,CSVConfig,CSVColumn,CSVData,
-    RelEDB,Data,
+    CSVLocator,CSVConfig,GNFColumn,CSVData,
+    EDB,Data,
 }
 
 using ProtoBuf: ProtoBuf
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl
index 31402b6a..6c189a30 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl
@@ -362,10 +362,15 @@ Base.:(==)(a::Define, b::Define) = a.fragment == b.fragment
 Base.hash(a::Define, h::UInt) = hash(a.fragment, h)
 Base.isequal(a::Define, b::Define) = isequal(a.fragment, b.fragment)
 
+# SnapshotMapping
+Base.:(==)(a::SnapshotMapping, b::SnapshotMapping) = a.destination_path == b.destination_path && a.source_relation == b.source_relation
+Base.hash(a::SnapshotMapping, h::UInt) = hash(a.source_relation, hash(a.destination_path, h))
+Base.isequal(a::SnapshotMapping, b::SnapshotMapping) = isequal(a.destination_path, b.destination_path) && isequal(a.source_relation, b.source_relation)
+
 # Snapshot
-Base.:(==)(a::Snapshot, b::Snapshot) = a.destination_path == b.destination_path && a.source_relation == b.source_relation
-Base.hash(a::Snapshot, h::UInt) = hash(a.source_relation, hash(a.destination_path, h))
-Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.destination_path, b.destination_path) && isequal(a.source_relation, b.source_relation)
+Base.:(==)(a::Snapshot, b::Snapshot) = a.mappings == b.mappings
+Base.hash(a::Snapshot, h::UInt) = hash(a.mappings, h)
+Base.isequal(a::Snapshot, b::Snapshot) = isequal(a.mappings, b.mappings)
 
 # Context
 Base.:(==)(a::Context, b::Context) = a.relations == b.relations
@@ -487,20 +492,20 @@ function Base.isequal(a::BeTreeLocator, b::BeTreeLocator)
     _isequal_oneof(a.location, b.location) && isequal(a.element_count, b.element_count) && isequal(a.tree_height, b.tree_height)
 end
 
-# RelEDB
-Base.:(==)(a::RelEDB, b::RelEDB) = a.target_id == b.target_id && a.path == b.path && a.types == b.types
-Base.hash(a::RelEDB, h::UInt) = hash(a.types, hash(a.path, hash(a.target_id, h)))
-Base.isequal(a::RelEDB, b::RelEDB) = isequal(a.target_id, b.target_id) && isequal(a.path, b.path) && isequal(a.types, b.types)
+# EDB
+Base.:(==)(a::EDB, b::EDB) = a.target_id == b.target_id && a.path == b.path && a.types == b.types
+Base.hash(a::EDB, h::UInt) = hash(a.types, hash(a.path, hash(a.target_id, h)))
+Base.isequal(a::EDB, b::EDB) = isequal(a.target_id, b.target_id) && isequal(a.path, b.path) && isequal(a.types, b.types)
 
 # BeTreeInfo
 Base.:(==)(a::BeTreeInfo, b::BeTreeInfo) = a.key_types == b.key_types && a.value_types == b.value_types && a.storage_config == b.storage_config && a.relation_locator == b.relation_locator
 Base.hash(a::BeTreeInfo, h::UInt) = hash(a.relation_locator, hash(a.storage_config, hash(a.value_types, hash(a.key_types, h))))
 Base.isequal(a::BeTreeInfo, b::BeTreeInfo) = isequal(a.key_types, b.key_types) && isequal(a.value_types, b.value_types) && isequal(a.storage_config, b.storage_config) && isequal(a.relation_locator, b.relation_locator)
 
-# CSVColumn
-Base.:(==)(a::CSVColumn, b::CSVColumn) = a.column_name == b.column_name && a.target_id == b.target_id && a.types == b.types
-Base.hash(a::CSVColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_name, h)))
-Base.isequal(a::CSVColumn, b::CSVColumn) = isequal(a.column_name, b.column_name) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types)
+# GNFColumn
+Base.:(==)(a::GNFColumn, b::GNFColumn) = a.column_path == b.column_path && a.target_id == b.target_id && a.types == b.types
+Base.hash(a::GNFColumn, h::UInt) = hash(a.types, hash(a.target_id, hash(a.column_path, h)))
+Base.isequal(a::GNFColumn, b::GNFColumn) = isequal(a.column_path, b.column_path) && isequal(a.target_id, b.target_id) && isequal(a.types, b.types)
 
 # BeTreeRelation
 Base.:(==)(a::BeTreeRelation, b::BeTreeRelation) = a.name == b.name && a.relation_info == b.relation_info
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl
index 7864079e..7ac85ce5 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl
@@ -8,12 +8,12 @@ using ProtoBuf.EnumX: @enumx
 export DateTimeType, RelationId, Var, FloatType, UInt128Type, BeTreeConfig, DateTimeValue
 export DateValue, OrMonoid, CSVLocator, Int128Type, DecimalType, UnspecifiedType, DateType
 export MissingType, MissingValue, CSVConfig, IntType, StringType, Int128Value, UInt128Value
-export BooleanType, DecimalValue, BeTreeLocator, var"#Type", Value, RelEDB, MinMonoid
-export SumMonoid, MaxMonoid, BeTreeInfo, Binding, CSVColumn, Attribute, Term, Monoid
-export BeTreeRelation, CSVData, Cast, Pragma, Atom, RelTerm, Data, Primitive, RelAtom
-export Abstraction, Algorithm, Assign, Break, Conjunction, Constraint, Def, Disjunction
-export Exists, FFI, FunctionalDependency, MonoidDef, MonusDef, Not, Reduce, Script, Upsert
-export Construct, Loop, Declaration, Instruction, Formula
+export BooleanType, DecimalValue, BeTreeLocator, var"#Type", Value, GNFColumn, MinMonoid
+export SumMonoid, MaxMonoid, BeTreeInfo, Binding, EDB, Attribute, Term, CSVData, Monoid
+export BeTreeRelation, Cast, Pragma, Atom, RelTerm, Data, Primitive, RelAtom, Abstraction
+export Algorithm, Assign, Break, Conjunction, Constraint, Def, Disjunction, Exists, FFI
+export FunctionalDependency, MonoidDef, MonusDef, Not, Reduce, Script, Upsert, Construct
+export Loop, Declaration, Instruction, Formula
 abstract type var"##Abstract#Abstraction" end
 abstract type var"##Abstract#Not" end
 abstract type var"##Abstract#Break" end
@@ -1027,45 +1027,45 @@ function PB._encoded_size(x::Value)
     return encoded_size
 end
 
-struct RelEDB
+struct GNFColumn
+    column_path::Vector{String}
     target_id::Union{Nothing,RelationId}
-    path::Vector{String}
     types::Vector{var"#Type"}
 end
-RelEDB(;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) = RelEDB(target_id, path, types)
-PB.default_values(::Type{RelEDB}) = (;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}())
-PB.field_numbers(::Type{RelEDB}) = (;target_id = 1, path = 2, types = 3)
+GNFColumn(;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}()) = GNFColumn(column_path, target_id, types)
+PB.default_values(::Type{GNFColumn}) = (;column_path = Vector{String}(), target_id = nothing, types = Vector{var"#Type"}())
+PB.field_numbers(::Type{GNFColumn}) = (;column_path = 1, target_id = 2, types = 3)
 
-function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:RelEDB})
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:GNFColumn})
+    column_path = PB.BufferedVector{String}()
     target_id = Ref{Union{Nothing,RelationId}}(nothing)
-    path = PB.BufferedVector{String}()
     types = PB.BufferedVector{var"#Type"}()
     while !PB.message_done(d)
         field_number, wire_type = PB.decode_tag(d)
         if field_number == 1
-            PB.decode!(d, target_id)
+            PB.decode!(d, column_path)
         elseif field_number == 2
-            PB.decode!(d, path)
+            PB.decode!(d, target_id)
         elseif field_number == 3
             PB.decode!(d, types)
         else
             Base.skip(d, wire_type)
         end
     end
-    return RelEDB(target_id[], path[], types[])
+    return GNFColumn(column_path[], target_id[], types[])
 end
 
-function PB.encode(e::PB.AbstractProtoEncoder, x::RelEDB)
+function PB.encode(e::PB.AbstractProtoEncoder, x::GNFColumn)
     initpos = position(e.io)
-    !isnothing(x.target_id) && PB.encode(e, 1, x.target_id)
-    !isempty(x.path) && PB.encode(e, 2, x.path)
+    !isempty(x.column_path) && PB.encode(e, 1, x.column_path)
+    !isnothing(x.target_id) && PB.encode(e, 2, x.target_id)
     !isempty(x.types) && PB.encode(e, 3, x.types)
     return position(e.io) - initpos
 end
-function PB._encoded_size(x::RelEDB)
+function PB._encoded_size(x::GNFColumn)
     encoded_size = 0
-    !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 1))
-    !isempty(x.path) && (encoded_size += PB._encoded_size(x.path, 2))
+    !isempty(x.column_path) && (encoded_size += PB._encoded_size(x.column_path, 1))
+    !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 2))
     !isempty(x.types) && (encoded_size += PB._encoded_size(x.types, 3))
     return encoded_size
 end
@@ -1250,45 +1250,45 @@ function PB._encoded_size(x::Binding)
     return encoded_size
 end
 
-struct CSVColumn
-    column_name::String
+struct EDB
     target_id::Union{Nothing,RelationId}
+    path::Vector{String}
     types::Vector{var"#Type"}
 end
-CSVColumn(;column_name = "", target_id = nothing, types = Vector{var"#Type"}()) = CSVColumn(column_name, target_id, types)
-PB.default_values(::Type{CSVColumn}) = (;column_name = "", target_id = nothing, types = Vector{var"#Type"}())
-PB.field_numbers(::Type{CSVColumn}) = (;column_name = 1, target_id = 2, types = 3)
+EDB(;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}()) = EDB(target_id, path, types)
+PB.default_values(::Type{EDB}) = (;target_id = nothing, path = Vector{String}(), types = Vector{var"#Type"}())
+PB.field_numbers(::Type{EDB}) = (;target_id = 1, path = 2, types = 3)
 
-function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVColumn})
-    column_name = ""
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:EDB})
     target_id = Ref{Union{Nothing,RelationId}}(nothing)
+    path = PB.BufferedVector{String}()
     types = PB.BufferedVector{var"#Type"}()
     while !PB.message_done(d)
         field_number, wire_type = PB.decode_tag(d)
         if field_number == 1
-            column_name = PB.decode(d, String)
-        elseif field_number == 2
             PB.decode!(d, target_id)
+        elseif field_number == 2
+            PB.decode!(d, path)
         elseif field_number == 3
             PB.decode!(d, types)
         else
             Base.skip(d, wire_type)
         end
     end
-    return CSVColumn(column_name, target_id[], types[])
+    return EDB(target_id[], path[], types[])
 end
 
-function PB.encode(e::PB.AbstractProtoEncoder, x::CSVColumn)
+function PB.encode(e::PB.AbstractProtoEncoder, x::EDB)
     initpos = position(e.io)
-    !isempty(x.column_name) && PB.encode(e, 1, x.column_name)
-    !isnothing(x.target_id) && PB.encode(e, 2, x.target_id)
+    !isnothing(x.target_id) && PB.encode(e, 1, x.target_id)
+    !isempty(x.path) && PB.encode(e, 2, x.path)
     !isempty(x.types) && PB.encode(e, 3, x.types)
     return position(e.io) - initpos
 end
-function PB._encoded_size(x::CSVColumn)
+function PB._encoded_size(x::EDB)
     encoded_size = 0
-    !isempty(x.column_name) && (encoded_size += PB._encoded_size(x.column_name, 1))
-    !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 2))
+    !isnothing(x.target_id) && (encoded_size += PB._encoded_size(x.target_id, 1))
+    !isempty(x.path) && (encoded_size += PB._encoded_size(x.path, 2))
     !isempty(x.types) && (encoded_size += PB._encoded_size(x.types, 3))
     return encoded_size
 end
@@ -1376,6 +1376,55 @@ function PB._encoded_size(x::Term)
     return encoded_size
 end
 
+struct CSVData
+    locator::Union{Nothing,CSVLocator}
+    config::Union{Nothing,CSVConfig}
+    columns::Vector{GNFColumn}
+    asof::String
+end
+CSVData(;locator = nothing, config = nothing, columns = Vector{GNFColumn}(), asof = "") = CSVData(locator, config, columns, asof)
+PB.default_values(::Type{CSVData}) = (;locator = nothing, config = nothing, columns = Vector{GNFColumn}(), asof = "")
+PB.field_numbers(::Type{CSVData}) = (;locator = 1, config = 2, columns = 3, asof = 4)
+
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVData})
+    locator = Ref{Union{Nothing,CSVLocator}}(nothing)
+    config = Ref{Union{Nothing,CSVConfig}}(nothing)
+    columns = PB.BufferedVector{GNFColumn}()
+    asof = ""
+    while !PB.message_done(d)
+        field_number, wire_type = PB.decode_tag(d)
+        if field_number == 1
+            PB.decode!(d, locator)
+        elseif field_number == 2
+            PB.decode!(d, config)
+        elseif field_number == 3
+            PB.decode!(d, columns)
+        elseif field_number == 4
+            asof = PB.decode(d, String)
+        else
+            Base.skip(d, wire_type)
+        end
+    end
+    return CSVData(locator[], config[], columns[], asof)
+end
+
+function PB.encode(e::PB.AbstractProtoEncoder, x::CSVData)
+    initpos = position(e.io)
+    !isnothing(x.locator) && PB.encode(e, 1, x.locator)
+    !isnothing(x.config) && PB.encode(e, 2, x.config)
+    !isempty(x.columns) && PB.encode(e, 3, x.columns)
+    !isempty(x.asof) && PB.encode(e, 4, x.asof)
+    return position(e.io) - initpos
+end
+function PB._encoded_size(x::CSVData)
+    encoded_size = 0
+    !isnothing(x.locator) && (encoded_size += PB._encoded_size(x.locator, 1))
+    !isnothing(x.config) && (encoded_size += PB._encoded_size(x.config, 2))
+    !isempty(x.columns) && (encoded_size += PB._encoded_size(x.columns, 3))
+    !isempty(x.asof) && (encoded_size += PB._encoded_size(x.asof, 4))
+    return encoded_size
+end
+
 struct Monoid
     value::Union{Nothing,OneOf{<:Union{OrMonoid,MinMonoid,MaxMonoid,SumMonoid}}}
 end
@@ -1471,55 +1520,6 @@ function PB._encoded_size(x::BeTreeRelation)
     return encoded_size
 end
 
-struct CSVData
-    locator::Union{Nothing,CSVLocator}
-    config::Union{Nothing,CSVConfig}
-    columns::Vector{CSVColumn}
-    asof::String
-end
-CSVData(;locator = nothing, config = nothing, columns = Vector{CSVColumn}(), asof = "") = CSVData(locator, config, columns, asof)
-PB.default_values(::Type{CSVData}) = (;locator = nothing, config = nothing, columns = Vector{CSVColumn}(), asof = "")
-PB.field_numbers(::Type{CSVData}) = (;locator = 1, config = 2, columns = 3, asof = 4)
-
-function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:CSVData})
-    locator = Ref{Union{Nothing,CSVLocator}}(nothing)
-    config = Ref{Union{Nothing,CSVConfig}}(nothing)
-    columns = PB.BufferedVector{CSVColumn}()
-    asof = ""
-    while !PB.message_done(d)
-        field_number, wire_type = PB.decode_tag(d)
-        if field_number == 1
-            PB.decode!(d, locator)
-        elseif field_number == 2
-            PB.decode!(d, config)
-        elseif field_number == 3
-            PB.decode!(d, columns)
-        elseif field_number == 4
-            asof = PB.decode(d, String)
-        else
-            Base.skip(d, wire_type)
-        end
-    end
-    return CSVData(locator[], config[], columns[], asof)
-end
-
-function PB.encode(e::PB.AbstractProtoEncoder, x::CSVData)
-    initpos = position(e.io)
-    !isnothing(x.locator) && PB.encode(e, 1, x.locator)
-    !isnothing(x.config) && PB.encode(e, 2, x.config)
-    !isempty(x.columns) && PB.encode(e, 3, x.columns)
-    !isempty(x.asof) && PB.encode(e, 4, x.asof)
-    return position(e.io) - initpos
-end
-function PB._encoded_size(x::CSVData)
-    encoded_size = 0
-    !isnothing(x.locator) && (encoded_size += PB._encoded_size(x.locator, 1))
-    !isnothing(x.config) && (encoded_size += PB._encoded_size(x.config, 2))
-    !isempty(x.columns) && (encoded_size += PB._encoded_size(x.columns, 3))
-    !isempty(x.asof) && (encoded_size += PB._encoded_size(x.asof, 4))
-    return encoded_size
-end
-
 struct Cast
     input::Union{Nothing,Term}
     result::Union{Nothing,Term}
@@ -1678,21 +1678,21 @@ function PB._encoded_size(x::RelTerm)
 end
 
 struct Data
-    data_type::Union{Nothing,OneOf{<:Union{RelEDB,BeTreeRelation,CSVData}}}
+    data_type::Union{Nothing,OneOf{<:Union{EDB,BeTreeRelation,CSVData}}}
 end
 Data(;data_type = nothing) = Data(data_type)
 PB.oneof_field_types(::Type{Data}) = (;
-    data_type = (;rel_edb=RelEDB, betree_relation=BeTreeRelation, csv_data=CSVData),
+    data_type = (;edb=EDB, betree_relation=BeTreeRelation, csv_data=CSVData),
 )
-PB.default_values(::Type{Data}) = (;rel_edb = nothing, betree_relation = nothing, csv_data = nothing)
-PB.field_numbers(::Type{Data}) = (;rel_edb = 1, betree_relation = 2, csv_data = 3)
+PB.default_values(::Type{Data}) = (;edb = nothing, betree_relation = nothing, csv_data = nothing)
+PB.field_numbers(::Type{Data}) = (;edb = 1, betree_relation = 2, csv_data = 3)
 
 function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Data})
     data_type = nothing
     while !PB.message_done(d)
         field_number, wire_type = PB.decode_tag(d)
         if field_number == 1
-            data_type = OneOf(:rel_edb, PB.decode(d, Ref{RelEDB}))
+            data_type = OneOf(:edb, PB.decode(d, Ref{EDB}))
         elseif field_number == 2
             data_type = OneOf(:betree_relation, PB.decode(d, Ref{BeTreeRelation}))
         elseif field_number == 3
@@ -1707,8 +1707,8 @@ end
 function PB.encode(e::PB.AbstractProtoEncoder, x::Data)
     initpos = position(e.io)
     if isnothing(x.data_type);
-    elseif x.data_type.name === :rel_edb
-        PB.encode(e, 1, x.data_type[]::RelEDB)
+    elseif x.data_type.name === :edb
+        PB.encode(e, 1, x.data_type[]::EDB)
     elseif x.data_type.name === :betree_relation
         PB.encode(e, 2, x.data_type[]::BeTreeRelation)
     elseif x.data_type.name === :csv_data
@@ -1719,8 +1719,8 @@ end
 function PB._encoded_size(x::Data)
     encoded_size = 0
     if isnothing(x.data_type);
-    elseif x.data_type.name === :rel_edb
-        encoded_size += PB._encoded_size(x.data_type[]::RelEDB, 1)
+    elseif x.data_type.name === :edb
+        encoded_size += PB._encoded_size(x.data_type[]::EDB, 1)
     elseif x.data_type.name === :betree_relation
         encoded_size += PB._encoded_size(x.data_type[]::BeTreeRelation, 2)
     elseif x.data_type.name === :csv_data
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl
index 5b79c7b8..ae3e4a62 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl
@@ -5,9 +5,9 @@ import ProtoBuf as PB
 using ProtoBuf: OneOf
 using ProtoBuf.EnumX: @enumx
 
-export ExportCSVColumn, Demand, Undefine, MaintenanceLevel, Snapshot, Define, Context, Sync
-export Abort, Output, ExportCSVConfig, IVMConfig, Write, Export, Configure, Epoch, Read
-export Transaction, WhatIf
+export ExportCSVColumn, Demand, Undefine, MaintenanceLevel, Define, Context, Sync
+export SnapshotMapping, Abort, Output, ExportCSVConfig, IVMConfig, Snapshot, Export
+export Configure, Write, Epoch, Read, Transaction, WhatIf
 abstract type var"##Abstract#Transaction" end
 abstract type var"##Abstract#Epoch" end
 abstract type var"##Abstract#Read" end
@@ -115,43 +115,6 @@ end
 
 @enumx MaintenanceLevel MAINTENANCE_LEVEL_UNSPECIFIED=0 MAINTENANCE_LEVEL_OFF=1 MAINTENANCE_LEVEL_AUTO=2 MAINTENANCE_LEVEL_ALL=3
 
-struct Snapshot
-    destination_path::Vector{String}
-    source_relation::Union{Nothing,RelationId}
-end
-Snapshot(;destination_path = Vector{String}(), source_relation = nothing) = Snapshot(destination_path, source_relation)
-PB.default_values(::Type{Snapshot}) = (;destination_path = Vector{String}(), source_relation = nothing)
-PB.field_numbers(::Type{Snapshot}) = (;destination_path = 1, source_relation = 2)
-
-function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Snapshot})
-    destination_path = PB.BufferedVector{String}()
-    source_relation = Ref{Union{Nothing,RelationId}}(nothing)
-    while !PB.message_done(d)
-        field_number, wire_type = PB.decode_tag(d)
-        if field_number == 1
-            PB.decode!(d, destination_path)
-        elseif field_number == 2
-            PB.decode!(d, source_relation)
-        else
-            Base.skip(d, wire_type)
-        end
-    end
-    return Snapshot(destination_path[], source_relation[])
-end
-
-function PB.encode(e::PB.AbstractProtoEncoder, x::Snapshot)
-    initpos = position(e.io)
-    !isempty(x.destination_path) && PB.encode(e, 1, x.destination_path)
-    !isnothing(x.source_relation) && PB.encode(e, 2, x.source_relation)
-    return position(e.io) - initpos
-end
-function PB._encoded_size(x::Snapshot)
-    encoded_size = 0
-    !isempty(x.destination_path) && (encoded_size += PB._encoded_size(x.destination_path, 1))
-    !isnothing(x.source_relation) && (encoded_size += PB._encoded_size(x.source_relation, 2))
-    return encoded_size
-end
-
 struct Define
     fragment::Union{Nothing,Fragment}
 end
@@ -245,6 +208,43 @@ function PB._encoded_size(x::Sync)
     return encoded_size
 end
 
+struct SnapshotMapping
+    destination_path::Vector{String}
+    source_relation::Union{Nothing,RelationId}
+end
+SnapshotMapping(;destination_path = Vector{String}(), source_relation = nothing) = SnapshotMapping(destination_path, source_relation)
+PB.default_values(::Type{SnapshotMapping}) = (;destination_path = Vector{String}(), source_relation = nothing)
+PB.field_numbers(::Type{SnapshotMapping}) = (;destination_path = 1, source_relation = 2)
+
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:SnapshotMapping})
+    destination_path = PB.BufferedVector{String}()
+    source_relation = Ref{Union{Nothing,RelationId}}(nothing)
+    while !PB.message_done(d)
+        field_number, wire_type = PB.decode_tag(d)
+        if field_number == 1
+            PB.decode!(d, destination_path)
+        elseif field_number == 2
+            PB.decode!(d, source_relation)
+        else
+            Base.skip(d, wire_type)
+        end
+    end
+    return SnapshotMapping(destination_path[], source_relation[])
+end
+
+function PB.encode(e::PB.AbstractProtoEncoder, x::SnapshotMapping)
+    initpos = position(e.io)
+    !isempty(x.destination_path) && PB.encode(e, 1, x.destination_path)
+    !isnothing(x.source_relation) && PB.encode(e, 2, x.source_relation)
+    return position(e.io) - initpos
+end
+function PB._encoded_size(x::SnapshotMapping)
+    encoded_size = 0
+    !isempty(x.destination_path) && (encoded_size += PB._encoded_size(x.destination_path, 1))
+    !isnothing(x.source_relation) && (encoded_size += PB._encoded_size(x.source_relation, 2))
+    return encoded_size
+end
+
 struct Abort
     name::String
     relation_id::Union{Nothing,RelationId}
@@ -429,62 +429,34 @@ function PB._encoded_size(x::IVMConfig)
     return encoded_size
 end
 
-struct Write
-    write_type::Union{Nothing,OneOf{<:Union{Define,Undefine,Context,Snapshot}}}
+struct Snapshot
+    mappings::Vector{SnapshotMapping}
 end
-Write(;write_type = nothing) = Write(write_type)
-PB.reserved_fields(::Type{Write}) = (names = String[], numbers = Union{Int,UnitRange{Int}}[4])
-PB.oneof_field_types(::Type{Write}) = (;
-    write_type = (;define=Define, undefine=Undefine, context=Context, snapshot=Snapshot),
-)
-PB.default_values(::Type{Write}) = (;define = nothing, undefine = nothing, context = nothing, snapshot = nothing)
-PB.field_numbers(::Type{Write}) = (;define = 1, undefine = 2, context = 3, snapshot = 5)
+Snapshot(;mappings = Vector{SnapshotMapping}()) = Snapshot(mappings)
+PB.default_values(::Type{Snapshot}) = (;mappings = Vector{SnapshotMapping}())
+PB.field_numbers(::Type{Snapshot}) = (;mappings = 1)
 
-function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Write})
-    write_type = nothing
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Snapshot})
+    mappings = PB.BufferedVector{SnapshotMapping}()
     while !PB.message_done(d)
         field_number, wire_type = PB.decode_tag(d)
         if field_number == 1
-            write_type = OneOf(:define, PB.decode(d, Ref{Define}))
-        elseif field_number == 2
-            write_type = OneOf(:undefine, PB.decode(d, Ref{Undefine}))
-        elseif field_number == 3
-            write_type = OneOf(:context, PB.decode(d, Ref{Context}))
-        elseif field_number == 5
-            write_type = OneOf(:snapshot, PB.decode(d, Ref{Snapshot}))
+            PB.decode!(d, mappings)
         else
             Base.skip(d, wire_type)
         end
     end
-    return Write(write_type)
+    return Snapshot(mappings[])
 end
 
-function PB.encode(e::PB.AbstractProtoEncoder, x::Write)
+function PB.encode(e::PB.AbstractProtoEncoder, x::Snapshot)
     initpos = position(e.io)
-    if isnothing(x.write_type);
-    elseif x.write_type.name === :define
-        PB.encode(e, 1, x.write_type[]::Define)
-    elseif x.write_type.name === :undefine
-        PB.encode(e, 2, x.write_type[]::Undefine)
-    elseif x.write_type.name === :context
-        PB.encode(e, 3, x.write_type[]::Context)
-    elseif x.write_type.name === :snapshot
-        PB.encode(e, 5, x.write_type[]::Snapshot)
-    end
+    !isempty(x.mappings) && PB.encode(e, 1, x.mappings)
     return position(e.io) - initpos
 end
-function PB._encoded_size(x::Write)
+function PB._encoded_size(x::Snapshot)
     encoded_size = 0
-    if isnothing(x.write_type);
-    elseif x.write_type.name === :define
-        encoded_size += PB._encoded_size(x.write_type[]::Define, 1)
-    elseif x.write_type.name === :undefine
-        encoded_size += PB._encoded_size(x.write_type[]::Undefine, 2)
-    elseif x.write_type.name === :context
-        encoded_size += PB._encoded_size(x.write_type[]::Context, 3)
-    elseif x.write_type.name === :snapshot
-        encoded_size += PB._encoded_size(x.write_type[]::Snapshot, 5)
-    end
+    !isempty(x.mappings) && (encoded_size += PB._encoded_size(x.mappings, 1))
     return encoded_size
 end
 
@@ -565,6 +537,65 @@ function PB._encoded_size(x::Configure)
     return encoded_size
 end
 
+struct Write
+    write_type::Union{Nothing,OneOf{<:Union{Define,Undefine,Context,Snapshot}}}
+end
+Write(;write_type = nothing) = Write(write_type)
+PB.reserved_fields(::Type{Write}) = (names = String[], numbers = Union{Int,UnitRange{Int}}[4])
+PB.oneof_field_types(::Type{Write}) = (;
+    write_type = (;define=Define, undefine=Undefine, context=Context, snapshot=Snapshot),
+)
+PB.default_values(::Type{Write}) = (;define = nothing, undefine = nothing, context = nothing, snapshot = nothing)
+PB.field_numbers(::Type{Write}) = (;define = 1, undefine = 2, context = 3, snapshot = 5)
+
+function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:Write})
+    write_type = nothing
+    while !PB.message_done(d)
+        field_number, wire_type = PB.decode_tag(d)
+        if field_number == 1
+            write_type = OneOf(:define, PB.decode(d, Ref{Define}))
+        elseif field_number == 2
+            write_type = OneOf(:undefine, PB.decode(d, Ref{Undefine}))
+        elseif field_number == 3
+            write_type = OneOf(:context, PB.decode(d, Ref{Context}))
+        elseif field_number == 5
+            write_type = OneOf(:snapshot, PB.decode(d, Ref{Snapshot}))
+        else
+            Base.skip(d, wire_type)
+        end
+    end
+    return Write(write_type)
+end
+
+function PB.encode(e::PB.AbstractProtoEncoder, x::Write)
+    initpos = position(e.io)
+    if isnothing(x.write_type);
+    elseif x.write_type.name === :define
+        PB.encode(e, 1, x.write_type[]::Define)
+    elseif x.write_type.name === :undefine
+        PB.encode(e, 2, x.write_type[]::Undefine)
+    elseif x.write_type.name === :context
+        PB.encode(e, 3, x.write_type[]::Context)
+    elseif x.write_type.name === :snapshot
+        PB.encode(e, 5, x.write_type[]::Snapshot)
+    end
+    return position(e.io) - initpos
+end
+function PB._encoded_size(x::Write)
+    encoded_size = 0
+    if isnothing(x.write_type);
+    elseif x.write_type.name === :define
+        encoded_size += PB._encoded_size(x.write_type[]::Define, 1)
+    elseif x.write_type.name === :undefine
+        encoded_size += PB._encoded_size(x.write_type[]::Undefine, 2)
+    elseif x.write_type.name === :context
+        encoded_size += PB._encoded_size(x.write_type[]::Context, 3)
+    elseif x.write_type.name === :snapshot
+        encoded_size += PB._encoded_size(x.write_type[]::Snapshot, 5)
+    end
+    return encoded_size
+end
+
 # Stub definitions for cyclic types
 struct var"##Stub#Epoch"{T1<:var"##Abstract#Read"} <: var"##Abstract#Epoch"
     writes::Vector{Write}
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl
index 361e1130..40b58a46 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl
@@ -305,7 +305,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V
     if (!isnothing(value) && _has_proto_field(value, Symbol("int_value")))
         return Int32(_get_oneof_field(value, :int_value))
     else
-        _t1311 = nothing
+        _t1339 = nothing
     end
     return Int32(default)
 end
@@ -314,7 +314,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V
     if (!isnothing(value) && _has_proto_field(value, Symbol("int_value")))
         return _get_oneof_field(value, :int_value)
     else
-        _t1312 = nothing
+        _t1340 = nothing
     end
     return default
 end
@@ -323,7 +323,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto.
     if (!isnothing(value) && _has_proto_field(value, Symbol("string_value")))
         return _get_oneof_field(value, :string_value)
     else
-        _t1313 = nothing
+        _t1341 = nothing
     end
     return default
 end
@@ -332,7 +332,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto
     if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value")))
         return _get_oneof_field(value, :boolean_value)
     else
-        _t1314 = nothing
+        _t1342 = nothing
     end
     return default
 end
@@ -341,7 +341,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P
     if (!isnothing(value) && _has_proto_field(value, Symbol("string_value")))
         return String[_get_oneof_field(value, :string_value)]
     else
-        _t1315 = nothing
+        _t1343 = nothing
     end
     return default
 end
@@ -350,7 +350,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro
     if (!isnothing(value) && _has_proto_field(value, Symbol("int_value")))
         return _get_oneof_field(value, :int_value)
     else
-        _t1316 = nothing
+        _t1344 = nothing
     end
     return nothing
 end
@@ -359,7 +359,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P
     if (!isnothing(value) && _has_proto_field(value, Symbol("float_value")))
         return _get_oneof_field(value, :float_value)
     else
-        _t1317 = nothing
+        _t1345 = nothing
     end
     return nothing
 end
@@ -368,7 +368,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro
     if (!isnothing(value) && _has_proto_field(value, Symbol("string_value")))
         return Vector{UInt8}(_get_oneof_field(value, :string_value))
     else
-        _t1318 = nothing
+        _t1346 = nothing
     end
     return nothing
 end
@@ -377,70 +377,70 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P
     if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value")))
         return _get_oneof_field(value, :uint128_value)
     else
-        _t1319 = nothing
+        _t1347 = nothing
     end
     return nothing
 end
 
 function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.CSVConfig
     config = Dict(config_dict)
-    _t1320 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1)
-    header_row = _t1320
-    _t1321 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0)
-    skip = _t1321
-    _t1322 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "")
-    new_line = _t1322
-    _t1323 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",")
-    delimiter = _t1323
-    _t1324 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"")
-    quotechar = _t1324
-    _t1325 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"")
-    escapechar = _t1325
-    _t1326 = _extract_value_string(parser, get(config, "csv_comment", nothing), "")
-    comment = _t1326
-    _t1327 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[])
-    missing_strings = _t1327
-    _t1328 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".")
-    decimal_separator = _t1328
-    _t1329 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8")
-    encoding = _t1329
-    _t1330 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto")
-    compression = _t1330
-    _t1331 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression)
-    return _t1331
+    _t1348 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1)
+    header_row = _t1348
+    _t1349 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0)
+    skip = _t1349
+    _t1350 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "")
+    new_line = _t1350
+    _t1351 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",")
+    delimiter = _t1351
+    _t1352 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"")
+    quotechar = _t1352
+    _t1353 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"")
+    escapechar = _t1353
+    _t1354 = _extract_value_string(parser, get(config, "csv_comment", nothing), "")
+    comment = _t1354
+    _t1355 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[])
+    missing_strings = _t1355
+    _t1356 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".")
+    decimal_separator = _t1356
+    _t1357 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8")
+    encoding = _t1357
+    _t1358 = _extract_value_string(parser, get(config, "csv_compression", nothing), "auto")
+    compression = _t1358
+    _t1359 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression)
+    return _t1359
 end
 
 function construct_betree_info(parser::ParserState, key_types::Vector{Proto.var"#Type"}, value_types::Vector{Proto.var"#Type"}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.BeTreeInfo
     config = Dict(config_dict)
-    _t1332 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing))
-    epsilon = _t1332
-    _t1333 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing))
-    max_pivots = _t1333
-    _t1334 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing))
-    max_deltas = _t1334
-    _t1335 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing))
-    max_leaf = _t1335
-    _t1336 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf)
-    storage_config = _t1336
-    _t1337 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing))
-    root_pageid = _t1337
-    _t1338 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing))
-    inline_data = _t1338
-    _t1339 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing))
-    element_count = _t1339
-    _t1340 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing))
-    tree_height = _t1340
-    _t1341 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height)
-    relation_locator = _t1341
-    _t1342 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator)
-    return _t1342
+    _t1360 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing))
+    epsilon = _t1360
+    _t1361 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing))
+    max_pivots = _t1361
+    _t1362 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing))
+    max_deltas = _t1362
+    _t1363 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing))
+    max_leaf = _t1363
+    _t1364 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf)
+    storage_config = _t1364
+    _t1365 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing))
+    root_pageid = _t1365
+    _t1366 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing))
+    inline_data = _t1366
+    _t1367 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing))
+    element_count = _t1367
+    _t1368 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing))
+    tree_height = _t1368
+    _t1369 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height)
+    relation_locator = _t1369
+    _t1370 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator)
+    return _t1370
 end
 
 function default_configure(parser::ParserState)::Proto.Configure
-    _t1343 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF)
-    ivm_config = _t1343
-    _t1344 = Proto.Configure(semantics_version=0, ivm_config=ivm_config)
-    return _t1344
+    _t1371 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF)
+    ivm_config = _t1371
+    _t1372 = Proto.Configure(semantics_version=0, ivm_config=ivm_config)
+    return _t1372
 end
 
 function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure
@@ -462,32 +462,32 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri
             end
         end
     end
-    _t1345 = Proto.IVMConfig(level=maintenance_level)
-    ivm_config = _t1345
-    _t1346 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0)
-    semantics_version = _t1346
-    _t1347 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config)
-    return _t1347
+    _t1373 = Proto.IVMConfig(level=maintenance_level)
+    ivm_config = _t1373
+    _t1374 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0)
+    semantics_version = _t1374
+    _t1375 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config)
+    return _t1375
 end
 
 function export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig
     config = Dict(config_dict)
-    _t1348 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0)
-    partition_size = _t1348
-    _t1349 = _extract_value_string(parser, get(config, "compression", nothing), "")
-    compression = _t1349
-    _t1350 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true)
-    syntax_header_row = _t1350
-    _t1351 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "")
-    syntax_missing_string = _t1351
-    _t1352 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",")
-    syntax_delim = _t1352
-    _t1353 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"")
-    syntax_quotechar = _t1353
-    _t1354 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\")
-    syntax_escapechar = _t1354
-    _t1355 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar)
-    return _t1355
+    _t1376 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0)
+    partition_size = _t1376
+    _t1377 = _extract_value_string(parser, get(config, "compression", nothing), "")
+    compression = _t1377
+    _t1378 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true)
+    syntax_header_row = _t1378
+    _t1379 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "")
+    syntax_missing_string = _t1379
+    _t1380 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",")
+    syntax_delim = _t1380
+    _t1381 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"")
+    syntax_quotechar = _t1381
+    _t1382 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\")
+    syntax_escapechar = _t1382
+    _t1383 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar)
+    return _t1383
 end
 
 # --- Parse functions ---
@@ -496,2699 +496,2755 @@ function parse_transaction(parser::ParserState)::Proto.Transaction
     consume_literal!(parser, "(")
     consume_literal!(parser, "transaction")
     if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1))
-        _t713 = parse_configure(parser)
-        _t712 = _t713
+        _t733 = parse_configure(parser)
+        _t732 = _t733
     else
-        _t712 = nothing
+        _t732 = nothing
     end
-    configure356 = _t712
+    configure366 = _t732
     if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1))
-        _t715 = parse_sync(parser)
-        _t714 = _t715
+        _t735 = parse_sync(parser)
+        _t734 = _t735
     else
-        _t714 = nothing
+        _t734 = nothing
     end
-    sync357 = _t714
-    xs358 = Proto.Epoch[]
-    cond359 = match_lookahead_literal(parser, "(", 0)
-    while cond359
-        _t716 = parse_epoch(parser)
-        item360 = _t716
-        push!(xs358, item360)
-        cond359 = match_lookahead_literal(parser, "(", 0)
+    sync367 = _t734
+    xs368 = Proto.Epoch[]
+    cond369 = match_lookahead_literal(parser, "(", 0)
+    while cond369
+        _t736 = parse_epoch(parser)
+        item370 = _t736
+        push!(xs368, item370)
+        cond369 = match_lookahead_literal(parser, "(", 0)
     end
-    epochs361 = xs358
+    epochs371 = xs368
     consume_literal!(parser, ")")
-    _t717 = default_configure(parser)
-    _t718 = Proto.Transaction(epochs=epochs361, configure=(!isnothing(configure356) ? configure356 : _t717), sync=sync357)
-    return _t718
+    _t737 = default_configure(parser)
+    _t738 = Proto.Transaction(epochs=epochs371, configure=(!isnothing(configure366) ? configure366 : _t737), sync=sync367)
+    return _t738
 end
 
 function parse_configure(parser::ParserState)::Proto.Configure
     consume_literal!(parser, "(")
     consume_literal!(parser, "configure")
-    _t719 = parse_config_dict(parser)
-    config_dict362 = _t719
+    _t739 = parse_config_dict(parser)
+    config_dict372 = _t739
     consume_literal!(parser, ")")
-    _t720 = construct_configure(parser, config_dict362)
-    return _t720
+    _t740 = construct_configure(parser, config_dict372)
+    return _t740
 end
 
 function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}}
     consume_literal!(parser, "{")
-    xs363 = Tuple{String, Proto.Value}[]
-    cond364 = match_lookahead_literal(parser, ":", 0)
-    while cond364
-        _t721 = parse_config_key_value(parser)
-        item365 = _t721
-        push!(xs363, item365)
-        cond364 = match_lookahead_literal(parser, ":", 0)
-    end
-    config_key_values366 = xs363
+    xs373 = Tuple{String, Proto.Value}[]
+    cond374 = match_lookahead_literal(parser, ":", 0)
+    while cond374
+        _t741 = parse_config_key_value(parser)
+        item375 = _t741
+        push!(xs373, item375)
+        cond374 = match_lookahead_literal(parser, ":", 0)
+    end
+    config_key_values376 = xs373
     consume_literal!(parser, "}")
-    return config_key_values366
+    return config_key_values376
 end
 
 function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value}
     consume_literal!(parser, ":")
-    symbol367 = consume_terminal!(parser, "SYMBOL")
-    _t722 = parse_value(parser)
-    value368 = _t722
-    return (symbol367, value368,)
+    symbol377 = consume_terminal!(parser, "SYMBOL")
+    _t742 = parse_value(parser)
+    value378 = _t742
+    return (symbol377, value378,)
 end
 
 function parse_value(parser::ParserState)::Proto.Value
     if match_lookahead_literal(parser, "true", 0)
-        _t723 = 9
+        _t743 = 9
     else
         if match_lookahead_literal(parser, "missing", 0)
-            _t724 = 8
+            _t744 = 8
         else
             if match_lookahead_literal(parser, "false", 0)
-                _t725 = 9
+                _t745 = 9
             else
                 if match_lookahead_literal(parser, "(", 0)
                     if match_lookahead_literal(parser, "datetime", 1)
-                        _t727 = 1
+                        _t747 = 1
                     else
                         if match_lookahead_literal(parser, "date", 1)
-                            _t728 = 0
+                            _t748 = 0
                         else
-                            _t728 = -1
+                            _t748 = -1
                         end
-                        _t727 = _t728
+                        _t747 = _t748
                     end
-                    _t726 = _t727
+                    _t746 = _t747
                 else
                     if match_lookahead_terminal(parser, "UINT128", 0)
-                        _t729 = 5
+                        _t749 = 5
                     else
                         if match_lookahead_terminal(parser, "STRING", 0)
-                            _t730 = 2
+                            _t750 = 2
                         else
                             if match_lookahead_terminal(parser, "INT128", 0)
-                                _t731 = 6
+                                _t751 = 6
                             else
                                 if match_lookahead_terminal(parser, "INT", 0)
-                                    _t732 = 3
+                                    _t752 = 3
                                 else
                                     if match_lookahead_terminal(parser, "FLOAT", 0)
-                                        _t733 = 4
+                                        _t753 = 4
                                     else
                                         if match_lookahead_terminal(parser, "DECIMAL", 0)
-                                            _t734 = 7
+                                            _t754 = 7
                                         else
-                                            _t734 = -1
+                                            _t754 = -1
                                         end
-                                        _t733 = _t734
+                                        _t753 = _t754
                                     end
-                                    _t732 = _t733
+                                    _t752 = _t753
                                 end
-                                _t731 = _t732
+                                _t751 = _t752
                             end
-                            _t730 = _t731
+                            _t750 = _t751
                         end
-                        _t729 = _t730
+                        _t749 = _t750
                     end
-                    _t726 = _t729
+                    _t746 = _t749
                 end
-                _t725 = _t726
+                _t745 = _t746
             end
-            _t724 = _t725
+            _t744 = _t745
         end
-        _t723 = _t724
-    end
-    prediction369 = _t723
-    if prediction369 == 9
-        _t736 = parse_boolean_value(parser)
-        boolean_value378 = _t736
-        _t737 = Proto.Value(value=OneOf(:boolean_value, boolean_value378))
-        _t735 = _t737
+        _t743 = _t744
+    end
+    prediction379 = _t743
+    if prediction379 == 9
+        _t756 = parse_boolean_value(parser)
+        boolean_value388 = _t756
+        _t757 = Proto.Value(value=OneOf(:boolean_value, boolean_value388))
+        _t755 = _t757
     else
-        if prediction369 == 8
+        if prediction379 == 8
             consume_literal!(parser, "missing")
-            _t739 = Proto.MissingValue()
-            _t740 = Proto.Value(value=OneOf(:missing_value, _t739))
-            _t738 = _t740
+            _t759 = Proto.MissingValue()
+            _t760 = Proto.Value(value=OneOf(:missing_value, _t759))
+            _t758 = _t760
         else
-            if prediction369 == 7
-                decimal377 = consume_terminal!(parser, "DECIMAL")
-                _t742 = Proto.Value(value=OneOf(:decimal_value, decimal377))
-                _t741 = _t742
+            if prediction379 == 7
+                decimal387 = consume_terminal!(parser, "DECIMAL")
+                _t762 = Proto.Value(value=OneOf(:decimal_value, decimal387))
+                _t761 = _t762
             else
-                if prediction369 == 6
-                    int128376 = consume_terminal!(parser, "INT128")
-                    _t744 = Proto.Value(value=OneOf(:int128_value, int128376))
-                    _t743 = _t744
+                if prediction379 == 6
+                    int128386 = consume_terminal!(parser, "INT128")
+                    _t764 = Proto.Value(value=OneOf(:int128_value, int128386))
+                    _t763 = _t764
                 else
-                    if prediction369 == 5
-                        uint128375 = consume_terminal!(parser, "UINT128")
-                        _t746 = Proto.Value(value=OneOf(:uint128_value, uint128375))
-                        _t745 = _t746
+                    if prediction379 == 5
+                        uint128385 = consume_terminal!(parser, "UINT128")
+                        _t766 = Proto.Value(value=OneOf(:uint128_value, uint128385))
+                        _t765 = _t766
                     else
-                        if prediction369 == 4
-                            float374 = consume_terminal!(parser, "FLOAT")
-                            _t748 = Proto.Value(value=OneOf(:float_value, float374))
-                            _t747 = _t748
+                        if prediction379 == 4
+                            float384 = consume_terminal!(parser, "FLOAT")
+                            _t768 = Proto.Value(value=OneOf(:float_value, float384))
+                            _t767 = _t768
                         else
-                            if prediction369 == 3
-                                int373 = consume_terminal!(parser, "INT")
-                                _t750 = Proto.Value(value=OneOf(:int_value, int373))
-                                _t749 = _t750
+                            if prediction379 == 3
+                                int383 = consume_terminal!(parser, "INT")
+                                _t770 = Proto.Value(value=OneOf(:int_value, int383))
+                                _t769 = _t770
                             else
-                                if prediction369 == 2
-                                    string372 = consume_terminal!(parser, "STRING")
-                                    _t752 = Proto.Value(value=OneOf(:string_value, string372))
-                                    _t751 = _t752
+                                if prediction379 == 2
+                                    string382 = consume_terminal!(parser, "STRING")
+                                    _t772 = Proto.Value(value=OneOf(:string_value, string382))
+                                    _t771 = _t772
                                 else
-                                    if prediction369 == 1
-                                        _t754 = parse_datetime(parser)
-                                        datetime371 = _t754
-                                        _t755 = Proto.Value(value=OneOf(:datetime_value, datetime371))
-                                        _t753 = _t755
+                                    if prediction379 == 1
+                                        _t774 = parse_datetime(parser)
+                                        datetime381 = _t774
+                                        _t775 = Proto.Value(value=OneOf(:datetime_value, datetime381))
+                                        _t773 = _t775
                                     else
-                                        if prediction369 == 0
-                                            _t757 = parse_date(parser)
-                                            date370 = _t757
-                                            _t758 = Proto.Value(value=OneOf(:date_value, date370))
-                                            _t756 = _t758
+                                        if prediction379 == 0
+                                            _t777 = parse_date(parser)
+                                            date380 = _t777
+                                            _t778 = Proto.Value(value=OneOf(:date_value, date380))
+                                            _t776 = _t778
                                         else
                                             throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0))))
                                         end
-                                        _t753 = _t756
+                                        _t773 = _t776
                                     end
-                                    _t751 = _t753
+                                    _t771 = _t773
                                 end
-                                _t749 = _t751
+                                _t769 = _t771
                             end
-                            _t747 = _t749
+                            _t767 = _t769
                         end
-                        _t745 = _t747
+                        _t765 = _t767
                     end
-                    _t743 = _t745
+                    _t763 = _t765
                 end
-                _t741 = _t743
+                _t761 = _t763
             end
-            _t738 = _t741
+            _t758 = _t761
         end
-        _t735 = _t738
+        _t755 = _t758
     end
-    return _t735
+    return _t755
 end
 
 function parse_date(parser::ParserState)::Proto.DateValue
     consume_literal!(parser, "(")
     consume_literal!(parser, "date")
-    int379 = consume_terminal!(parser, "INT")
-    int_3380 = consume_terminal!(parser, "INT")
-    int_4381 = consume_terminal!(parser, "INT")
+    int389 = consume_terminal!(parser, "INT")
+    int_3390 = consume_terminal!(parser, "INT")
+    int_4391 = consume_terminal!(parser, "INT")
     consume_literal!(parser, ")")
-    _t759 = Proto.DateValue(year=Int32(int379), month=Int32(int_3380), day=Int32(int_4381))
-    return _t759
+    _t779 = Proto.DateValue(year=Int32(int389), month=Int32(int_3390), day=Int32(int_4391))
+    return _t779
 end
 
 function parse_datetime(parser::ParserState)::Proto.DateTimeValue
     consume_literal!(parser, "(")
     consume_literal!(parser, "datetime")
-    int382 = consume_terminal!(parser, "INT")
-    int_3383 = consume_terminal!(parser, "INT")
-    int_4384 = consume_terminal!(parser, "INT")
-    int_5385 = consume_terminal!(parser, "INT")
-    int_6386 = consume_terminal!(parser, "INT")
-    int_7387 = consume_terminal!(parser, "INT")
+    int392 = consume_terminal!(parser, "INT")
+    int_3393 = consume_terminal!(parser, "INT")
+    int_4394 = consume_terminal!(parser, "INT")
+    int_5395 = consume_terminal!(parser, "INT")
+    int_6396 = consume_terminal!(parser, "INT")
+    int_7397 = consume_terminal!(parser, "INT")
     if match_lookahead_terminal(parser, "INT", 0)
-        _t760 = consume_terminal!(parser, "INT")
+        _t780 = consume_terminal!(parser, "INT")
     else
-        _t760 = nothing
+        _t780 = nothing
     end
-    int_8388 = _t760
+    int_8398 = _t780
     consume_literal!(parser, ")")
-    _t761 = Proto.DateTimeValue(year=Int32(int382), month=Int32(int_3383), day=Int32(int_4384), hour=Int32(int_5385), minute=Int32(int_6386), second=Int32(int_7387), microsecond=Int32((!isnothing(int_8388) ? int_8388 : 0)))
-    return _t761
+    _t781 = Proto.DateTimeValue(year=Int32(int392), month=Int32(int_3393), day=Int32(int_4394), hour=Int32(int_5395), minute=Int32(int_6396), second=Int32(int_7397), microsecond=Int32((!isnothing(int_8398) ? int_8398 : 0)))
+    return _t781
 end
 
 function parse_boolean_value(parser::ParserState)::Bool
     if match_lookahead_literal(parser, "true", 0)
-        _t762 = 0
+        _t782 = 0
     else
         if match_lookahead_literal(parser, "false", 0)
-            _t763 = 1
+            _t783 = 1
         else
-            _t763 = -1
+            _t783 = -1
         end
-        _t762 = _t763
+        _t782 = _t783
     end
-    prediction389 = _t762
-    if prediction389 == 1
+    prediction399 = _t782
+    if prediction399 == 1
         consume_literal!(parser, "false")
-        _t764 = false
+        _t784 = false
     else
-        if prediction389 == 0
+        if prediction399 == 0
             consume_literal!(parser, "true")
-            _t765 = true
+            _t785 = true
         else
             throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0))))
         end
-        _t764 = _t765
+        _t784 = _t785
     end
-    return _t764
+    return _t784
 end
 
 function parse_sync(parser::ParserState)::Proto.Sync
     consume_literal!(parser, "(")
     consume_literal!(parser, "sync")
-    xs390 = Proto.FragmentId[]
-    cond391 = match_lookahead_literal(parser, ":", 0)
-    while cond391
-        _t766 = parse_fragment_id(parser)
-        item392 = _t766
-        push!(xs390, item392)
-        cond391 = match_lookahead_literal(parser, ":", 0)
+    xs400 = Proto.FragmentId[]
+    cond401 = match_lookahead_literal(parser, ":", 0)
+    while cond401
+        _t786 = parse_fragment_id(parser)
+        item402 = _t786
+        push!(xs400, item402)
+        cond401 = match_lookahead_literal(parser, ":", 0)
     end
-    fragment_ids393 = xs390
+    fragment_ids403 = xs400
     consume_literal!(parser, ")")
-    _t767 = Proto.Sync(fragments=fragment_ids393)
-    return _t767
+    _t787 = Proto.Sync(fragments=fragment_ids403)
+    return _t787
 end
 
 function parse_fragment_id(parser::ParserState)::Proto.FragmentId
     consume_literal!(parser, ":")
-    symbol394 = consume_terminal!(parser, "SYMBOL")
-    return Proto.FragmentId(Vector{UInt8}(symbol394))
+    symbol404 = consume_terminal!(parser, "SYMBOL")
+    return Proto.FragmentId(Vector{UInt8}(symbol404))
 end
 
 function parse_epoch(parser::ParserState)::Proto.Epoch
     consume_literal!(parser, "(")
     consume_literal!(parser, "epoch")
     if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1))
-        _t769 = parse_epoch_writes(parser)
-        _t768 = _t769
+        _t789 = parse_epoch_writes(parser)
+        _t788 = _t789
     else
-        _t768 = nothing
+        _t788 = nothing
     end
-    epoch_writes395 = _t768
+    epoch_writes405 = _t788
     if match_lookahead_literal(parser, "(", 0)
-        _t771 = parse_epoch_reads(parser)
-        _t770 = _t771
+        _t791 = parse_epoch_reads(parser)
+        _t790 = _t791
     else
-        _t770 = nothing
+        _t790 = nothing
     end
-    epoch_reads396 = _t770
+    epoch_reads406 = _t790
     consume_literal!(parser, ")")
-    _t772 = Proto.Epoch(writes=(!isnothing(epoch_writes395) ? epoch_writes395 : Proto.Write[]), reads=(!isnothing(epoch_reads396) ? epoch_reads396 : Proto.Read[]))
-    return _t772
+    _t792 = Proto.Epoch(writes=(!isnothing(epoch_writes405) ? epoch_writes405 : Proto.Write[]), reads=(!isnothing(epoch_reads406) ? epoch_reads406 : Proto.Read[]))
+    return _t792
 end
 
 function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write}
     consume_literal!(parser, "(")
     consume_literal!(parser, "writes")
-    xs397 = Proto.Write[]
-    cond398 = match_lookahead_literal(parser, "(", 0)
-    while cond398
-        _t773 = parse_write(parser)
-        item399 = _t773
-        push!(xs397, item399)
-        cond398 = match_lookahead_literal(parser, "(", 0)
+    xs407 = Proto.Write[]
+    cond408 = match_lookahead_literal(parser, "(", 0)
+    while cond408
+        _t793 = parse_write(parser)
+        item409 = _t793
+        push!(xs407, item409)
+        cond408 = match_lookahead_literal(parser, "(", 0)
     end
-    writes400 = xs397
+    writes410 = xs407
     consume_literal!(parser, ")")
-    return writes400
+    return writes410
 end
 
 function parse_write(parser::ParserState)::Proto.Write
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "undefine", 1)
-            _t775 = 1
+            _t795 = 1
         else
             if match_lookahead_literal(parser, "snapshot", 1)
-                _t776 = 3
+                _t796 = 3
             else
                 if match_lookahead_literal(parser, "define", 1)
-                    _t777 = 0
+                    _t797 = 0
                 else
                     if match_lookahead_literal(parser, "context", 1)
-                        _t778 = 2
+                        _t798 = 2
                     else
-                        _t778 = -1
+                        _t798 = -1
                     end
-                    _t777 = _t778
+                    _t797 = _t798
                 end
-                _t776 = _t777
+                _t796 = _t797
             end
-            _t775 = _t776
+            _t795 = _t796
         end
-        _t774 = _t775
+        _t794 = _t795
     else
-        _t774 = -1
-    end
-    prediction401 = _t774
-    if prediction401 == 3
-        _t780 = parse_snapshot(parser)
-        snapshot405 = _t780
-        _t781 = Proto.Write(write_type=OneOf(:snapshot, snapshot405))
-        _t779 = _t781
+        _t794 = -1
+    end
+    prediction411 = _t794
+    if prediction411 == 3
+        _t800 = parse_snapshot(parser)
+        snapshot415 = _t800
+        _t801 = Proto.Write(write_type=OneOf(:snapshot, snapshot415))
+        _t799 = _t801
     else
-        if prediction401 == 2
-            _t783 = parse_context(parser)
-            context404 = _t783
-            _t784 = Proto.Write(write_type=OneOf(:context, context404))
-            _t782 = _t784
+        if prediction411 == 2
+            _t803 = parse_context(parser)
+            context414 = _t803
+            _t804 = Proto.Write(write_type=OneOf(:context, context414))
+            _t802 = _t804
         else
-            if prediction401 == 1
-                _t786 = parse_undefine(parser)
-                undefine403 = _t786
-                _t787 = Proto.Write(write_type=OneOf(:undefine, undefine403))
-                _t785 = _t787
+            if prediction411 == 1
+                _t806 = parse_undefine(parser)
+                undefine413 = _t806
+                _t807 = Proto.Write(write_type=OneOf(:undefine, undefine413))
+                _t805 = _t807
             else
-                if prediction401 == 0
-                    _t789 = parse_define(parser)
-                    define402 = _t789
-                    _t790 = Proto.Write(write_type=OneOf(:define, define402))
-                    _t788 = _t790
+                if prediction411 == 0
+                    _t809 = parse_define(parser)
+                    define412 = _t809
+                    _t810 = Proto.Write(write_type=OneOf(:define, define412))
+                    _t808 = _t810
                 else
                     throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0))))
                 end
-                _t785 = _t788
+                _t805 = _t808
             end
-            _t782 = _t785
+            _t802 = _t805
         end
-        _t779 = _t782
+        _t799 = _t802
     end
-    return _t779
+    return _t799
 end
 
 function parse_define(parser::ParserState)::Proto.Define
     consume_literal!(parser, "(")
     consume_literal!(parser, "define")
-    _t791 = parse_fragment(parser)
-    fragment406 = _t791
+    _t811 = parse_fragment(parser)
+    fragment416 = _t811
     consume_literal!(parser, ")")
-    _t792 = Proto.Define(fragment=fragment406)
-    return _t792
+    _t812 = Proto.Define(fragment=fragment416)
+    return _t812
 end
 
 function parse_fragment(parser::ParserState)::Proto.Fragment
     consume_literal!(parser, "(")
     consume_literal!(parser, "fragment")
-    _t793 = parse_new_fragment_id(parser)
-    new_fragment_id407 = _t793
-    xs408 = Proto.Declaration[]
-    cond409 = match_lookahead_literal(parser, "(", 0)
-    while cond409
-        _t794 = parse_declaration(parser)
-        item410 = _t794
-        push!(xs408, item410)
-        cond409 = match_lookahead_literal(parser, "(", 0)
+    _t813 = parse_new_fragment_id(parser)
+    new_fragment_id417 = _t813
+    xs418 = Proto.Declaration[]
+    cond419 = match_lookahead_literal(parser, "(", 0)
+    while cond419
+        _t814 = parse_declaration(parser)
+        item420 = _t814
+        push!(xs418, item420)
+        cond419 = match_lookahead_literal(parser, "(", 0)
     end
-    declarations411 = xs408
+    declarations421 = xs418
     consume_literal!(parser, ")")
-    return construct_fragment(parser, new_fragment_id407, declarations411)
+    return construct_fragment(parser, new_fragment_id417, declarations421)
 end
 
 function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId
-    _t795 = parse_fragment_id(parser)
-    fragment_id412 = _t795
-    start_fragment!(parser, fragment_id412)
-    return fragment_id412
+    _t815 = parse_fragment_id(parser)
+    fragment_id422 = _t815
+    start_fragment!(parser, fragment_id422)
+    return fragment_id422
 end
 
 function parse_declaration(parser::ParserState)::Proto.Declaration
     if match_lookahead_literal(parser, "(", 0)
-        if match_lookahead_literal(parser, "rel_edb", 1)
-            _t797 = 3
+        if match_lookahead_literal(parser, "functional_dependency", 1)
+            _t817 = 2
         else
-            if match_lookahead_literal(parser, "functional_dependency", 1)
-                _t798 = 2
+            if match_lookahead_literal(parser, "edb", 1)
+                _t818 = 3
             else
                 if match_lookahead_literal(parser, "def", 1)
-                    _t799 = 0
+                    _t819 = 0
                 else
                     if match_lookahead_literal(parser, "csv_data", 1)
-                        _t800 = 3
+                        _t820 = 3
                     else
                         if match_lookahead_literal(parser, "betree_relation", 1)
-                            _t801 = 3
+                            _t821 = 3
                         else
                             if match_lookahead_literal(parser, "algorithm", 1)
-                                _t802 = 1
+                                _t822 = 1
                             else
-                                _t802 = -1
+                                _t822 = -1
                             end
-                            _t801 = _t802
+                            _t821 = _t822
                         end
-                        _t800 = _t801
+                        _t820 = _t821
                     end
-                    _t799 = _t800
+                    _t819 = _t820
                 end
-                _t798 = _t799
+                _t818 = _t819
             end
-            _t797 = _t798
+            _t817 = _t818
         end
-        _t796 = _t797
+        _t816 = _t817
     else
-        _t796 = -1
-    end
-    prediction413 = _t796
-    if prediction413 == 3
-        _t804 = parse_data(parser)
-        data417 = _t804
-        _t805 = Proto.Declaration(declaration_type=OneOf(:data, data417))
-        _t803 = _t805
+        _t816 = -1
+    end
+    prediction423 = _t816
+    if prediction423 == 3
+        _t824 = parse_data(parser)
+        data427 = _t824
+        _t825 = Proto.Declaration(declaration_type=OneOf(:data, data427))
+        _t823 = _t825
     else
-        if prediction413 == 2
-            _t807 = parse_constraint(parser)
-            constraint416 = _t807
-            _t808 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint416))
-            _t806 = _t808
+        if prediction423 == 2
+            _t827 = parse_constraint(parser)
+            constraint426 = _t827
+            _t828 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint426))
+            _t826 = _t828
         else
-            if prediction413 == 1
-                _t810 = parse_algorithm(parser)
-                algorithm415 = _t810
-                _t811 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm415))
-                _t809 = _t811
+            if prediction423 == 1
+                _t830 = parse_algorithm(parser)
+                algorithm425 = _t830
+                _t831 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm425))
+                _t829 = _t831
             else
-                if prediction413 == 0
-                    _t813 = parse_def(parser)
-                    def414 = _t813
-                    _t814 = Proto.Declaration(declaration_type=OneOf(:def, def414))
-                    _t812 = _t814
+                if prediction423 == 0
+                    _t833 = parse_def(parser)
+                    def424 = _t833
+                    _t834 = Proto.Declaration(declaration_type=OneOf(:def, def424))
+                    _t832 = _t834
                 else
                     throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0))))
                 end
-                _t809 = _t812
+                _t829 = _t832
             end
-            _t806 = _t809
+            _t826 = _t829
         end
-        _t803 = _t806
+        _t823 = _t826
     end
-    return _t803
+    return _t823
 end
 
 function parse_def(parser::ParserState)::Proto.Def
     consume_literal!(parser, "(")
     consume_literal!(parser, "def")
-    _t815 = parse_relation_id(parser)
-    relation_id418 = _t815
-    _t816 = parse_abstraction(parser)
-    abstraction419 = _t816
+    _t835 = parse_relation_id(parser)
+    relation_id428 = _t835
+    _t836 = parse_abstraction(parser)
+    abstraction429 = _t836
     if match_lookahead_literal(parser, "(", 0)
-        _t818 = parse_attrs(parser)
-        _t817 = _t818
+        _t838 = parse_attrs(parser)
+        _t837 = _t838
     else
-        _t817 = nothing
+        _t837 = nothing
     end
-    attrs420 = _t817
+    attrs430 = _t837
     consume_literal!(parser, ")")
-    _t819 = Proto.Def(name=relation_id418, body=abstraction419, attrs=(!isnothing(attrs420) ? attrs420 : Proto.Attribute[]))
-    return _t819
+    _t839 = Proto.Def(name=relation_id428, body=abstraction429, attrs=(!isnothing(attrs430) ? attrs430 : Proto.Attribute[]))
+    return _t839
 end
 
 function parse_relation_id(parser::ParserState)::Proto.RelationId
     if match_lookahead_literal(parser, ":", 0)
-        _t820 = 0
+        _t840 = 0
     else
         if match_lookahead_terminal(parser, "UINT128", 0)
-            _t821 = 1
+            _t841 = 1
         else
-            _t821 = -1
+            _t841 = -1
         end
-        _t820 = _t821
+        _t840 = _t841
     end
-    prediction421 = _t820
-    if prediction421 == 1
-        uint128423 = consume_terminal!(parser, "UINT128")
-        _t822 = Proto.RelationId(uint128423.low, uint128423.high)
+    prediction431 = _t840
+    if prediction431 == 1
+        uint128433 = consume_terminal!(parser, "UINT128")
+        _t842 = Proto.RelationId(uint128433.low, uint128433.high)
     else
-        if prediction421 == 0
+        if prediction431 == 0
             consume_literal!(parser, ":")
-            symbol422 = consume_terminal!(parser, "SYMBOL")
-            _t823 = relation_id_from_string(parser, symbol422)
+            symbol432 = consume_terminal!(parser, "SYMBOL")
+            _t843 = relation_id_from_string(parser, symbol432)
         else
             throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0))))
         end
-        _t822 = _t823
+        _t842 = _t843
     end
-    return _t822
+    return _t842
 end
 
 function parse_abstraction(parser::ParserState)::Proto.Abstraction
     consume_literal!(parser, "(")
-    _t824 = parse_bindings(parser)
-    bindings424 = _t824
-    _t825 = parse_formula(parser)
-    formula425 = _t825
+    _t844 = parse_bindings(parser)
+    bindings434 = _t844
+    _t845 = parse_formula(parser)
+    formula435 = _t845
     consume_literal!(parser, ")")
-    _t826 = Proto.Abstraction(vars=vcat(bindings424[1], !isnothing(bindings424[2]) ? bindings424[2] : []), value=formula425)
-    return _t826
+    _t846 = Proto.Abstraction(vars=vcat(bindings434[1], !isnothing(bindings434[2]) ? bindings434[2] : []), value=formula435)
+    return _t846
 end
 
 function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}
     consume_literal!(parser, "[")
-    xs426 = Proto.Binding[]
-    cond427 = match_lookahead_terminal(parser, "SYMBOL", 0)
-    while cond427
-        _t827 = parse_binding(parser)
-        item428 = _t827
-        push!(xs426, item428)
-        cond427 = match_lookahead_terminal(parser, "SYMBOL", 0)
-    end
-    bindings429 = xs426
+    xs436 = Proto.Binding[]
+    cond437 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    while cond437
+        _t847 = parse_binding(parser)
+        item438 = _t847
+        push!(xs436, item438)
+        cond437 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    end
+    bindings439 = xs436
     if match_lookahead_literal(parser, "|", 0)
-        _t829 = parse_value_bindings(parser)
-        _t828 = _t829
+        _t849 = parse_value_bindings(parser)
+        _t848 = _t849
     else
-        _t828 = nothing
+        _t848 = nothing
     end
-    value_bindings430 = _t828
+    value_bindings440 = _t848
     consume_literal!(parser, "]")
-    return (bindings429, (!isnothing(value_bindings430) ? value_bindings430 : Proto.Binding[]),)
+    return (bindings439, (!isnothing(value_bindings440) ? value_bindings440 : Proto.Binding[]),)
 end
 
 function parse_binding(parser::ParserState)::Proto.Binding
-    symbol431 = consume_terminal!(parser, "SYMBOL")
+    symbol441 = consume_terminal!(parser, "SYMBOL")
     consume_literal!(parser, "::")
-    _t830 = parse_type(parser)
-    type432 = _t830
-    _t831 = Proto.Var(name=symbol431)
-    _t832 = Proto.Binding(var=_t831, var"#type"=type432)
-    return _t832
+    _t850 = parse_type(parser)
+    type442 = _t850
+    _t851 = Proto.Var(name=symbol441)
+    _t852 = Proto.Binding(var=_t851, var"#type"=type442)
+    return _t852
 end
 
 function parse_type(parser::ParserState)::Proto.var"#Type"
     if match_lookahead_literal(parser, "UNKNOWN", 0)
-        _t833 = 0
+        _t853 = 0
     else
         if match_lookahead_literal(parser, "UINT128", 0)
-            _t834 = 4
+            _t854 = 4
         else
             if match_lookahead_literal(parser, "STRING", 0)
-                _t835 = 1
+                _t855 = 1
             else
                 if match_lookahead_literal(parser, "MISSING", 0)
-                    _t836 = 8
+                    _t856 = 8
                 else
                     if match_lookahead_literal(parser, "INT128", 0)
-                        _t837 = 5
+                        _t857 = 5
                     else
                         if match_lookahead_literal(parser, "INT", 0)
-                            _t838 = 2
+                            _t858 = 2
                         else
                             if match_lookahead_literal(parser, "FLOAT", 0)
-                                _t839 = 3
+                                _t859 = 3
                             else
                                 if match_lookahead_literal(parser, "DATETIME", 0)
-                                    _t840 = 7
+                                    _t860 = 7
                                 else
                                     if match_lookahead_literal(parser, "DATE", 0)
-                                        _t841 = 6
+                                        _t861 = 6
                                     else
                                         if match_lookahead_literal(parser, "BOOLEAN", 0)
-                                            _t842 = 10
+                                            _t862 = 10
                                         else
                                             if match_lookahead_literal(parser, "(", 0)
-                                                _t843 = 9
+                                                _t863 = 9
                                             else
-                                                _t843 = -1
+                                                _t863 = -1
                                             end
-                                            _t842 = _t843
+                                            _t862 = _t863
                                         end
-                                        _t841 = _t842
+                                        _t861 = _t862
                                     end
-                                    _t840 = _t841
+                                    _t860 = _t861
                                 end
-                                _t839 = _t840
+                                _t859 = _t860
                             end
-                            _t838 = _t839
+                            _t858 = _t859
                         end
-                        _t837 = _t838
+                        _t857 = _t858
                     end
-                    _t836 = _t837
+                    _t856 = _t857
                 end
-                _t835 = _t836
+                _t855 = _t856
             end
-            _t834 = _t835
+            _t854 = _t855
         end
-        _t833 = _t834
-    end
-    prediction433 = _t833
-    if prediction433 == 10
-        _t845 = parse_boolean_type(parser)
-        boolean_type444 = _t845
-        _t846 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type444))
-        _t844 = _t846
+        _t853 = _t854
+    end
+    prediction443 = _t853
+    if prediction443 == 10
+        _t865 = parse_boolean_type(parser)
+        boolean_type454 = _t865
+        _t866 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type454))
+        _t864 = _t866
     else
-        if prediction433 == 9
-            _t848 = parse_decimal_type(parser)
-            decimal_type443 = _t848
-            _t849 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type443))
-            _t847 = _t849
+        if prediction443 == 9
+            _t868 = parse_decimal_type(parser)
+            decimal_type453 = _t868
+            _t869 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type453))
+            _t867 = _t869
         else
-            if prediction433 == 8
-                _t851 = parse_missing_type(parser)
-                missing_type442 = _t851
-                _t852 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type442))
-                _t850 = _t852
+            if prediction443 == 8
+                _t871 = parse_missing_type(parser)
+                missing_type452 = _t871
+                _t872 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type452))
+                _t870 = _t872
             else
-                if prediction433 == 7
-                    _t854 = parse_datetime_type(parser)
-                    datetime_type441 = _t854
-                    _t855 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type441))
-                    _t853 = _t855
+                if prediction443 == 7
+                    _t874 = parse_datetime_type(parser)
+                    datetime_type451 = _t874
+                    _t875 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type451))
+                    _t873 = _t875
                 else
-                    if prediction433 == 6
-                        _t857 = parse_date_type(parser)
-                        date_type440 = _t857
-                        _t858 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type440))
-                        _t856 = _t858
+                    if prediction443 == 6
+                        _t877 = parse_date_type(parser)
+                        date_type450 = _t877
+                        _t878 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type450))
+                        _t876 = _t878
                     else
-                        if prediction433 == 5
-                            _t860 = parse_int128_type(parser)
-                            int128_type439 = _t860
-                            _t861 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type439))
-                            _t859 = _t861
+                        if prediction443 == 5
+                            _t880 = parse_int128_type(parser)
+                            int128_type449 = _t880
+                            _t881 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type449))
+                            _t879 = _t881
                         else
-                            if prediction433 == 4
-                                _t863 = parse_uint128_type(parser)
-                                uint128_type438 = _t863
-                                _t864 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type438))
-                                _t862 = _t864
+                            if prediction443 == 4
+                                _t883 = parse_uint128_type(parser)
+                                uint128_type448 = _t883
+                                _t884 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type448))
+                                _t882 = _t884
                             else
-                                if prediction433 == 3
-                                    _t866 = parse_float_type(parser)
-                                    float_type437 = _t866
-                                    _t867 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type437))
-                                    _t865 = _t867
+                                if prediction443 == 3
+                                    _t886 = parse_float_type(parser)
+                                    float_type447 = _t886
+                                    _t887 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type447))
+                                    _t885 = _t887
                                 else
-                                    if prediction433 == 2
-                                        _t869 = parse_int_type(parser)
-                                        int_type436 = _t869
-                                        _t870 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type436))
-                                        _t868 = _t870
+                                    if prediction443 == 2
+                                        _t889 = parse_int_type(parser)
+                                        int_type446 = _t889
+                                        _t890 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type446))
+                                        _t888 = _t890
                                     else
-                                        if prediction433 == 1
-                                            _t872 = parse_string_type(parser)
-                                            string_type435 = _t872
-                                            _t873 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type435))
-                                            _t871 = _t873
+                                        if prediction443 == 1
+                                            _t892 = parse_string_type(parser)
+                                            string_type445 = _t892
+                                            _t893 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type445))
+                                            _t891 = _t893
                                         else
-                                            if prediction433 == 0
-                                                _t875 = parse_unspecified_type(parser)
-                                                unspecified_type434 = _t875
-                                                _t876 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type434))
-                                                _t874 = _t876
+                                            if prediction443 == 0
+                                                _t895 = parse_unspecified_type(parser)
+                                                unspecified_type444 = _t895
+                                                _t896 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type444))
+                                                _t894 = _t896
                                             else
                                                 throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0))))
                                             end
-                                            _t871 = _t874
+                                            _t891 = _t894
                                         end
-                                        _t868 = _t871
+                                        _t888 = _t891
                                     end
-                                    _t865 = _t868
+                                    _t885 = _t888
                                 end
-                                _t862 = _t865
+                                _t882 = _t885
                             end
-                            _t859 = _t862
+                            _t879 = _t882
                         end
-                        _t856 = _t859
+                        _t876 = _t879
                     end
-                    _t853 = _t856
+                    _t873 = _t876
                 end
-                _t850 = _t853
+                _t870 = _t873
             end
-            _t847 = _t850
+            _t867 = _t870
         end
-        _t844 = _t847
+        _t864 = _t867
     end
-    return _t844
+    return _t864
 end
 
 function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType
     consume_literal!(parser, "UNKNOWN")
-    _t877 = Proto.UnspecifiedType()
-    return _t877
+    _t897 = Proto.UnspecifiedType()
+    return _t897
 end
 
 function parse_string_type(parser::ParserState)::Proto.StringType
     consume_literal!(parser, "STRING")
-    _t878 = Proto.StringType()
-    return _t878
+    _t898 = Proto.StringType()
+    return _t898
 end
 
 function parse_int_type(parser::ParserState)::Proto.IntType
     consume_literal!(parser, "INT")
-    _t879 = Proto.IntType()
-    return _t879
+    _t899 = Proto.IntType()
+    return _t899
 end
 
 function parse_float_type(parser::ParserState)::Proto.FloatType
     consume_literal!(parser, "FLOAT")
-    _t880 = Proto.FloatType()
-    return _t880
+    _t900 = Proto.FloatType()
+    return _t900
 end
 
 function parse_uint128_type(parser::ParserState)::Proto.UInt128Type
     consume_literal!(parser, "UINT128")
-    _t881 = Proto.UInt128Type()
-    return _t881
+    _t901 = Proto.UInt128Type()
+    return _t901
 end
 
 function parse_int128_type(parser::ParserState)::Proto.Int128Type
     consume_literal!(parser, "INT128")
-    _t882 = Proto.Int128Type()
-    return _t882
+    _t902 = Proto.Int128Type()
+    return _t902
 end
 
 function parse_date_type(parser::ParserState)::Proto.DateType
     consume_literal!(parser, "DATE")
-    _t883 = Proto.DateType()
-    return _t883
+    _t903 = Proto.DateType()
+    return _t903
 end
 
 function parse_datetime_type(parser::ParserState)::Proto.DateTimeType
     consume_literal!(parser, "DATETIME")
-    _t884 = Proto.DateTimeType()
-    return _t884
+    _t904 = Proto.DateTimeType()
+    return _t904
 end
 
 function parse_missing_type(parser::ParserState)::Proto.MissingType
     consume_literal!(parser, "MISSING")
-    _t885 = Proto.MissingType()
-    return _t885
+    _t905 = Proto.MissingType()
+    return _t905
 end
 
 function parse_decimal_type(parser::ParserState)::Proto.DecimalType
     consume_literal!(parser, "(")
     consume_literal!(parser, "DECIMAL")
-    int445 = consume_terminal!(parser, "INT")
-    int_3446 = consume_terminal!(parser, "INT")
+    int455 = consume_terminal!(parser, "INT")
+    int_3456 = consume_terminal!(parser, "INT")
     consume_literal!(parser, ")")
-    _t886 = Proto.DecimalType(precision=Int32(int445), scale=Int32(int_3446))
-    return _t886
+    _t906 = Proto.DecimalType(precision=Int32(int455), scale=Int32(int_3456))
+    return _t906
 end
 
 function parse_boolean_type(parser::ParserState)::Proto.BooleanType
     consume_literal!(parser, "BOOLEAN")
-    _t887 = Proto.BooleanType()
-    return _t887
+    _t907 = Proto.BooleanType()
+    return _t907
 end
 
 function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding}
     consume_literal!(parser, "|")
-    xs447 = Proto.Binding[]
-    cond448 = match_lookahead_terminal(parser, "SYMBOL", 0)
-    while cond448
-        _t888 = parse_binding(parser)
-        item449 = _t888
-        push!(xs447, item449)
-        cond448 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    xs457 = Proto.Binding[]
+    cond458 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    while cond458
+        _t908 = parse_binding(parser)
+        item459 = _t908
+        push!(xs457, item459)
+        cond458 = match_lookahead_terminal(parser, "SYMBOL", 0)
     end
-    bindings450 = xs447
-    return bindings450
+    bindings460 = xs457
+    return bindings460
 end
 
 function parse_formula(parser::ParserState)::Proto.Formula
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "true", 1)
-            _t890 = 0
+            _t910 = 0
         else
             if match_lookahead_literal(parser, "relatom", 1)
-                _t891 = 11
+                _t911 = 11
             else
                 if match_lookahead_literal(parser, "reduce", 1)
-                    _t892 = 3
+                    _t912 = 3
                 else
                     if match_lookahead_literal(parser, "primitive", 1)
-                        _t893 = 10
+                        _t913 = 10
                     else
                         if match_lookahead_literal(parser, "pragma", 1)
-                            _t894 = 9
+                            _t914 = 9
                         else
                             if match_lookahead_literal(parser, "or", 1)
-                                _t895 = 5
+                                _t915 = 5
                             else
                                 if match_lookahead_literal(parser, "not", 1)
-                                    _t896 = 6
+                                    _t916 = 6
                                 else
                                     if match_lookahead_literal(parser, "ffi", 1)
-                                        _t897 = 7
+                                        _t917 = 7
                                     else
                                         if match_lookahead_literal(parser, "false", 1)
-                                            _t898 = 1
+                                            _t918 = 1
                                         else
                                             if match_lookahead_literal(parser, "exists", 1)
-                                                _t899 = 2
+                                                _t919 = 2
                                             else
                                                 if match_lookahead_literal(parser, "cast", 1)
-                                                    _t900 = 12
+                                                    _t920 = 12
                                                 else
                                                     if match_lookahead_literal(parser, "atom", 1)
-                                                        _t901 = 8
+                                                        _t921 = 8
                                                     else
                                                         if match_lookahead_literal(parser, "and", 1)
-                                                            _t902 = 4
+                                                            _t922 = 4
                                                         else
                                                             if match_lookahead_literal(parser, ">=", 1)
-                                                                _t903 = 10
+                                                                _t923 = 10
                                                             else
                                                                 if match_lookahead_literal(parser, ">", 1)
-                                                                    _t904 = 10
+                                                                    _t924 = 10
                                                                 else
                                                                     if match_lookahead_literal(parser, "=", 1)
-                                                                        _t905 = 10
+                                                                        _t925 = 10
                                                                     else
                                                                         if match_lookahead_literal(parser, "<=", 1)
-                                                                            _t906 = 10
+                                                                            _t926 = 10
                                                                         else
                                                                             if match_lookahead_literal(parser, "<", 1)
-                                                                                _t907 = 10
+                                                                                _t927 = 10
                                                                             else
                                                                                 if match_lookahead_literal(parser, "/", 1)
-                                                                                    _t908 = 10
+                                                                                    _t928 = 10
                                                                                 else
                                                                                     if match_lookahead_literal(parser, "-", 1)
-                                                                                        _t909 = 10
+                                                                                        _t929 = 10
                                                                                     else
                                                                                         if match_lookahead_literal(parser, "+", 1)
-                                                                                            _t910 = 10
+                                                                                            _t930 = 10
                                                                                         else
                                                                                             if match_lookahead_literal(parser, "*", 1)
-                                                                                                _t911 = 10
+                                                                                                _t931 = 10
                                                                                             else
-                                                                                                _t911 = -1
+                                                                                                _t931 = -1
                                                                                             end
-                                                                                            _t910 = _t911
+                                                                                            _t930 = _t931
                                                                                         end
-                                                                                        _t909 = _t910
+                                                                                        _t929 = _t930
                                                                                     end
-                                                                                    _t908 = _t909
+                                                                                    _t928 = _t929
                                                                                 end
-                                                                                _t907 = _t908
+                                                                                _t927 = _t928
                                                                             end
-                                                                            _t906 = _t907
+                                                                            _t926 = _t927
                                                                         end
-                                                                        _t905 = _t906
+                                                                        _t925 = _t926
                                                                     end
-                                                                    _t904 = _t905
+                                                                    _t924 = _t925
                                                                 end
-                                                                _t903 = _t904
+                                                                _t923 = _t924
                                                             end
-                                                            _t902 = _t903
+                                                            _t922 = _t923
                                                         end
-                                                        _t901 = _t902
+                                                        _t921 = _t922
                                                     end
-                                                    _t900 = _t901
+                                                    _t920 = _t921
                                                 end
-                                                _t899 = _t900
+                                                _t919 = _t920
                                             end
-                                            _t898 = _t899
+                                            _t918 = _t919
                                         end
-                                        _t897 = _t898
+                                        _t917 = _t918
                                     end
-                                    _t896 = _t897
+                                    _t916 = _t917
                                 end
-                                _t895 = _t896
+                                _t915 = _t916
                             end
-                            _t894 = _t895
+                            _t914 = _t915
                         end
-                        _t893 = _t894
+                        _t913 = _t914
                     end
-                    _t892 = _t893
+                    _t912 = _t913
                 end
-                _t891 = _t892
+                _t911 = _t912
             end
-            _t890 = _t891
+            _t910 = _t911
         end
-        _t889 = _t890
+        _t909 = _t910
     else
-        _t889 = -1
-    end
-    prediction451 = _t889
-    if prediction451 == 12
-        _t913 = parse_cast(parser)
-        cast464 = _t913
-        _t914 = Proto.Formula(formula_type=OneOf(:cast, cast464))
-        _t912 = _t914
+        _t909 = -1
+    end
+    prediction461 = _t909
+    if prediction461 == 12
+        _t933 = parse_cast(parser)
+        cast474 = _t933
+        _t934 = Proto.Formula(formula_type=OneOf(:cast, cast474))
+        _t932 = _t934
     else
-        if prediction451 == 11
-            _t916 = parse_rel_atom(parser)
-            rel_atom463 = _t916
-            _t917 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom463))
-            _t915 = _t917
+        if prediction461 == 11
+            _t936 = parse_rel_atom(parser)
+            rel_atom473 = _t936
+            _t937 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom473))
+            _t935 = _t937
         else
-            if prediction451 == 10
-                _t919 = parse_primitive(parser)
-                primitive462 = _t919
-                _t920 = Proto.Formula(formula_type=OneOf(:primitive, primitive462))
-                _t918 = _t920
+            if prediction461 == 10
+                _t939 = parse_primitive(parser)
+                primitive472 = _t939
+                _t940 = Proto.Formula(formula_type=OneOf(:primitive, primitive472))
+                _t938 = _t940
             else
-                if prediction451 == 9
-                    _t922 = parse_pragma(parser)
-                    pragma461 = _t922
-                    _t923 = Proto.Formula(formula_type=OneOf(:pragma, pragma461))
-                    _t921 = _t923
+                if prediction461 == 9
+                    _t942 = parse_pragma(parser)
+                    pragma471 = _t942
+                    _t943 = Proto.Formula(formula_type=OneOf(:pragma, pragma471))
+                    _t941 = _t943
                 else
-                    if prediction451 == 8
-                        _t925 = parse_atom(parser)
-                        atom460 = _t925
-                        _t926 = Proto.Formula(formula_type=OneOf(:atom, atom460))
-                        _t924 = _t926
+                    if prediction461 == 8
+                        _t945 = parse_atom(parser)
+                        atom470 = _t945
+                        _t946 = Proto.Formula(formula_type=OneOf(:atom, atom470))
+                        _t944 = _t946
                     else
-                        if prediction451 == 7
-                            _t928 = parse_ffi(parser)
-                            ffi459 = _t928
-                            _t929 = Proto.Formula(formula_type=OneOf(:ffi, ffi459))
-                            _t927 = _t929
+                        if prediction461 == 7
+                            _t948 = parse_ffi(parser)
+                            ffi469 = _t948
+                            _t949 = Proto.Formula(formula_type=OneOf(:ffi, ffi469))
+                            _t947 = _t949
                         else
-                            if prediction451 == 6
-                                _t931 = parse_not(parser)
-                                not458 = _t931
-                                _t932 = Proto.Formula(formula_type=OneOf(:not, not458))
-                                _t930 = _t932
+                            if prediction461 == 6
+                                _t951 = parse_not(parser)
+                                not468 = _t951
+                                _t952 = Proto.Formula(formula_type=OneOf(:not, not468))
+                                _t950 = _t952
                             else
-                                if prediction451 == 5
-                                    _t934 = parse_disjunction(parser)
-                                    disjunction457 = _t934
-                                    _t935 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction457))
-                                    _t933 = _t935
+                                if prediction461 == 5
+                                    _t954 = parse_disjunction(parser)
+                                    disjunction467 = _t954
+                                    _t955 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction467))
+                                    _t953 = _t955
                                 else
-                                    if prediction451 == 4
-                                        _t937 = parse_conjunction(parser)
-                                        conjunction456 = _t937
-                                        _t938 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction456))
-                                        _t936 = _t938
+                                    if prediction461 == 4
+                                        _t957 = parse_conjunction(parser)
+                                        conjunction466 = _t957
+                                        _t958 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction466))
+                                        _t956 = _t958
                                     else
-                                        if prediction451 == 3
-                                            _t940 = parse_reduce(parser)
-                                            reduce455 = _t940
-                                            _t941 = Proto.Formula(formula_type=OneOf(:reduce, reduce455))
-                                            _t939 = _t941
+                                        if prediction461 == 3
+                                            _t960 = parse_reduce(parser)
+                                            reduce465 = _t960
+                                            _t961 = Proto.Formula(formula_type=OneOf(:reduce, reduce465))
+                                            _t959 = _t961
                                         else
-                                            if prediction451 == 2
-                                                _t943 = parse_exists(parser)
-                                                exists454 = _t943
-                                                _t944 = Proto.Formula(formula_type=OneOf(:exists, exists454))
-                                                _t942 = _t944
+                                            if prediction461 == 2
+                                                _t963 = parse_exists(parser)
+                                                exists464 = _t963
+                                                _t964 = Proto.Formula(formula_type=OneOf(:exists, exists464))
+                                                _t962 = _t964
                                             else
-                                                if prediction451 == 1
-                                                    _t946 = parse_false(parser)
-                                                    false453 = _t946
-                                                    _t947 = Proto.Formula(formula_type=OneOf(:disjunction, false453))
-                                                    _t945 = _t947
+                                                if prediction461 == 1
+                                                    _t966 = parse_false(parser)
+                                                    false463 = _t966
+                                                    _t967 = Proto.Formula(formula_type=OneOf(:disjunction, false463))
+                                                    _t965 = _t967
                                                 else
-                                                    if prediction451 == 0
-                                                        _t949 = parse_true(parser)
-                                                        true452 = _t949
-                                                        _t950 = Proto.Formula(formula_type=OneOf(:conjunction, true452))
-                                                        _t948 = _t950
+                                                    if prediction461 == 0
+                                                        _t969 = parse_true(parser)
+                                                        true462 = _t969
+                                                        _t970 = Proto.Formula(formula_type=OneOf(:conjunction, true462))
+                                                        _t968 = _t970
                                                     else
                                                         throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0))))
                                                     end
-                                                    _t945 = _t948
+                                                    _t965 = _t968
                                                 end
-                                                _t942 = _t945
+                                                _t962 = _t965
                                             end
-                                            _t939 = _t942
+                                            _t959 = _t962
                                         end
-                                        _t936 = _t939
+                                        _t956 = _t959
                                     end
-                                    _t933 = _t936
+                                    _t953 = _t956
                                 end
-                                _t930 = _t933
+                                _t950 = _t953
                             end
-                            _t927 = _t930
+                            _t947 = _t950
                         end
-                        _t924 = _t927
+                        _t944 = _t947
                     end
-                    _t921 = _t924
+                    _t941 = _t944
                 end
-                _t918 = _t921
+                _t938 = _t941
             end
-            _t915 = _t918
+            _t935 = _t938
         end
-        _t912 = _t915
+        _t932 = _t935
     end
-    return _t912
+    return _t932
 end
 
 function parse_true(parser::ParserState)::Proto.Conjunction
     consume_literal!(parser, "(")
     consume_literal!(parser, "true")
     consume_literal!(parser, ")")
-    _t951 = Proto.Conjunction(args=Proto.Formula[])
-    return _t951
+    _t971 = Proto.Conjunction(args=Proto.Formula[])
+    return _t971
 end
 
 function parse_false(parser::ParserState)::Proto.Disjunction
     consume_literal!(parser, "(")
     consume_literal!(parser, "false")
     consume_literal!(parser, ")")
-    _t952 = Proto.Disjunction(args=Proto.Formula[])
-    return _t952
+    _t972 = Proto.Disjunction(args=Proto.Formula[])
+    return _t972
 end
 
 function parse_exists(parser::ParserState)::Proto.Exists
     consume_literal!(parser, "(")
     consume_literal!(parser, "exists")
-    _t953 = parse_bindings(parser)
-    bindings465 = _t953
-    _t954 = parse_formula(parser)
-    formula466 = _t954
+    _t973 = parse_bindings(parser)
+    bindings475 = _t973
+    _t974 = parse_formula(parser)
+    formula476 = _t974
     consume_literal!(parser, ")")
-    _t955 = Proto.Abstraction(vars=vcat(bindings465[1], !isnothing(bindings465[2]) ? bindings465[2] : []), value=formula466)
-    _t956 = Proto.Exists(body=_t955)
-    return _t956
+    _t975 = Proto.Abstraction(vars=vcat(bindings475[1], !isnothing(bindings475[2]) ? bindings475[2] : []), value=formula476)
+    _t976 = Proto.Exists(body=_t975)
+    return _t976
 end
 
 function parse_reduce(parser::ParserState)::Proto.Reduce
     consume_literal!(parser, "(")
     consume_literal!(parser, "reduce")
-    _t957 = parse_abstraction(parser)
-    abstraction467 = _t957
-    _t958 = parse_abstraction(parser)
-    abstraction_3468 = _t958
-    _t959 = parse_terms(parser)
-    terms469 = _t959
+    _t977 = parse_abstraction(parser)
+    abstraction477 = _t977
+    _t978 = parse_abstraction(parser)
+    abstraction_3478 = _t978
+    _t979 = parse_terms(parser)
+    terms479 = _t979
     consume_literal!(parser, ")")
-    _t960 = Proto.Reduce(op=abstraction467, body=abstraction_3468, terms=terms469)
-    return _t960
+    _t980 = Proto.Reduce(op=abstraction477, body=abstraction_3478, terms=terms479)
+    return _t980
 end
 
 function parse_terms(parser::ParserState)::Vector{Proto.Term}
     consume_literal!(parser, "(")
     consume_literal!(parser, "terms")
-    xs470 = Proto.Term[]
-    cond471 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond471
-        _t961 = parse_term(parser)
-        item472 = _t961
-        push!(xs470, item472)
-        cond471 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    xs480 = Proto.Term[]
+    cond481 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond481
+        _t981 = parse_term(parser)
+        item482 = _t981
+        push!(xs480, item482)
+        cond481 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    terms473 = xs470
+    terms483 = xs480
     consume_literal!(parser, ")")
-    return terms473
+    return terms483
 end
 
 function parse_term(parser::ParserState)::Proto.Term
     if match_lookahead_literal(parser, "true", 0)
-        _t962 = 1
+        _t982 = 1
     else
         if match_lookahead_literal(parser, "missing", 0)
-            _t963 = 1
+            _t983 = 1
         else
             if match_lookahead_literal(parser, "false", 0)
-                _t964 = 1
+                _t984 = 1
             else
                 if match_lookahead_literal(parser, "(", 0)
-                    _t965 = 1
+                    _t985 = 1
                 else
                     if match_lookahead_terminal(parser, "UINT128", 0)
-                        _t966 = 1
+                        _t986 = 1
                     else
                         if match_lookahead_terminal(parser, "SYMBOL", 0)
-                            _t967 = 0
+                            _t987 = 0
                         else
                             if match_lookahead_terminal(parser, "STRING", 0)
-                                _t968 = 1
+                                _t988 = 1
                             else
                                 if match_lookahead_terminal(parser, "INT128", 0)
-                                    _t969 = 1
+                                    _t989 = 1
                                 else
                                     if match_lookahead_terminal(parser, "INT", 0)
-                                        _t970 = 1
+                                        _t990 = 1
                                     else
                                         if match_lookahead_terminal(parser, "FLOAT", 0)
-                                            _t971 = 1
+                                            _t991 = 1
                                         else
                                             if match_lookahead_terminal(parser, "DECIMAL", 0)
-                                                _t972 = 1
+                                                _t992 = 1
                                             else
-                                                _t972 = -1
+                                                _t992 = -1
                                             end
-                                            _t971 = _t972
+                                            _t991 = _t992
                                         end
-                                        _t970 = _t971
+                                        _t990 = _t991
                                     end
-                                    _t969 = _t970
+                                    _t989 = _t990
                                 end
-                                _t968 = _t969
+                                _t988 = _t989
                             end
-                            _t967 = _t968
+                            _t987 = _t988
                         end
-                        _t966 = _t967
+                        _t986 = _t987
                     end
-                    _t965 = _t966
+                    _t985 = _t986
                 end
-                _t964 = _t965
+                _t984 = _t985
             end
-            _t963 = _t964
+            _t983 = _t984
         end
-        _t962 = _t963
-    end
-    prediction474 = _t962
-    if prediction474 == 1
-        _t974 = parse_constant(parser)
-        constant476 = _t974
-        _t975 = Proto.Term(term_type=OneOf(:constant, constant476))
-        _t973 = _t975
+        _t982 = _t983
+    end
+    prediction484 = _t982
+    if prediction484 == 1
+        _t994 = parse_constant(parser)
+        constant486 = _t994
+        _t995 = Proto.Term(term_type=OneOf(:constant, constant486))
+        _t993 = _t995
     else
-        if prediction474 == 0
-            _t977 = parse_var(parser)
-            var475 = _t977
-            _t978 = Proto.Term(term_type=OneOf(:var, var475))
-            _t976 = _t978
+        if prediction484 == 0
+            _t997 = parse_var(parser)
+            var485 = _t997
+            _t998 = Proto.Term(term_type=OneOf(:var, var485))
+            _t996 = _t998
         else
             throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0))))
         end
-        _t973 = _t976
+        _t993 = _t996
     end
-    return _t973
+    return _t993
 end
 
 function parse_var(parser::ParserState)::Proto.Var
-    symbol477 = consume_terminal!(parser, "SYMBOL")
-    _t979 = Proto.Var(name=symbol477)
-    return _t979
+    symbol487 = consume_terminal!(parser, "SYMBOL")
+    _t999 = Proto.Var(name=symbol487)
+    return _t999
 end
 
 function parse_constant(parser::ParserState)::Proto.Value
-    _t980 = parse_value(parser)
-    value478 = _t980
-    return value478
+    _t1000 = parse_value(parser)
+    value488 = _t1000
+    return value488
 end
 
 function parse_conjunction(parser::ParserState)::Proto.Conjunction
     consume_literal!(parser, "(")
     consume_literal!(parser, "and")
-    xs479 = Proto.Formula[]
-    cond480 = match_lookahead_literal(parser, "(", 0)
-    while cond480
-        _t981 = parse_formula(parser)
-        item481 = _t981
-        push!(xs479, item481)
-        cond480 = match_lookahead_literal(parser, "(", 0)
+    xs489 = Proto.Formula[]
+    cond490 = match_lookahead_literal(parser, "(", 0)
+    while cond490
+        _t1001 = parse_formula(parser)
+        item491 = _t1001
+        push!(xs489, item491)
+        cond490 = match_lookahead_literal(parser, "(", 0)
     end
-    formulas482 = xs479
+    formulas492 = xs489
     consume_literal!(parser, ")")
-    _t982 = Proto.Conjunction(args=formulas482)
-    return _t982
+    _t1002 = Proto.Conjunction(args=formulas492)
+    return _t1002
 end
 
 function parse_disjunction(parser::ParserState)::Proto.Disjunction
     consume_literal!(parser, "(")
     consume_literal!(parser, "or")
-    xs483 = Proto.Formula[]
-    cond484 = match_lookahead_literal(parser, "(", 0)
-    while cond484
-        _t983 = parse_formula(parser)
-        item485 = _t983
-        push!(xs483, item485)
-        cond484 = match_lookahead_literal(parser, "(", 0)
+    xs493 = Proto.Formula[]
+    cond494 = match_lookahead_literal(parser, "(", 0)
+    while cond494
+        _t1003 = parse_formula(parser)
+        item495 = _t1003
+        push!(xs493, item495)
+        cond494 = match_lookahead_literal(parser, "(", 0)
     end
-    formulas486 = xs483
+    formulas496 = xs493
     consume_literal!(parser, ")")
-    _t984 = Proto.Disjunction(args=formulas486)
-    return _t984
+    _t1004 = Proto.Disjunction(args=formulas496)
+    return _t1004
 end
 
 function parse_not(parser::ParserState)::Proto.Not
     consume_literal!(parser, "(")
     consume_literal!(parser, "not")
-    _t985 = parse_formula(parser)
-    formula487 = _t985
+    _t1005 = parse_formula(parser)
+    formula497 = _t1005
     consume_literal!(parser, ")")
-    _t986 = Proto.Not(arg=formula487)
-    return _t986
+    _t1006 = Proto.Not(arg=formula497)
+    return _t1006
 end
 
 function parse_ffi(parser::ParserState)::Proto.FFI
     consume_literal!(parser, "(")
     consume_literal!(parser, "ffi")
-    _t987 = parse_name(parser)
-    name488 = _t987
-    _t988 = parse_ffi_args(parser)
-    ffi_args489 = _t988
-    _t989 = parse_terms(parser)
-    terms490 = _t989
+    _t1007 = parse_name(parser)
+    name498 = _t1007
+    _t1008 = parse_ffi_args(parser)
+    ffi_args499 = _t1008
+    _t1009 = parse_terms(parser)
+    terms500 = _t1009
     consume_literal!(parser, ")")
-    _t990 = Proto.FFI(name=name488, args=ffi_args489, terms=terms490)
-    return _t990
+    _t1010 = Proto.FFI(name=name498, args=ffi_args499, terms=terms500)
+    return _t1010
 end
 
 function parse_name(parser::ParserState)::String
     consume_literal!(parser, ":")
-    symbol491 = consume_terminal!(parser, "SYMBOL")
-    return symbol491
+    symbol501 = consume_terminal!(parser, "SYMBOL")
+    return symbol501
 end
 
 function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction}
     consume_literal!(parser, "(")
     consume_literal!(parser, "args")
-    xs492 = Proto.Abstraction[]
-    cond493 = match_lookahead_literal(parser, "(", 0)
-    while cond493
-        _t991 = parse_abstraction(parser)
-        item494 = _t991
-        push!(xs492, item494)
-        cond493 = match_lookahead_literal(parser, "(", 0)
+    xs502 = Proto.Abstraction[]
+    cond503 = match_lookahead_literal(parser, "(", 0)
+    while cond503
+        _t1011 = parse_abstraction(parser)
+        item504 = _t1011
+        push!(xs502, item504)
+        cond503 = match_lookahead_literal(parser, "(", 0)
     end
-    abstractions495 = xs492
+    abstractions505 = xs502
     consume_literal!(parser, ")")
-    return abstractions495
+    return abstractions505
 end
 
 function parse_atom(parser::ParserState)::Proto.Atom
     consume_literal!(parser, "(")
     consume_literal!(parser, "atom")
-    _t992 = parse_relation_id(parser)
-    relation_id496 = _t992
-    xs497 = Proto.Term[]
-    cond498 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond498
-        _t993 = parse_term(parser)
-        item499 = _t993
-        push!(xs497, item499)
-        cond498 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    _t1012 = parse_relation_id(parser)
+    relation_id506 = _t1012
+    xs507 = Proto.Term[]
+    cond508 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond508
+        _t1013 = parse_term(parser)
+        item509 = _t1013
+        push!(xs507, item509)
+        cond508 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    terms500 = xs497
+    terms510 = xs507
     consume_literal!(parser, ")")
-    _t994 = Proto.Atom(name=relation_id496, terms=terms500)
-    return _t994
+    _t1014 = Proto.Atom(name=relation_id506, terms=terms510)
+    return _t1014
 end
 
 function parse_pragma(parser::ParserState)::Proto.Pragma
     consume_literal!(parser, "(")
     consume_literal!(parser, "pragma")
-    _t995 = parse_name(parser)
-    name501 = _t995
-    xs502 = Proto.Term[]
-    cond503 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond503
-        _t996 = parse_term(parser)
-        item504 = _t996
-        push!(xs502, item504)
-        cond503 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    _t1015 = parse_name(parser)
+    name511 = _t1015
+    xs512 = Proto.Term[]
+    cond513 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond513
+        _t1016 = parse_term(parser)
+        item514 = _t1016
+        push!(xs512, item514)
+        cond513 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    terms505 = xs502
+    terms515 = xs512
     consume_literal!(parser, ")")
-    _t997 = Proto.Pragma(name=name501, terms=terms505)
-    return _t997
+    _t1017 = Proto.Pragma(name=name511, terms=terms515)
+    return _t1017
 end
 
 function parse_primitive(parser::ParserState)::Proto.Primitive
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "primitive", 1)
-            _t999 = 9
+            _t1019 = 9
         else
             if match_lookahead_literal(parser, ">=", 1)
-                _t1000 = 4
+                _t1020 = 4
             else
                 if match_lookahead_literal(parser, ">", 1)
-                    _t1001 = 3
+                    _t1021 = 3
                 else
                     if match_lookahead_literal(parser, "=", 1)
-                        _t1002 = 0
+                        _t1022 = 0
                     else
                         if match_lookahead_literal(parser, "<=", 1)
-                            _t1003 = 2
+                            _t1023 = 2
                         else
                             if match_lookahead_literal(parser, "<", 1)
-                                _t1004 = 1
+                                _t1024 = 1
                             else
                                 if match_lookahead_literal(parser, "/", 1)
-                                    _t1005 = 8
+                                    _t1025 = 8
                                 else
                                     if match_lookahead_literal(parser, "-", 1)
-                                        _t1006 = 6
+                                        _t1026 = 6
                                     else
                                         if match_lookahead_literal(parser, "+", 1)
-                                            _t1007 = 5
+                                            _t1027 = 5
                                         else
                                             if match_lookahead_literal(parser, "*", 1)
-                                                _t1008 = 7
+                                                _t1028 = 7
                                             else
-                                                _t1008 = -1
+                                                _t1028 = -1
                                             end
-                                            _t1007 = _t1008
+                                            _t1027 = _t1028
                                         end
-                                        _t1006 = _t1007
+                                        _t1026 = _t1027
                                     end
-                                    _t1005 = _t1006
+                                    _t1025 = _t1026
                                 end
-                                _t1004 = _t1005
+                                _t1024 = _t1025
                             end
-                            _t1003 = _t1004
+                            _t1023 = _t1024
                         end
-                        _t1002 = _t1003
+                        _t1022 = _t1023
                     end
-                    _t1001 = _t1002
+                    _t1021 = _t1022
                 end
-                _t1000 = _t1001
+                _t1020 = _t1021
             end
-            _t999 = _t1000
+            _t1019 = _t1020
         end
-        _t998 = _t999
+        _t1018 = _t1019
     else
-        _t998 = -1
+        _t1018 = -1
     end
-    prediction506 = _t998
-    if prediction506 == 9
+    prediction516 = _t1018
+    if prediction516 == 9
         consume_literal!(parser, "(")
         consume_literal!(parser, "primitive")
-        _t1010 = parse_name(parser)
-        name516 = _t1010
-        xs517 = Proto.RelTerm[]
-        cond518 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-        while cond518
-            _t1011 = parse_rel_term(parser)
-            item519 = _t1011
-            push!(xs517, item519)
-            cond518 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+        _t1030 = parse_name(parser)
+        name526 = _t1030
+        xs527 = Proto.RelTerm[]
+        cond528 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+        while cond528
+            _t1031 = parse_rel_term(parser)
+            item529 = _t1031
+            push!(xs527, item529)
+            cond528 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
         end
-        rel_terms520 = xs517
+        rel_terms530 = xs527
         consume_literal!(parser, ")")
-        _t1012 = Proto.Primitive(name=name516, terms=rel_terms520)
-        _t1009 = _t1012
+        _t1032 = Proto.Primitive(name=name526, terms=rel_terms530)
+        _t1029 = _t1032
     else
-        if prediction506 == 8
-            _t1014 = parse_divide(parser)
-            divide515 = _t1014
-            _t1013 = divide515
+        if prediction516 == 8
+            _t1034 = parse_divide(parser)
+            divide525 = _t1034
+            _t1033 = divide525
         else
-            if prediction506 == 7
-                _t1016 = parse_multiply(parser)
-                multiply514 = _t1016
-                _t1015 = multiply514
+            if prediction516 == 7
+                _t1036 = parse_multiply(parser)
+                multiply524 = _t1036
+                _t1035 = multiply524
             else
-                if prediction506 == 6
-                    _t1018 = parse_minus(parser)
-                    minus513 = _t1018
-                    _t1017 = minus513
+                if prediction516 == 6
+                    _t1038 = parse_minus(parser)
+                    minus523 = _t1038
+                    _t1037 = minus523
                 else
-                    if prediction506 == 5
-                        _t1020 = parse_add(parser)
-                        add512 = _t1020
-                        _t1019 = add512
+                    if prediction516 == 5
+                        _t1040 = parse_add(parser)
+                        add522 = _t1040
+                        _t1039 = add522
                     else
-                        if prediction506 == 4
-                            _t1022 = parse_gt_eq(parser)
-                            gt_eq511 = _t1022
-                            _t1021 = gt_eq511
+                        if prediction516 == 4
+                            _t1042 = parse_gt_eq(parser)
+                            gt_eq521 = _t1042
+                            _t1041 = gt_eq521
                         else
-                            if prediction506 == 3
-                                _t1024 = parse_gt(parser)
-                                gt510 = _t1024
-                                _t1023 = gt510
+                            if prediction516 == 3
+                                _t1044 = parse_gt(parser)
+                                gt520 = _t1044
+                                _t1043 = gt520
                             else
-                                if prediction506 == 2
-                                    _t1026 = parse_lt_eq(parser)
-                                    lt_eq509 = _t1026
-                                    _t1025 = lt_eq509
+                                if prediction516 == 2
+                                    _t1046 = parse_lt_eq(parser)
+                                    lt_eq519 = _t1046
+                                    _t1045 = lt_eq519
                                 else
-                                    if prediction506 == 1
-                                        _t1028 = parse_lt(parser)
-                                        lt508 = _t1028
-                                        _t1027 = lt508
+                                    if prediction516 == 1
+                                        _t1048 = parse_lt(parser)
+                                        lt518 = _t1048
+                                        _t1047 = lt518
                                     else
-                                        if prediction506 == 0
-                                            _t1030 = parse_eq(parser)
-                                            eq507 = _t1030
-                                            _t1029 = eq507
+                                        if prediction516 == 0
+                                            _t1050 = parse_eq(parser)
+                                            eq517 = _t1050
+                                            _t1049 = eq517
                                         else
                                             throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0))))
                                         end
-                                        _t1027 = _t1029
+                                        _t1047 = _t1049
                                     end
-                                    _t1025 = _t1027
+                                    _t1045 = _t1047
                                 end
-                                _t1023 = _t1025
+                                _t1043 = _t1045
                             end
-                            _t1021 = _t1023
+                            _t1041 = _t1043
                         end
-                        _t1019 = _t1021
+                        _t1039 = _t1041
                     end
-                    _t1017 = _t1019
+                    _t1037 = _t1039
                 end
-                _t1015 = _t1017
+                _t1035 = _t1037
             end
-            _t1013 = _t1015
+            _t1033 = _t1035
         end
-        _t1009 = _t1013
+        _t1029 = _t1033
     end
-    return _t1009
+    return _t1029
 end
 
 function parse_eq(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "=")
-    _t1031 = parse_term(parser)
-    term521 = _t1031
-    _t1032 = parse_term(parser)
-    term_3522 = _t1032
+    _t1051 = parse_term(parser)
+    term531 = _t1051
+    _t1052 = parse_term(parser)
+    term_3532 = _t1052
     consume_literal!(parser, ")")
-    _t1033 = Proto.RelTerm(rel_term_type=OneOf(:term, term521))
-    _t1034 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3522))
-    _t1035 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1033, _t1034])
-    return _t1035
+    _t1053 = Proto.RelTerm(rel_term_type=OneOf(:term, term531))
+    _t1054 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532))
+    _t1055 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1053, _t1054])
+    return _t1055
 end
 
 function parse_lt(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "<")
-    _t1036 = parse_term(parser)
-    term523 = _t1036
-    _t1037 = parse_term(parser)
-    term_3524 = _t1037
+    _t1056 = parse_term(parser)
+    term533 = _t1056
+    _t1057 = parse_term(parser)
+    term_3534 = _t1057
     consume_literal!(parser, ")")
-    _t1038 = Proto.RelTerm(rel_term_type=OneOf(:term, term523))
-    _t1039 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3524))
-    _t1040 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1038, _t1039])
-    return _t1040
+    _t1058 = Proto.RelTerm(rel_term_type=OneOf(:term, term533))
+    _t1059 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3534))
+    _t1060 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1058, _t1059])
+    return _t1060
 end
 
 function parse_lt_eq(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "<=")
-    _t1041 = parse_term(parser)
-    term525 = _t1041
-    _t1042 = parse_term(parser)
-    term_3526 = _t1042
+    _t1061 = parse_term(parser)
+    term535 = _t1061
+    _t1062 = parse_term(parser)
+    term_3536 = _t1062
     consume_literal!(parser, ")")
-    _t1043 = Proto.RelTerm(rel_term_type=OneOf(:term, term525))
-    _t1044 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3526))
-    _t1045 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1043, _t1044])
-    return _t1045
+    _t1063 = Proto.RelTerm(rel_term_type=OneOf(:term, term535))
+    _t1064 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3536))
+    _t1065 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1063, _t1064])
+    return _t1065
 end
 
 function parse_gt(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, ">")
-    _t1046 = parse_term(parser)
-    term527 = _t1046
-    _t1047 = parse_term(parser)
-    term_3528 = _t1047
+    _t1066 = parse_term(parser)
+    term537 = _t1066
+    _t1067 = parse_term(parser)
+    term_3538 = _t1067
     consume_literal!(parser, ")")
-    _t1048 = Proto.RelTerm(rel_term_type=OneOf(:term, term527))
-    _t1049 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3528))
-    _t1050 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1048, _t1049])
-    return _t1050
+    _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term537))
+    _t1069 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538))
+    _t1070 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1068, _t1069])
+    return _t1070
 end
 
 function parse_gt_eq(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, ">=")
-    _t1051 = parse_term(parser)
-    term529 = _t1051
-    _t1052 = parse_term(parser)
-    term_3530 = _t1052
+    _t1071 = parse_term(parser)
+    term539 = _t1071
+    _t1072 = parse_term(parser)
+    term_3540 = _t1072
     consume_literal!(parser, ")")
-    _t1053 = Proto.RelTerm(rel_term_type=OneOf(:term, term529))
-    _t1054 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3530))
-    _t1055 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1053, _t1054])
-    return _t1055
+    _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term539))
+    _t1074 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3540))
+    _t1075 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1073, _t1074])
+    return _t1075
 end
 
 function parse_add(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "+")
-    _t1056 = parse_term(parser)
-    term531 = _t1056
-    _t1057 = parse_term(parser)
-    term_3532 = _t1057
-    _t1058 = parse_term(parser)
-    term_4533 = _t1058
+    _t1076 = parse_term(parser)
+    term541 = _t1076
+    _t1077 = parse_term(parser)
+    term_3542 = _t1077
+    _t1078 = parse_term(parser)
+    term_4543 = _t1078
     consume_literal!(parser, ")")
-    _t1059 = Proto.RelTerm(rel_term_type=OneOf(:term, term531))
-    _t1060 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3532))
-    _t1061 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4533))
-    _t1062 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1059, _t1060, _t1061])
-    return _t1062
+    _t1079 = Proto.RelTerm(rel_term_type=OneOf(:term, term541))
+    _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3542))
+    _t1081 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4543))
+    _t1082 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1079, _t1080, _t1081])
+    return _t1082
 end
 
 function parse_minus(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "-")
-    _t1063 = parse_term(parser)
-    term534 = _t1063
-    _t1064 = parse_term(parser)
-    term_3535 = _t1064
-    _t1065 = parse_term(parser)
-    term_4536 = _t1065
+    _t1083 = parse_term(parser)
+    term544 = _t1083
+    _t1084 = parse_term(parser)
+    term_3545 = _t1084
+    _t1085 = parse_term(parser)
+    term_4546 = _t1085
     consume_literal!(parser, ")")
-    _t1066 = Proto.RelTerm(rel_term_type=OneOf(:term, term534))
-    _t1067 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3535))
-    _t1068 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4536))
-    _t1069 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1066, _t1067, _t1068])
-    return _t1069
+    _t1086 = Proto.RelTerm(rel_term_type=OneOf(:term, term544))
+    _t1087 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3545))
+    _t1088 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4546))
+    _t1089 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1086, _t1087, _t1088])
+    return _t1089
 end
 
 function parse_multiply(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "*")
-    _t1070 = parse_term(parser)
-    term537 = _t1070
-    _t1071 = parse_term(parser)
-    term_3538 = _t1071
-    _t1072 = parse_term(parser)
-    term_4539 = _t1072
-    consume_literal!(parser, ")")
-    _t1073 = Proto.RelTerm(rel_term_type=OneOf(:term, term537))
-    _t1074 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3538))
-    _t1075 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4539))
-    _t1076 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1073, _t1074, _t1075])
-    return _t1076
+    _t1090 = parse_term(parser)
+    term547 = _t1090
+    _t1091 = parse_term(parser)
+    term_3548 = _t1091
+    _t1092 = parse_term(parser)
+    term_4549 = _t1092
+    consume_literal!(parser, ")")
+    _t1093 = Proto.RelTerm(rel_term_type=OneOf(:term, term547))
+    _t1094 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3548))
+    _t1095 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4549))
+    _t1096 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1093, _t1094, _t1095])
+    return _t1096
 end
 
 function parse_divide(parser::ParserState)::Proto.Primitive
     consume_literal!(parser, "(")
     consume_literal!(parser, "/")
-    _t1077 = parse_term(parser)
-    term540 = _t1077
-    _t1078 = parse_term(parser)
-    term_3541 = _t1078
-    _t1079 = parse_term(parser)
-    term_4542 = _t1079
+    _t1097 = parse_term(parser)
+    term550 = _t1097
+    _t1098 = parse_term(parser)
+    term_3551 = _t1098
+    _t1099 = parse_term(parser)
+    term_4552 = _t1099
     consume_literal!(parser, ")")
-    _t1080 = Proto.RelTerm(rel_term_type=OneOf(:term, term540))
-    _t1081 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3541))
-    _t1082 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4542))
-    _t1083 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1080, _t1081, _t1082])
-    return _t1083
+    _t1100 = Proto.RelTerm(rel_term_type=OneOf(:term, term550))
+    _t1101 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3551))
+    _t1102 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4552))
+    _t1103 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1100, _t1101, _t1102])
+    return _t1103
 end
 
 function parse_rel_term(parser::ParserState)::Proto.RelTerm
     if match_lookahead_literal(parser, "true", 0)
-        _t1084 = 1
+        _t1104 = 1
     else
         if match_lookahead_literal(parser, "missing", 0)
-            _t1085 = 1
+            _t1105 = 1
         else
             if match_lookahead_literal(parser, "false", 0)
-                _t1086 = 1
+                _t1106 = 1
             else
                 if match_lookahead_literal(parser, "(", 0)
-                    _t1087 = 1
+                    _t1107 = 1
                 else
                     if match_lookahead_literal(parser, "#", 0)
-                        _t1088 = 0
+                        _t1108 = 0
                     else
                         if match_lookahead_terminal(parser, "UINT128", 0)
-                            _t1089 = 1
+                            _t1109 = 1
                         else
                             if match_lookahead_terminal(parser, "SYMBOL", 0)
-                                _t1090 = 1
+                                _t1110 = 1
                             else
                                 if match_lookahead_terminal(parser, "STRING", 0)
-                                    _t1091 = 1
+                                    _t1111 = 1
                                 else
                                     if match_lookahead_terminal(parser, "INT128", 0)
-                                        _t1092 = 1
+                                        _t1112 = 1
                                     else
                                         if match_lookahead_terminal(parser, "INT", 0)
-                                            _t1093 = 1
+                                            _t1113 = 1
                                         else
                                             if match_lookahead_terminal(parser, "FLOAT", 0)
-                                                _t1094 = 1
+                                                _t1114 = 1
                                             else
                                                 if match_lookahead_terminal(parser, "DECIMAL", 0)
-                                                    _t1095 = 1
+                                                    _t1115 = 1
                                                 else
-                                                    _t1095 = -1
+                                                    _t1115 = -1
                                                 end
-                                                _t1094 = _t1095
+                                                _t1114 = _t1115
                                             end
-                                            _t1093 = _t1094
+                                            _t1113 = _t1114
                                         end
-                                        _t1092 = _t1093
+                                        _t1112 = _t1113
                                     end
-                                    _t1091 = _t1092
+                                    _t1111 = _t1112
                                 end
-                                _t1090 = _t1091
+                                _t1110 = _t1111
                             end
-                            _t1089 = _t1090
+                            _t1109 = _t1110
                         end
-                        _t1088 = _t1089
+                        _t1108 = _t1109
                     end
-                    _t1087 = _t1088
+                    _t1107 = _t1108
                 end
-                _t1086 = _t1087
+                _t1106 = _t1107
             end
-            _t1085 = _t1086
+            _t1105 = _t1106
         end
-        _t1084 = _t1085
-    end
-    prediction543 = _t1084
-    if prediction543 == 1
-        _t1097 = parse_term(parser)
-        term545 = _t1097
-        _t1098 = Proto.RelTerm(rel_term_type=OneOf(:term, term545))
-        _t1096 = _t1098
+        _t1104 = _t1105
+    end
+    prediction553 = _t1104
+    if prediction553 == 1
+        _t1117 = parse_term(parser)
+        term555 = _t1117
+        _t1118 = Proto.RelTerm(rel_term_type=OneOf(:term, term555))
+        _t1116 = _t1118
     else
-        if prediction543 == 0
-            _t1100 = parse_specialized_value(parser)
-            specialized_value544 = _t1100
-            _t1101 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value544))
-            _t1099 = _t1101
+        if prediction553 == 0
+            _t1120 = parse_specialized_value(parser)
+            specialized_value554 = _t1120
+            _t1121 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value554))
+            _t1119 = _t1121
         else
             throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0))))
         end
-        _t1096 = _t1099
+        _t1116 = _t1119
     end
-    return _t1096
+    return _t1116
 end
 
 function parse_specialized_value(parser::ParserState)::Proto.Value
     consume_literal!(parser, "#")
-    _t1102 = parse_value(parser)
-    value546 = _t1102
-    return value546
+    _t1122 = parse_value(parser)
+    value556 = _t1122
+    return value556
 end
 
 function parse_rel_atom(parser::ParserState)::Proto.RelAtom
     consume_literal!(parser, "(")
     consume_literal!(parser, "relatom")
-    _t1103 = parse_name(parser)
-    name547 = _t1103
-    xs548 = Proto.RelTerm[]
-    cond549 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond549
-        _t1104 = parse_rel_term(parser)
-        item550 = _t1104
-        push!(xs548, item550)
-        cond549 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    end
-    rel_terms551 = xs548
-    consume_literal!(parser, ")")
-    _t1105 = Proto.RelAtom(name=name547, terms=rel_terms551)
-    return _t1105
+    _t1123 = parse_name(parser)
+    name557 = _t1123
+    xs558 = Proto.RelTerm[]
+    cond559 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond559
+        _t1124 = parse_rel_term(parser)
+        item560 = _t1124
+        push!(xs558, item560)
+        cond559 = (((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    end
+    rel_terms561 = xs558
+    consume_literal!(parser, ")")
+    _t1125 = Proto.RelAtom(name=name557, terms=rel_terms561)
+    return _t1125
 end
 
 function parse_cast(parser::ParserState)::Proto.Cast
     consume_literal!(parser, "(")
     consume_literal!(parser, "cast")
-    _t1106 = parse_term(parser)
-    term552 = _t1106
-    _t1107 = parse_term(parser)
-    term_3553 = _t1107
+    _t1126 = parse_term(parser)
+    term562 = _t1126
+    _t1127 = parse_term(parser)
+    term_3563 = _t1127
     consume_literal!(parser, ")")
-    _t1108 = Proto.Cast(input=term552, result=term_3553)
-    return _t1108
+    _t1128 = Proto.Cast(input=term562, result=term_3563)
+    return _t1128
 end
 
 function parse_attrs(parser::ParserState)::Vector{Proto.Attribute}
     consume_literal!(parser, "(")
     consume_literal!(parser, "attrs")
-    xs554 = Proto.Attribute[]
-    cond555 = match_lookahead_literal(parser, "(", 0)
-    while cond555
-        _t1109 = parse_attribute(parser)
-        item556 = _t1109
-        push!(xs554, item556)
-        cond555 = match_lookahead_literal(parser, "(", 0)
+    xs564 = Proto.Attribute[]
+    cond565 = match_lookahead_literal(parser, "(", 0)
+    while cond565
+        _t1129 = parse_attribute(parser)
+        item566 = _t1129
+        push!(xs564, item566)
+        cond565 = match_lookahead_literal(parser, "(", 0)
     end
-    attributes557 = xs554
+    attributes567 = xs564
     consume_literal!(parser, ")")
-    return attributes557
+    return attributes567
 end
 
 function parse_attribute(parser::ParserState)::Proto.Attribute
     consume_literal!(parser, "(")
     consume_literal!(parser, "attribute")
-    _t1110 = parse_name(parser)
-    name558 = _t1110
-    xs559 = Proto.Value[]
-    cond560 = (((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond560
-        _t1111 = parse_value(parser)
-        item561 = _t1111
-        push!(xs559, item561)
-        cond560 = (((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    _t1130 = parse_name(parser)
+    name568 = _t1130
+    xs569 = Proto.Value[]
+    cond570 = (((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond570
+        _t1131 = parse_value(parser)
+        item571 = _t1131
+        push!(xs569, item571)
+        cond570 = (((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    values562 = xs559
+    values572 = xs569
     consume_literal!(parser, ")")
-    _t1112 = Proto.Attribute(name=name558, args=values562)
-    return _t1112
+    _t1132 = Proto.Attribute(name=name568, args=values572)
+    return _t1132
 end
 
 function parse_algorithm(parser::ParserState)::Proto.Algorithm
     consume_literal!(parser, "(")
     consume_literal!(parser, "algorithm")
-    xs563 = Proto.RelationId[]
-    cond564 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond564
-        _t1113 = parse_relation_id(parser)
-        item565 = _t1113
-        push!(xs563, item565)
-        cond564 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
+    xs573 = Proto.RelationId[]
+    cond574 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond574
+        _t1133 = parse_relation_id(parser)
+        item575 = _t1133
+        push!(xs573, item575)
+        cond574 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    relation_ids566 = xs563
-    _t1114 = parse_script(parser)
-    script567 = _t1114
+    relation_ids576 = xs573
+    _t1134 = parse_script(parser)
+    script577 = _t1134
     consume_literal!(parser, ")")
-    _t1115 = Proto.Algorithm(var"#global"=relation_ids566, body=script567)
-    return _t1115
+    _t1135 = Proto.Algorithm(var"#global"=relation_ids576, body=script577)
+    return _t1135
 end
 
 function parse_script(parser::ParserState)::Proto.Script
     consume_literal!(parser, "(")
     consume_literal!(parser, "script")
-    xs568 = Proto.Construct[]
-    cond569 = match_lookahead_literal(parser, "(", 0)
-    while cond569
-        _t1116 = parse_construct(parser)
-        item570 = _t1116
-        push!(xs568, item570)
-        cond569 = match_lookahead_literal(parser, "(", 0)
+    xs578 = Proto.Construct[]
+    cond579 = match_lookahead_literal(parser, "(", 0)
+    while cond579
+        _t1136 = parse_construct(parser)
+        item580 = _t1136
+        push!(xs578, item580)
+        cond579 = match_lookahead_literal(parser, "(", 0)
     end
-    constructs571 = xs568
+    constructs581 = xs578
     consume_literal!(parser, ")")
-    _t1117 = Proto.Script(constructs=constructs571)
-    return _t1117
+    _t1137 = Proto.Script(constructs=constructs581)
+    return _t1137
 end
 
 function parse_construct(parser::ParserState)::Proto.Construct
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "upsert", 1)
-            _t1119 = 1
+            _t1139 = 1
         else
             if match_lookahead_literal(parser, "monus", 1)
-                _t1120 = 1
+                _t1140 = 1
             else
                 if match_lookahead_literal(parser, "monoid", 1)
-                    _t1121 = 1
+                    _t1141 = 1
                 else
                     if match_lookahead_literal(parser, "loop", 1)
-                        _t1122 = 0
+                        _t1142 = 0
                     else
                         if match_lookahead_literal(parser, "break", 1)
-                            _t1123 = 1
+                            _t1143 = 1
                         else
                             if match_lookahead_literal(parser, "assign", 1)
-                                _t1124 = 1
+                                _t1144 = 1
                             else
-                                _t1124 = -1
+                                _t1144 = -1
                             end
-                            _t1123 = _t1124
+                            _t1143 = _t1144
                         end
-                        _t1122 = _t1123
+                        _t1142 = _t1143
                     end
-                    _t1121 = _t1122
+                    _t1141 = _t1142
                 end
-                _t1120 = _t1121
+                _t1140 = _t1141
             end
-            _t1119 = _t1120
+            _t1139 = _t1140
         end
-        _t1118 = _t1119
+        _t1138 = _t1139
     else
-        _t1118 = -1
-    end
-    prediction572 = _t1118
-    if prediction572 == 1
-        _t1126 = parse_instruction(parser)
-        instruction574 = _t1126
-        _t1127 = Proto.Construct(construct_type=OneOf(:instruction, instruction574))
-        _t1125 = _t1127
+        _t1138 = -1
+    end
+    prediction582 = _t1138
+    if prediction582 == 1
+        _t1146 = parse_instruction(parser)
+        instruction584 = _t1146
+        _t1147 = Proto.Construct(construct_type=OneOf(:instruction, instruction584))
+        _t1145 = _t1147
     else
-        if prediction572 == 0
-            _t1129 = parse_loop(parser)
-            loop573 = _t1129
-            _t1130 = Proto.Construct(construct_type=OneOf(:loop, loop573))
-            _t1128 = _t1130
+        if prediction582 == 0
+            _t1149 = parse_loop(parser)
+            loop583 = _t1149
+            _t1150 = Proto.Construct(construct_type=OneOf(:loop, loop583))
+            _t1148 = _t1150
         else
             throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0))))
         end
-        _t1125 = _t1128
+        _t1145 = _t1148
     end
-    return _t1125
+    return _t1145
 end
 
 function parse_loop(parser::ParserState)::Proto.Loop
     consume_literal!(parser, "(")
     consume_literal!(parser, "loop")
-    _t1131 = parse_init(parser)
-    init575 = _t1131
-    _t1132 = parse_script(parser)
-    script576 = _t1132
+    _t1151 = parse_init(parser)
+    init585 = _t1151
+    _t1152 = parse_script(parser)
+    script586 = _t1152
     consume_literal!(parser, ")")
-    _t1133 = Proto.Loop(init=init575, body=script576)
-    return _t1133
+    _t1153 = Proto.Loop(init=init585, body=script586)
+    return _t1153
 end
 
 function parse_init(parser::ParserState)::Vector{Proto.Instruction}
     consume_literal!(parser, "(")
     consume_literal!(parser, "init")
-    xs577 = Proto.Instruction[]
-    cond578 = match_lookahead_literal(parser, "(", 0)
-    while cond578
-        _t1134 = parse_instruction(parser)
-        item579 = _t1134
-        push!(xs577, item579)
-        cond578 = match_lookahead_literal(parser, "(", 0)
+    xs587 = Proto.Instruction[]
+    cond588 = match_lookahead_literal(parser, "(", 0)
+    while cond588
+        _t1154 = parse_instruction(parser)
+        item589 = _t1154
+        push!(xs587, item589)
+        cond588 = match_lookahead_literal(parser, "(", 0)
     end
-    instructions580 = xs577
+    instructions590 = xs587
     consume_literal!(parser, ")")
-    return instructions580
+    return instructions590
 end
 
 function parse_instruction(parser::ParserState)::Proto.Instruction
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "upsert", 1)
-            _t1136 = 1
+            _t1156 = 1
         else
             if match_lookahead_literal(parser, "monus", 1)
-                _t1137 = 4
+                _t1157 = 4
             else
                 if match_lookahead_literal(parser, "monoid", 1)
-                    _t1138 = 3
+                    _t1158 = 3
                 else
                     if match_lookahead_literal(parser, "break", 1)
-                        _t1139 = 2
+                        _t1159 = 2
                     else
                         if match_lookahead_literal(parser, "assign", 1)
-                            _t1140 = 0
+                            _t1160 = 0
                         else
-                            _t1140 = -1
+                            _t1160 = -1
                         end
-                        _t1139 = _t1140
+                        _t1159 = _t1160
                     end
-                    _t1138 = _t1139
+                    _t1158 = _t1159
                 end
-                _t1137 = _t1138
+                _t1157 = _t1158
             end
-            _t1136 = _t1137
+            _t1156 = _t1157
         end
-        _t1135 = _t1136
+        _t1155 = _t1156
     else
-        _t1135 = -1
-    end
-    prediction581 = _t1135
-    if prediction581 == 4
-        _t1142 = parse_monus_def(parser)
-        monus_def586 = _t1142
-        _t1143 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def586))
-        _t1141 = _t1143
+        _t1155 = -1
+    end
+    prediction591 = _t1155
+    if prediction591 == 4
+        _t1162 = parse_monus_def(parser)
+        monus_def596 = _t1162
+        _t1163 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def596))
+        _t1161 = _t1163
     else
-        if prediction581 == 3
-            _t1145 = parse_monoid_def(parser)
-            monoid_def585 = _t1145
-            _t1146 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def585))
-            _t1144 = _t1146
+        if prediction591 == 3
+            _t1165 = parse_monoid_def(parser)
+            monoid_def595 = _t1165
+            _t1166 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def595))
+            _t1164 = _t1166
         else
-            if prediction581 == 2
-                _t1148 = parse_break(parser)
-                break584 = _t1148
-                _t1149 = Proto.Instruction(instr_type=OneOf(:var"#break", break584))
-                _t1147 = _t1149
+            if prediction591 == 2
+                _t1168 = parse_break(parser)
+                break594 = _t1168
+                _t1169 = Proto.Instruction(instr_type=OneOf(:var"#break", break594))
+                _t1167 = _t1169
             else
-                if prediction581 == 1
-                    _t1151 = parse_upsert(parser)
-                    upsert583 = _t1151
-                    _t1152 = Proto.Instruction(instr_type=OneOf(:upsert, upsert583))
-                    _t1150 = _t1152
+                if prediction591 == 1
+                    _t1171 = parse_upsert(parser)
+                    upsert593 = _t1171
+                    _t1172 = Proto.Instruction(instr_type=OneOf(:upsert, upsert593))
+                    _t1170 = _t1172
                 else
-                    if prediction581 == 0
-                        _t1154 = parse_assign(parser)
-                        assign582 = _t1154
-                        _t1155 = Proto.Instruction(instr_type=OneOf(:assign, assign582))
-                        _t1153 = _t1155
+                    if prediction591 == 0
+                        _t1174 = parse_assign(parser)
+                        assign592 = _t1174
+                        _t1175 = Proto.Instruction(instr_type=OneOf(:assign, assign592))
+                        _t1173 = _t1175
                     else
                         throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0))))
                     end
-                    _t1150 = _t1153
+                    _t1170 = _t1173
                 end
-                _t1147 = _t1150
+                _t1167 = _t1170
             end
-            _t1144 = _t1147
+            _t1164 = _t1167
         end
-        _t1141 = _t1144
+        _t1161 = _t1164
     end
-    return _t1141
+    return _t1161
 end
 
 function parse_assign(parser::ParserState)::Proto.Assign
     consume_literal!(parser, "(")
     consume_literal!(parser, "assign")
-    _t1156 = parse_relation_id(parser)
-    relation_id587 = _t1156
-    _t1157 = parse_abstraction(parser)
-    abstraction588 = _t1157
+    _t1176 = parse_relation_id(parser)
+    relation_id597 = _t1176
+    _t1177 = parse_abstraction(parser)
+    abstraction598 = _t1177
     if match_lookahead_literal(parser, "(", 0)
-        _t1159 = parse_attrs(parser)
-        _t1158 = _t1159
+        _t1179 = parse_attrs(parser)
+        _t1178 = _t1179
     else
-        _t1158 = nothing
+        _t1178 = nothing
     end
-    attrs589 = _t1158
+    attrs599 = _t1178
     consume_literal!(parser, ")")
-    _t1160 = Proto.Assign(name=relation_id587, body=abstraction588, attrs=(!isnothing(attrs589) ? attrs589 : Proto.Attribute[]))
-    return _t1160
+    _t1180 = Proto.Assign(name=relation_id597, body=abstraction598, attrs=(!isnothing(attrs599) ? attrs599 : Proto.Attribute[]))
+    return _t1180
 end
 
 function parse_upsert(parser::ParserState)::Proto.Upsert
     consume_literal!(parser, "(")
     consume_literal!(parser, "upsert")
-    _t1161 = parse_relation_id(parser)
-    relation_id590 = _t1161
-    _t1162 = parse_abstraction_with_arity(parser)
-    abstraction_with_arity591 = _t1162
+    _t1181 = parse_relation_id(parser)
+    relation_id600 = _t1181
+    _t1182 = parse_abstraction_with_arity(parser)
+    abstraction_with_arity601 = _t1182
     if match_lookahead_literal(parser, "(", 0)
-        _t1164 = parse_attrs(parser)
-        _t1163 = _t1164
+        _t1184 = parse_attrs(parser)
+        _t1183 = _t1184
     else
-        _t1163 = nothing
+        _t1183 = nothing
     end
-    attrs592 = _t1163
+    attrs602 = _t1183
     consume_literal!(parser, ")")
-    _t1165 = Proto.Upsert(name=relation_id590, body=abstraction_with_arity591[1], attrs=(!isnothing(attrs592) ? attrs592 : Proto.Attribute[]), value_arity=abstraction_with_arity591[2])
-    return _t1165
+    _t1185 = Proto.Upsert(name=relation_id600, body=abstraction_with_arity601[1], attrs=(!isnothing(attrs602) ? attrs602 : Proto.Attribute[]), value_arity=abstraction_with_arity601[2])
+    return _t1185
 end
 
 function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64}
     consume_literal!(parser, "(")
-    _t1166 = parse_bindings(parser)
-    bindings593 = _t1166
-    _t1167 = parse_formula(parser)
-    formula594 = _t1167
+    _t1186 = parse_bindings(parser)
+    bindings603 = _t1186
+    _t1187 = parse_formula(parser)
+    formula604 = _t1187
     consume_literal!(parser, ")")
-    _t1168 = Proto.Abstraction(vars=vcat(bindings593[1], !isnothing(bindings593[2]) ? bindings593[2] : []), value=formula594)
-    return (_t1168, length(bindings593[2]),)
+    _t1188 = Proto.Abstraction(vars=vcat(bindings603[1], !isnothing(bindings603[2]) ? bindings603[2] : []), value=formula604)
+    return (_t1188, length(bindings603[2]),)
 end
 
 function parse_break(parser::ParserState)::Proto.Break
     consume_literal!(parser, "(")
     consume_literal!(parser, "break")
-    _t1169 = parse_relation_id(parser)
-    relation_id595 = _t1169
-    _t1170 = parse_abstraction(parser)
-    abstraction596 = _t1170
+    _t1189 = parse_relation_id(parser)
+    relation_id605 = _t1189
+    _t1190 = parse_abstraction(parser)
+    abstraction606 = _t1190
     if match_lookahead_literal(parser, "(", 0)
-        _t1172 = parse_attrs(parser)
-        _t1171 = _t1172
+        _t1192 = parse_attrs(parser)
+        _t1191 = _t1192
     else
-        _t1171 = nothing
+        _t1191 = nothing
     end
-    attrs597 = _t1171
+    attrs607 = _t1191
     consume_literal!(parser, ")")
-    _t1173 = Proto.Break(name=relation_id595, body=abstraction596, attrs=(!isnothing(attrs597) ? attrs597 : Proto.Attribute[]))
-    return _t1173
+    _t1193 = Proto.Break(name=relation_id605, body=abstraction606, attrs=(!isnothing(attrs607) ? attrs607 : Proto.Attribute[]))
+    return _t1193
 end
 
 function parse_monoid_def(parser::ParserState)::Proto.MonoidDef
     consume_literal!(parser, "(")
     consume_literal!(parser, "monoid")
-    _t1174 = parse_monoid(parser)
-    monoid598 = _t1174
-    _t1175 = parse_relation_id(parser)
-    relation_id599 = _t1175
-    _t1176 = parse_abstraction_with_arity(parser)
-    abstraction_with_arity600 = _t1176
+    _t1194 = parse_monoid(parser)
+    monoid608 = _t1194
+    _t1195 = parse_relation_id(parser)
+    relation_id609 = _t1195
+    _t1196 = parse_abstraction_with_arity(parser)
+    abstraction_with_arity610 = _t1196
     if match_lookahead_literal(parser, "(", 0)
-        _t1178 = parse_attrs(parser)
-        _t1177 = _t1178
+        _t1198 = parse_attrs(parser)
+        _t1197 = _t1198
     else
-        _t1177 = nothing
+        _t1197 = nothing
     end
-    attrs601 = _t1177
+    attrs611 = _t1197
     consume_literal!(parser, ")")
-    _t1179 = Proto.MonoidDef(monoid=monoid598, name=relation_id599, body=abstraction_with_arity600[1], attrs=(!isnothing(attrs601) ? attrs601 : Proto.Attribute[]), value_arity=abstraction_with_arity600[2])
-    return _t1179
+    _t1199 = Proto.MonoidDef(monoid=monoid608, name=relation_id609, body=abstraction_with_arity610[1], attrs=(!isnothing(attrs611) ? attrs611 : Proto.Attribute[]), value_arity=abstraction_with_arity610[2])
+    return _t1199
 end
 
 function parse_monoid(parser::ParserState)::Proto.Monoid
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "sum", 1)
-            _t1181 = 3
+            _t1201 = 3
         else
             if match_lookahead_literal(parser, "or", 1)
-                _t1182 = 0
+                _t1202 = 0
             else
                 if match_lookahead_literal(parser, "min", 1)
-                    _t1183 = 1
+                    _t1203 = 1
                 else
                     if match_lookahead_literal(parser, "max", 1)
-                        _t1184 = 2
+                        _t1204 = 2
                     else
-                        _t1184 = -1
+                        _t1204 = -1
                     end
-                    _t1183 = _t1184
+                    _t1203 = _t1204
                 end
-                _t1182 = _t1183
+                _t1202 = _t1203
             end
-            _t1181 = _t1182
+            _t1201 = _t1202
         end
-        _t1180 = _t1181
+        _t1200 = _t1201
     else
-        _t1180 = -1
-    end
-    prediction602 = _t1180
-    if prediction602 == 3
-        _t1186 = parse_sum_monoid(parser)
-        sum_monoid606 = _t1186
-        _t1187 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid606))
-        _t1185 = _t1187
+        _t1200 = -1
+    end
+    prediction612 = _t1200
+    if prediction612 == 3
+        _t1206 = parse_sum_monoid(parser)
+        sum_monoid616 = _t1206
+        _t1207 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid616))
+        _t1205 = _t1207
     else
-        if prediction602 == 2
-            _t1189 = parse_max_monoid(parser)
-            max_monoid605 = _t1189
-            _t1190 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid605))
-            _t1188 = _t1190
+        if prediction612 == 2
+            _t1209 = parse_max_monoid(parser)
+            max_monoid615 = _t1209
+            _t1210 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid615))
+            _t1208 = _t1210
         else
-            if prediction602 == 1
-                _t1192 = parse_min_monoid(parser)
-                min_monoid604 = _t1192
-                _t1193 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid604))
-                _t1191 = _t1193
+            if prediction612 == 1
+                _t1212 = parse_min_monoid(parser)
+                min_monoid614 = _t1212
+                _t1213 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid614))
+                _t1211 = _t1213
             else
-                if prediction602 == 0
-                    _t1195 = parse_or_monoid(parser)
-                    or_monoid603 = _t1195
-                    _t1196 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid603))
-                    _t1194 = _t1196
+                if prediction612 == 0
+                    _t1215 = parse_or_monoid(parser)
+                    or_monoid613 = _t1215
+                    _t1216 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid613))
+                    _t1214 = _t1216
                 else
                     throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0))))
                 end
-                _t1191 = _t1194
+                _t1211 = _t1214
             end
-            _t1188 = _t1191
+            _t1208 = _t1211
         end
-        _t1185 = _t1188
+        _t1205 = _t1208
     end
-    return _t1185
+    return _t1205
 end
 
 function parse_or_monoid(parser::ParserState)::Proto.OrMonoid
     consume_literal!(parser, "(")
     consume_literal!(parser, "or")
     consume_literal!(parser, ")")
-    _t1197 = Proto.OrMonoid()
-    return _t1197
+    _t1217 = Proto.OrMonoid()
+    return _t1217
 end
 
 function parse_min_monoid(parser::ParserState)::Proto.MinMonoid
     consume_literal!(parser, "(")
     consume_literal!(parser, "min")
-    _t1198 = parse_type(parser)
-    type607 = _t1198
+    _t1218 = parse_type(parser)
+    type617 = _t1218
     consume_literal!(parser, ")")
-    _t1199 = Proto.MinMonoid(var"#type"=type607)
-    return _t1199
+    _t1219 = Proto.MinMonoid(var"#type"=type617)
+    return _t1219
 end
 
 function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid
     consume_literal!(parser, "(")
     consume_literal!(parser, "max")
-    _t1200 = parse_type(parser)
-    type608 = _t1200
+    _t1220 = parse_type(parser)
+    type618 = _t1220
     consume_literal!(parser, ")")
-    _t1201 = Proto.MaxMonoid(var"#type"=type608)
-    return _t1201
+    _t1221 = Proto.MaxMonoid(var"#type"=type618)
+    return _t1221
 end
 
 function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid
     consume_literal!(parser, "(")
     consume_literal!(parser, "sum")
-    _t1202 = parse_type(parser)
-    type609 = _t1202
+    _t1222 = parse_type(parser)
+    type619 = _t1222
     consume_literal!(parser, ")")
-    _t1203 = Proto.SumMonoid(var"#type"=type609)
-    return _t1203
+    _t1223 = Proto.SumMonoid(var"#type"=type619)
+    return _t1223
 end
 
 function parse_monus_def(parser::ParserState)::Proto.MonusDef
     consume_literal!(parser, "(")
     consume_literal!(parser, "monus")
-    _t1204 = parse_monoid(parser)
-    monoid610 = _t1204
-    _t1205 = parse_relation_id(parser)
-    relation_id611 = _t1205
-    _t1206 = parse_abstraction_with_arity(parser)
-    abstraction_with_arity612 = _t1206
+    _t1224 = parse_monoid(parser)
+    monoid620 = _t1224
+    _t1225 = parse_relation_id(parser)
+    relation_id621 = _t1225
+    _t1226 = parse_abstraction_with_arity(parser)
+    abstraction_with_arity622 = _t1226
     if match_lookahead_literal(parser, "(", 0)
-        _t1208 = parse_attrs(parser)
-        _t1207 = _t1208
+        _t1228 = parse_attrs(parser)
+        _t1227 = _t1228
     else
-        _t1207 = nothing
+        _t1227 = nothing
     end
-    attrs613 = _t1207
+    attrs623 = _t1227
     consume_literal!(parser, ")")
-    _t1209 = Proto.MonusDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[1], attrs=(!isnothing(attrs613) ? attrs613 : Proto.Attribute[]), value_arity=abstraction_with_arity612[2])
-    return _t1209
+    _t1229 = Proto.MonusDef(monoid=monoid620, name=relation_id621, body=abstraction_with_arity622[1], attrs=(!isnothing(attrs623) ? attrs623 : Proto.Attribute[]), value_arity=abstraction_with_arity622[2])
+    return _t1229
 end
 
 function parse_constraint(parser::ParserState)::Proto.Constraint
     consume_literal!(parser, "(")
     consume_literal!(parser, "functional_dependency")
-    _t1210 = parse_relation_id(parser)
-    relation_id614 = _t1210
-    _t1211 = parse_abstraction(parser)
-    abstraction615 = _t1211
-    _t1212 = parse_functional_dependency_keys(parser)
-    functional_dependency_keys616 = _t1212
-    _t1213 = parse_functional_dependency_values(parser)
-    functional_dependency_values617 = _t1213
+    _t1230 = parse_relation_id(parser)
+    relation_id624 = _t1230
+    _t1231 = parse_abstraction(parser)
+    abstraction625 = _t1231
+    _t1232 = parse_functional_dependency_keys(parser)
+    functional_dependency_keys626 = _t1232
+    _t1233 = parse_functional_dependency_values(parser)
+    functional_dependency_values627 = _t1233
     consume_literal!(parser, ")")
-    _t1214 = Proto.FunctionalDependency(guard=abstraction615, keys=functional_dependency_keys616, values=functional_dependency_values617)
-    _t1215 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1214), name=relation_id614)
-    return _t1215
+    _t1234 = Proto.FunctionalDependency(guard=abstraction625, keys=functional_dependency_keys626, values=functional_dependency_values627)
+    _t1235 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1234), name=relation_id624)
+    return _t1235
 end
 
 function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var}
     consume_literal!(parser, "(")
     consume_literal!(parser, "keys")
-    xs618 = Proto.Var[]
-    cond619 = match_lookahead_terminal(parser, "SYMBOL", 0)
-    while cond619
-        _t1216 = parse_var(parser)
-        item620 = _t1216
-        push!(xs618, item620)
-        cond619 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    xs628 = Proto.Var[]
+    cond629 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    while cond629
+        _t1236 = parse_var(parser)
+        item630 = _t1236
+        push!(xs628, item630)
+        cond629 = match_lookahead_terminal(parser, "SYMBOL", 0)
     end
-    vars621 = xs618
+    vars631 = xs628
     consume_literal!(parser, ")")
-    return vars621
+    return vars631
 end
 
 function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var}
     consume_literal!(parser, "(")
     consume_literal!(parser, "values")
-    xs622 = Proto.Var[]
-    cond623 = match_lookahead_terminal(parser, "SYMBOL", 0)
-    while cond623
-        _t1217 = parse_var(parser)
-        item624 = _t1217
-        push!(xs622, item624)
-        cond623 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    xs632 = Proto.Var[]
+    cond633 = match_lookahead_terminal(parser, "SYMBOL", 0)
+    while cond633
+        _t1237 = parse_var(parser)
+        item634 = _t1237
+        push!(xs632, item634)
+        cond633 = match_lookahead_terminal(parser, "SYMBOL", 0)
     end
-    vars625 = xs622
+    vars635 = xs632
     consume_literal!(parser, ")")
-    return vars625
+    return vars635
 end
 
 function parse_data(parser::ParserState)::Proto.Data
     if match_lookahead_literal(parser, "(", 0)
-        if match_lookahead_literal(parser, "rel_edb", 1)
-            _t1219 = 0
+        if match_lookahead_literal(parser, "edb", 1)
+            _t1239 = 0
         else
             if match_lookahead_literal(parser, "csv_data", 1)
-                _t1220 = 2
+                _t1240 = 2
             else
                 if match_lookahead_literal(parser, "betree_relation", 1)
-                    _t1221 = 1
+                    _t1241 = 1
                 else
-                    _t1221 = -1
+                    _t1241 = -1
                 end
-                _t1220 = _t1221
+                _t1240 = _t1241
             end
-            _t1219 = _t1220
+            _t1239 = _t1240
         end
-        _t1218 = _t1219
+        _t1238 = _t1239
     else
-        _t1218 = -1
-    end
-    prediction626 = _t1218
-    if prediction626 == 2
-        _t1223 = parse_csv_data(parser)
-        csv_data629 = _t1223
-        _t1224 = Proto.Data(data_type=OneOf(:csv_data, csv_data629))
-        _t1222 = _t1224
+        _t1238 = -1
+    end
+    prediction636 = _t1238
+    if prediction636 == 2
+        _t1243 = parse_csv_data(parser)
+        csv_data639 = _t1243
+        _t1244 = Proto.Data(data_type=OneOf(:csv_data, csv_data639))
+        _t1242 = _t1244
     else
-        if prediction626 == 1
-            _t1226 = parse_betree_relation(parser)
-            betree_relation628 = _t1226
-            _t1227 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation628))
-            _t1225 = _t1227
+        if prediction636 == 1
+            _t1246 = parse_betree_relation(parser)
+            betree_relation638 = _t1246
+            _t1247 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation638))
+            _t1245 = _t1247
         else
-            if prediction626 == 0
-                _t1229 = parse_rel_edb(parser)
-                rel_edb627 = _t1229
-                _t1230 = Proto.Data(data_type=OneOf(:rel_edb, rel_edb627))
-                _t1228 = _t1230
+            if prediction636 == 0
+                _t1249 = parse_edb(parser)
+                edb637 = _t1249
+                _t1250 = Proto.Data(data_type=OneOf(:edb, edb637))
+                _t1248 = _t1250
             else
                 throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0))))
             end
-            _t1225 = _t1228
+            _t1245 = _t1248
         end
-        _t1222 = _t1225
+        _t1242 = _t1245
     end
-    return _t1222
+    return _t1242
 end
 
-function parse_rel_edb(parser::ParserState)::Proto.RelEDB
+function parse_edb(parser::ParserState)::Proto.EDB
     consume_literal!(parser, "(")
-    consume_literal!(parser, "rel_edb")
-    _t1231 = parse_relation_id(parser)
-    relation_id630 = _t1231
-    _t1232 = parse_rel_edb_path(parser)
-    rel_edb_path631 = _t1232
-    _t1233 = parse_rel_edb_types(parser)
-    rel_edb_types632 = _t1233
+    consume_literal!(parser, "edb")
+    _t1251 = parse_relation_id(parser)
+    relation_id640 = _t1251
+    _t1252 = parse_edb_path(parser)
+    edb_path641 = _t1252
+    _t1253 = parse_edb_types(parser)
+    edb_types642 = _t1253
     consume_literal!(parser, ")")
-    _t1234 = Proto.RelEDB(target_id=relation_id630, path=rel_edb_path631, types=rel_edb_types632)
-    return _t1234
+    _t1254 = Proto.EDB(target_id=relation_id640, path=edb_path641, types=edb_types642)
+    return _t1254
 end
 
-function parse_rel_edb_path(parser::ParserState)::Vector{String}
+function parse_edb_path(parser::ParserState)::Vector{String}
     consume_literal!(parser, "[")
-    xs633 = String[]
-    cond634 = match_lookahead_terminal(parser, "STRING", 0)
-    while cond634
-        item635 = consume_terminal!(parser, "STRING")
-        push!(xs633, item635)
-        cond634 = match_lookahead_terminal(parser, "STRING", 0)
-    end
-    strings636 = xs633
+    xs643 = String[]
+    cond644 = match_lookahead_terminal(parser, "STRING", 0)
+    while cond644
+        item645 = consume_terminal!(parser, "STRING")
+        push!(xs643, item645)
+        cond644 = match_lookahead_terminal(parser, "STRING", 0)
+    end
+    strings646 = xs643
     consume_literal!(parser, "]")
-    return strings636
+    return strings646
 end
 
-function parse_rel_edb_types(parser::ParserState)::Vector{Proto.var"#Type"}
+function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"}
     consume_literal!(parser, "[")
-    xs637 = Proto.var"#Type"[]
-    cond638 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    while cond638
-        _t1235 = parse_type(parser)
-        item639 = _t1235
-        push!(xs637, item639)
-        cond638 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    end
-    types640 = xs637
+    xs647 = Proto.var"#Type"[]
+    cond648 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    while cond648
+        _t1255 = parse_type(parser)
+        item649 = _t1255
+        push!(xs647, item649)
+        cond648 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    end
+    types650 = xs647
     consume_literal!(parser, "]")
-    return types640
+    return types650
 end
 
 function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation
     consume_literal!(parser, "(")
     consume_literal!(parser, "betree_relation")
-    _t1236 = parse_relation_id(parser)
-    relation_id641 = _t1236
-    _t1237 = parse_betree_info(parser)
-    betree_info642 = _t1237
+    _t1256 = parse_relation_id(parser)
+    relation_id651 = _t1256
+    _t1257 = parse_betree_info(parser)
+    betree_info652 = _t1257
     consume_literal!(parser, ")")
-    _t1238 = Proto.BeTreeRelation(name=relation_id641, relation_info=betree_info642)
-    return _t1238
+    _t1258 = Proto.BeTreeRelation(name=relation_id651, relation_info=betree_info652)
+    return _t1258
 end
 
 function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo
     consume_literal!(parser, "(")
     consume_literal!(parser, "betree_info")
-    _t1239 = parse_betree_info_key_types(parser)
-    betree_info_key_types643 = _t1239
-    _t1240 = parse_betree_info_value_types(parser)
-    betree_info_value_types644 = _t1240
-    _t1241 = parse_config_dict(parser)
-    config_dict645 = _t1241
-    consume_literal!(parser, ")")
-    _t1242 = construct_betree_info(parser, betree_info_key_types643, betree_info_value_types644, config_dict645)
-    return _t1242
+    _t1259 = parse_betree_info_key_types(parser)
+    betree_info_key_types653 = _t1259
+    _t1260 = parse_betree_info_value_types(parser)
+    betree_info_value_types654 = _t1260
+    _t1261 = parse_config_dict(parser)
+    config_dict655 = _t1261
+    consume_literal!(parser, ")")
+    _t1262 = construct_betree_info(parser, betree_info_key_types653, betree_info_value_types654, config_dict655)
+    return _t1262
 end
 
 function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"}
     consume_literal!(parser, "(")
     consume_literal!(parser, "key_types")
-    xs646 = Proto.var"#Type"[]
-    cond647 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    while cond647
-        _t1243 = parse_type(parser)
-        item648 = _t1243
-        push!(xs646, item648)
-        cond647 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    xs656 = Proto.var"#Type"[]
+    cond657 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    while cond657
+        _t1263 = parse_type(parser)
+        item658 = _t1263
+        push!(xs656, item658)
+        cond657 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
     end
-    types649 = xs646
+    types659 = xs656
     consume_literal!(parser, ")")
-    return types649
+    return types659
 end
 
 function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"}
     consume_literal!(parser, "(")
     consume_literal!(parser, "value_types")
-    xs650 = Proto.var"#Type"[]
-    cond651 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    while cond651
-        _t1244 = parse_type(parser)
-        item652 = _t1244
-        push!(xs650, item652)
-        cond651 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    xs660 = Proto.var"#Type"[]
+    cond661 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    while cond661
+        _t1264 = parse_type(parser)
+        item662 = _t1264
+        push!(xs660, item662)
+        cond661 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
     end
-    types653 = xs650
+    types663 = xs660
     consume_literal!(parser, ")")
-    return types653
+    return types663
 end
 
 function parse_csv_data(parser::ParserState)::Proto.CSVData
     consume_literal!(parser, "(")
     consume_literal!(parser, "csv_data")
-    _t1245 = parse_csvlocator(parser)
-    csvlocator654 = _t1245
-    _t1246 = parse_csv_config(parser)
-    csv_config655 = _t1246
-    _t1247 = parse_csv_columns(parser)
-    csv_columns656 = _t1247
-    _t1248 = parse_csv_asof(parser)
-    csv_asof657 = _t1248
+    _t1265 = parse_csvlocator(parser)
+    csvlocator664 = _t1265
+    _t1266 = parse_csv_config(parser)
+    csv_config665 = _t1266
+    _t1267 = parse_gnf_columns(parser)
+    gnf_columns666 = _t1267
+    _t1268 = parse_csv_asof(parser)
+    csv_asof667 = _t1268
     consume_literal!(parser, ")")
-    _t1249 = Proto.CSVData(locator=csvlocator654, config=csv_config655, columns=csv_columns656, asof=csv_asof657)
-    return _t1249
+    _t1269 = Proto.CSVData(locator=csvlocator664, config=csv_config665, columns=gnf_columns666, asof=csv_asof667)
+    return _t1269
 end
 
 function parse_csvlocator(parser::ParserState)::Proto.CSVLocator
     consume_literal!(parser, "(")
     consume_literal!(parser, "csv_locator")
     if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1))
-        _t1251 = parse_csv_locator_paths(parser)
-        _t1250 = _t1251
+        _t1271 = parse_csv_locator_paths(parser)
+        _t1270 = _t1271
     else
-        _t1250 = nothing
+        _t1270 = nothing
     end
-    csv_locator_paths658 = _t1250
+    csv_locator_paths668 = _t1270
     if match_lookahead_literal(parser, "(", 0)
-        _t1253 = parse_csv_locator_inline_data(parser)
-        _t1252 = _t1253
+        _t1273 = parse_csv_locator_inline_data(parser)
+        _t1272 = _t1273
     else
-        _t1252 = nothing
+        _t1272 = nothing
     end
-    csv_locator_inline_data659 = _t1252
+    csv_locator_inline_data669 = _t1272
     consume_literal!(parser, ")")
-    _t1254 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths658) ? csv_locator_paths658 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data659) ? csv_locator_inline_data659 : "")))
-    return _t1254
+    _t1274 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths668) ? csv_locator_paths668 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data669) ? csv_locator_inline_data669 : "")))
+    return _t1274
 end
 
 function parse_csv_locator_paths(parser::ParserState)::Vector{String}
     consume_literal!(parser, "(")
     consume_literal!(parser, "paths")
-    xs660 = String[]
-    cond661 = match_lookahead_terminal(parser, "STRING", 0)
-    while cond661
-        item662 = consume_terminal!(parser, "STRING")
-        push!(xs660, item662)
-        cond661 = match_lookahead_terminal(parser, "STRING", 0)
+    xs670 = String[]
+    cond671 = match_lookahead_terminal(parser, "STRING", 0)
+    while cond671
+        item672 = consume_terminal!(parser, "STRING")
+        push!(xs670, item672)
+        cond671 = match_lookahead_terminal(parser, "STRING", 0)
     end
-    strings663 = xs660
+    strings673 = xs670
     consume_literal!(parser, ")")
-    return strings663
+    return strings673
 end
 
 function parse_csv_locator_inline_data(parser::ParserState)::String
     consume_literal!(parser, "(")
     consume_literal!(parser, "inline_data")
-    string664 = consume_terminal!(parser, "STRING")
+    string674 = consume_terminal!(parser, "STRING")
     consume_literal!(parser, ")")
-    return string664
+    return string674
 end
 
 function parse_csv_config(parser::ParserState)::Proto.CSVConfig
     consume_literal!(parser, "(")
     consume_literal!(parser, "csv_config")
-    _t1255 = parse_config_dict(parser)
-    config_dict665 = _t1255
+    _t1275 = parse_config_dict(parser)
+    config_dict675 = _t1275
     consume_literal!(parser, ")")
-    _t1256 = construct_csv_config(parser, config_dict665)
-    return _t1256
+    _t1276 = construct_csv_config(parser, config_dict675)
+    return _t1276
 end
 
-function parse_csv_columns(parser::ParserState)::Vector{Proto.CSVColumn}
+function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn}
     consume_literal!(parser, "(")
     consume_literal!(parser, "columns")
-    xs666 = Proto.CSVColumn[]
-    cond667 = match_lookahead_literal(parser, "(", 0)
-    while cond667
-        _t1257 = parse_csv_column(parser)
-        item668 = _t1257
-        push!(xs666, item668)
-        cond667 = match_lookahead_literal(parser, "(", 0)
+    xs676 = Proto.GNFColumn[]
+    cond677 = match_lookahead_literal(parser, "(", 0)
+    while cond677
+        _t1277 = parse_gnf_column(parser)
+        item678 = _t1277
+        push!(xs676, item678)
+        cond677 = match_lookahead_literal(parser, "(", 0)
     end
-    csv_columns669 = xs666
+    gnf_columns679 = xs676
     consume_literal!(parser, ")")
-    return csv_columns669
+    return gnf_columns679
 end
 
-function parse_csv_column(parser::ParserState)::Proto.CSVColumn
+function parse_gnf_column(parser::ParserState)::Proto.GNFColumn
     consume_literal!(parser, "(")
     consume_literal!(parser, "column")
-    string670 = consume_terminal!(parser, "STRING")
-    _t1258 = parse_relation_id(parser)
-    relation_id671 = _t1258
+    _t1278 = parse_gnf_column_path(parser)
+    gnf_column_path680 = _t1278
+    if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
+        _t1280 = parse_relation_id(parser)
+        _t1279 = _t1280
+    else
+        _t1279 = nothing
+    end
+    relation_id681 = _t1279
     consume_literal!(parser, "[")
-    xs672 = Proto.var"#Type"[]
-    cond673 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    while cond673
-        _t1259 = parse_type(parser)
-        item674 = _t1259
-        push!(xs672, item674)
-        cond673 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
-    end
-    types675 = xs672
+    xs682 = Proto.var"#Type"[]
+    cond683 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    while cond683
+        _t1281 = parse_type(parser)
+        item684 = _t1281
+        push!(xs682, item684)
+        cond683 = ((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0))
+    end
+    types685 = xs682
     consume_literal!(parser, "]")
     consume_literal!(parser, ")")
-    _t1260 = Proto.CSVColumn(column_name=string670, target_id=relation_id671, types=types675)
-    return _t1260
+    _t1282 = Proto.GNFColumn(column_path=gnf_column_path680, target_id=relation_id681, types=types685)
+    return _t1282
+end
+
+function parse_gnf_column_path(parser::ParserState)::Vector{String}
+    if match_lookahead_literal(parser, "[", 0)
+        _t1283 = 1
+    else
+        if match_lookahead_terminal(parser, "STRING", 0)
+            _t1284 = 0
+        else
+            _t1284 = -1
+        end
+        _t1283 = _t1284
+    end
+    prediction686 = _t1283
+    if prediction686 == 1
+        consume_literal!(parser, "[")
+        xs688 = String[]
+        cond689 = match_lookahead_terminal(parser, "STRING", 0)
+        while cond689
+            item690 = consume_terminal!(parser, "STRING")
+            push!(xs688, item690)
+            cond689 = match_lookahead_terminal(parser, "STRING", 0)
+        end
+        strings691 = xs688
+        consume_literal!(parser, "]")
+        _t1285 = strings691
+    else
+        if prediction686 == 0
+            string687 = consume_terminal!(parser, "STRING")
+            _t1286 = String[string687]
+        else
+            throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0))))
+        end
+        _t1285 = _t1286
+    end
+    return _t1285
 end
 
 function parse_csv_asof(parser::ParserState)::String
     consume_literal!(parser, "(")
     consume_literal!(parser, "asof")
-    string676 = consume_terminal!(parser, "STRING")
+    string692 = consume_terminal!(parser, "STRING")
     consume_literal!(parser, ")")
-    return string676
+    return string692
 end
 
 function parse_undefine(parser::ParserState)::Proto.Undefine
     consume_literal!(parser, "(")
     consume_literal!(parser, "undefine")
-    _t1261 = parse_fragment_id(parser)
-    fragment_id677 = _t1261
+    _t1287 = parse_fragment_id(parser)
+    fragment_id693 = _t1287
     consume_literal!(parser, ")")
-    _t1262 = Proto.Undefine(fragment_id=fragment_id677)
-    return _t1262
+    _t1288 = Proto.Undefine(fragment_id=fragment_id693)
+    return _t1288
 end
 
 function parse_context(parser::ParserState)::Proto.Context
     consume_literal!(parser, "(")
     consume_literal!(parser, "context")
-    xs678 = Proto.RelationId[]
-    cond679 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
-    while cond679
-        _t1263 = parse_relation_id(parser)
-        item680 = _t1263
-        push!(xs678, item680)
-        cond679 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
+    xs694 = Proto.RelationId[]
+    cond695 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
+    while cond695
+        _t1289 = parse_relation_id(parser)
+        item696 = _t1289
+        push!(xs694, item696)
+        cond695 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0))
     end
-    relation_ids681 = xs678
+    relation_ids697 = xs694
     consume_literal!(parser, ")")
-    _t1264 = Proto.Context(relations=relation_ids681)
-    return _t1264
+    _t1290 = Proto.Context(relations=relation_ids697)
+    return _t1290
 end
 
 function parse_snapshot(parser::ParserState)::Proto.Snapshot
     consume_literal!(parser, "(")
     consume_literal!(parser, "snapshot")
-    _t1265 = parse_rel_edb_path(parser)
-    rel_edb_path682 = _t1265
-    _t1266 = parse_relation_id(parser)
-    relation_id683 = _t1266
+    xs698 = Proto.SnapshotMapping[]
+    cond699 = match_lookahead_literal(parser, "[", 0)
+    while cond699
+        _t1291 = parse_snapshot_mapping(parser)
+        item700 = _t1291
+        push!(xs698, item700)
+        cond699 = match_lookahead_literal(parser, "[", 0)
+    end
+    snapshot_mappings701 = xs698
     consume_literal!(parser, ")")
-    _t1267 = Proto.Snapshot(destination_path=rel_edb_path682, source_relation=relation_id683)
-    return _t1267
+    _t1292 = Proto.Snapshot(mappings=snapshot_mappings701)
+    return _t1292
+end
+
+function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping
+    _t1293 = parse_edb_path(parser)
+    edb_path702 = _t1293
+    _t1294 = parse_relation_id(parser)
+    relation_id703 = _t1294
+    _t1295 = Proto.SnapshotMapping(destination_path=edb_path702, source_relation=relation_id703)
+    return _t1295
 end
 
 function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read}
     consume_literal!(parser, "(")
     consume_literal!(parser, "reads")
-    xs684 = Proto.Read[]
-    cond685 = match_lookahead_literal(parser, "(", 0)
-    while cond685
-        _t1268 = parse_read(parser)
-        item686 = _t1268
-        push!(xs684, item686)
-        cond685 = match_lookahead_literal(parser, "(", 0)
+    xs704 = Proto.Read[]
+    cond705 = match_lookahead_literal(parser, "(", 0)
+    while cond705
+        _t1296 = parse_read(parser)
+        item706 = _t1296
+        push!(xs704, item706)
+        cond705 = match_lookahead_literal(parser, "(", 0)
     end
-    reads687 = xs684
+    reads707 = xs704
     consume_literal!(parser, ")")
-    return reads687
+    return reads707
 end
 
 function parse_read(parser::ParserState)::Proto.Read
     if match_lookahead_literal(parser, "(", 0)
         if match_lookahead_literal(parser, "what_if", 1)
-            _t1270 = 2
+            _t1298 = 2
         else
             if match_lookahead_literal(parser, "output", 1)
-                _t1271 = 1
+                _t1299 = 1
             else
                 if match_lookahead_literal(parser, "export", 1)
-                    _t1272 = 4
+                    _t1300 = 4
                 else
                     if match_lookahead_literal(parser, "demand", 1)
-                        _t1273 = 0
+                        _t1301 = 0
                     else
                         if match_lookahead_literal(parser, "abort", 1)
-                            _t1274 = 3
+                            _t1302 = 3
                         else
-                            _t1274 = -1
+                            _t1302 = -1
                         end
-                        _t1273 = _t1274
+                        _t1301 = _t1302
                     end
-                    _t1272 = _t1273
+                    _t1300 = _t1301
                 end
-                _t1271 = _t1272
+                _t1299 = _t1300
             end
-            _t1270 = _t1271
+            _t1298 = _t1299
         end
-        _t1269 = _t1270
+        _t1297 = _t1298
     else
-        _t1269 = -1
-    end
-    prediction688 = _t1269
-    if prediction688 == 4
-        _t1276 = parse_export(parser)
-        export693 = _t1276
-        _t1277 = Proto.Read(read_type=OneOf(:var"#export", export693))
-        _t1275 = _t1277
+        _t1297 = -1
+    end
+    prediction708 = _t1297
+    if prediction708 == 4
+        _t1304 = parse_export(parser)
+        export713 = _t1304
+        _t1305 = Proto.Read(read_type=OneOf(:var"#export", export713))
+        _t1303 = _t1305
     else
-        if prediction688 == 3
-            _t1279 = parse_abort(parser)
-            abort692 = _t1279
-            _t1280 = Proto.Read(read_type=OneOf(:abort, abort692))
-            _t1278 = _t1280
+        if prediction708 == 3
+            _t1307 = parse_abort(parser)
+            abort712 = _t1307
+            _t1308 = Proto.Read(read_type=OneOf(:abort, abort712))
+            _t1306 = _t1308
         else
-            if prediction688 == 2
-                _t1282 = parse_what_if(parser)
-                what_if691 = _t1282
-                _t1283 = Proto.Read(read_type=OneOf(:what_if, what_if691))
-                _t1281 = _t1283
+            if prediction708 == 2
+                _t1310 = parse_what_if(parser)
+                what_if711 = _t1310
+                _t1311 = Proto.Read(read_type=OneOf(:what_if, what_if711))
+                _t1309 = _t1311
             else
-                if prediction688 == 1
-                    _t1285 = parse_output(parser)
-                    output690 = _t1285
-                    _t1286 = Proto.Read(read_type=OneOf(:output, output690))
-                    _t1284 = _t1286
+                if prediction708 == 1
+                    _t1313 = parse_output(parser)
+                    output710 = _t1313
+                    _t1314 = Proto.Read(read_type=OneOf(:output, output710))
+                    _t1312 = _t1314
                 else
-                    if prediction688 == 0
-                        _t1288 = parse_demand(parser)
-                        demand689 = _t1288
-                        _t1289 = Proto.Read(read_type=OneOf(:demand, demand689))
-                        _t1287 = _t1289
+                    if prediction708 == 0
+                        _t1316 = parse_demand(parser)
+                        demand709 = _t1316
+                        _t1317 = Proto.Read(read_type=OneOf(:demand, demand709))
+                        _t1315 = _t1317
                     else
                         throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0))))
                     end
-                    _t1284 = _t1287
+                    _t1312 = _t1315
                 end
-                _t1281 = _t1284
+                _t1309 = _t1312
             end
-            _t1278 = _t1281
+            _t1306 = _t1309
         end
-        _t1275 = _t1278
+        _t1303 = _t1306
     end
-    return _t1275
+    return _t1303
 end
 
 function parse_demand(parser::ParserState)::Proto.Demand
     consume_literal!(parser, "(")
     consume_literal!(parser, "demand")
-    _t1290 = parse_relation_id(parser)
-    relation_id694 = _t1290
+    _t1318 = parse_relation_id(parser)
+    relation_id714 = _t1318
     consume_literal!(parser, ")")
-    _t1291 = Proto.Demand(relation_id=relation_id694)
-    return _t1291
+    _t1319 = Proto.Demand(relation_id=relation_id714)
+    return _t1319
 end
 
 function parse_output(parser::ParserState)::Proto.Output
     consume_literal!(parser, "(")
     consume_literal!(parser, "output")
-    _t1292 = parse_name(parser)
-    name695 = _t1292
-    _t1293 = parse_relation_id(parser)
-    relation_id696 = _t1293
+    _t1320 = parse_name(parser)
+    name715 = _t1320
+    _t1321 = parse_relation_id(parser)
+    relation_id716 = _t1321
     consume_literal!(parser, ")")
-    _t1294 = Proto.Output(name=name695, relation_id=relation_id696)
-    return _t1294
+    _t1322 = Proto.Output(name=name715, relation_id=relation_id716)
+    return _t1322
 end
 
 function parse_what_if(parser::ParserState)::Proto.WhatIf
     consume_literal!(parser, "(")
     consume_literal!(parser, "what_if")
-    _t1295 = parse_name(parser)
-    name697 = _t1295
-    _t1296 = parse_epoch(parser)
-    epoch698 = _t1296
+    _t1323 = parse_name(parser)
+    name717 = _t1323
+    _t1324 = parse_epoch(parser)
+    epoch718 = _t1324
     consume_literal!(parser, ")")
-    _t1297 = Proto.WhatIf(branch=name697, epoch=epoch698)
-    return _t1297
+    _t1325 = Proto.WhatIf(branch=name717, epoch=epoch718)
+    return _t1325
 end
 
 function parse_abort(parser::ParserState)::Proto.Abort
     consume_literal!(parser, "(")
     consume_literal!(parser, "abort")
     if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1))
-        _t1299 = parse_name(parser)
-        _t1298 = _t1299
+        _t1327 = parse_name(parser)
+        _t1326 = _t1327
     else
-        _t1298 = nothing
+        _t1326 = nothing
     end
-    name699 = _t1298
-    _t1300 = parse_relation_id(parser)
-    relation_id700 = _t1300
+    name719 = _t1326
+    _t1328 = parse_relation_id(parser)
+    relation_id720 = _t1328
     consume_literal!(parser, ")")
-    _t1301 = Proto.Abort(name=(!isnothing(name699) ? name699 : "abort"), relation_id=relation_id700)
-    return _t1301
+    _t1329 = Proto.Abort(name=(!isnothing(name719) ? name719 : "abort"), relation_id=relation_id720)
+    return _t1329
 end
 
 function parse_export(parser::ParserState)::Proto.Export
     consume_literal!(parser, "(")
     consume_literal!(parser, "export")
-    _t1302 = parse_export_csv_config(parser)
-    export_csv_config701 = _t1302
+    _t1330 = parse_export_csv_config(parser)
+    export_csv_config721 = _t1330
     consume_literal!(parser, ")")
-    _t1303 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config701))
-    return _t1303
+    _t1331 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config721))
+    return _t1331
 end
 
 function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig
     consume_literal!(parser, "(")
     consume_literal!(parser, "export_csv_config")
-    _t1304 = parse_export_csv_path(parser)
-    export_csv_path702 = _t1304
-    _t1305 = parse_export_csv_columns(parser)
-    export_csv_columns703 = _t1305
-    _t1306 = parse_config_dict(parser)
-    config_dict704 = _t1306
+    _t1332 = parse_export_csv_path(parser)
+    export_csv_path722 = _t1332
+    _t1333 = parse_export_csv_columns(parser)
+    export_csv_columns723 = _t1333
+    _t1334 = parse_config_dict(parser)
+    config_dict724 = _t1334
     consume_literal!(parser, ")")
-    _t1307 = export_csv_config(parser, export_csv_path702, export_csv_columns703, config_dict704)
-    return _t1307
+    _t1335 = export_csv_config(parser, export_csv_path722, export_csv_columns723, config_dict724)
+    return _t1335
 end
 
 function parse_export_csv_path(parser::ParserState)::String
     consume_literal!(parser, "(")
     consume_literal!(parser, "path")
-    string705 = consume_terminal!(parser, "STRING")
+    string725 = consume_terminal!(parser, "STRING")
     consume_literal!(parser, ")")
-    return string705
+    return string725
 end
 
 function parse_export_csv_columns(parser::ParserState)::Vector{Proto.ExportCSVColumn}
     consume_literal!(parser, "(")
     consume_literal!(parser, "columns")
-    xs706 = Proto.ExportCSVColumn[]
-    cond707 = match_lookahead_literal(parser, "(", 0)
-    while cond707
-        _t1308 = parse_export_csv_column(parser)
-        item708 = _t1308
-        push!(xs706, item708)
-        cond707 = match_lookahead_literal(parser, "(", 0)
+    xs726 = Proto.ExportCSVColumn[]
+    cond727 = match_lookahead_literal(parser, "(", 0)
+    while cond727
+        _t1336 = parse_export_csv_column(parser)
+        item728 = _t1336
+        push!(xs726, item728)
+        cond727 = match_lookahead_literal(parser, "(", 0)
     end
-    export_csv_columns709 = xs706
+    export_csv_columns729 = xs726
     consume_literal!(parser, ")")
-    return export_csv_columns709
+    return export_csv_columns729
 end
 
 function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn
     consume_literal!(parser, "(")
     consume_literal!(parser, "column")
-    string710 = consume_terminal!(parser, "STRING")
-    _t1309 = parse_relation_id(parser)
-    relation_id711 = _t1309
+    string730 = consume_terminal!(parser, "STRING")
+    _t1337 = parse_relation_id(parser)
+    relation_id731 = _t1337
     consume_literal!(parser, ")")
-    _t1310 = Proto.ExportCSVColumn(column_name=string710, column_data=relation_id711)
-    return _t1310
+    _t1338 = Proto.ExportCSVColumn(column_name=string730, column_data=relation_id731)
+    return _t1338
 end
 
 
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl
index f250c655..a2a2a36e 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl
@@ -338,147 +338,147 @@ end
 # --- Helper functions ---
 
 function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value
-    _t1398 = Proto.Value(value=OneOf(:int_value, Int64(v)))
-    return _t1398
+    _t1429 = Proto.Value(value=OneOf(:int_value, Int64(v)))
+    return _t1429
 end
 
 function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value
-    _t1399 = Proto.Value(value=OneOf(:int_value, v))
-    return _t1399
+    _t1430 = Proto.Value(value=OneOf(:int_value, v))
+    return _t1430
 end
 
 function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value
-    _t1400 = Proto.Value(value=OneOf(:float_value, v))
-    return _t1400
+    _t1431 = Proto.Value(value=OneOf(:float_value, v))
+    return _t1431
 end
 
 function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value
-    _t1401 = Proto.Value(value=OneOf(:string_value, v))
-    return _t1401
+    _t1432 = Proto.Value(value=OneOf(:string_value, v))
+    return _t1432
 end
 
 function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value
-    _t1402 = Proto.Value(value=OneOf(:boolean_value, v))
-    return _t1402
+    _t1433 = Proto.Value(value=OneOf(:boolean_value, v))
+    return _t1433
 end
 
 function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value
-    _t1403 = Proto.Value(value=OneOf(:uint128_value, v))
-    return _t1403
+    _t1434 = Proto.Value(value=OneOf(:uint128_value, v))
+    return _t1434
 end
 
 function deconstruct_configure(pp::PrettyPrinter, msg::Proto.Configure)::Vector{Tuple{String, Proto.Value}}
     result = Tuple{String, Proto.Value}[]
     if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO
-        _t1404 = _make_value_string(pp, "auto")
-        push!(result, ("ivm.maintenance_level", _t1404,))
+        _t1435 = _make_value_string(pp, "auto")
+        push!(result, ("ivm.maintenance_level", _t1435,))
     else
         if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL
-            _t1405 = _make_value_string(pp, "all")
-            push!(result, ("ivm.maintenance_level", _t1405,))
+            _t1436 = _make_value_string(pp, "all")
+            push!(result, ("ivm.maintenance_level", _t1436,))
         else
             if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF
-                _t1406 = _make_value_string(pp, "off")
-                push!(result, ("ivm.maintenance_level", _t1406,))
+                _t1437 = _make_value_string(pp, "off")
+                push!(result, ("ivm.maintenance_level", _t1437,))
             end
         end
     end
-    _t1407 = _make_value_int64(pp, msg.semantics_version)
-    push!(result, ("semantics_version", _t1407,))
+    _t1438 = _make_value_int64(pp, msg.semantics_version)
+    push!(result, ("semantics_version", _t1438,))
     return sort(result)
 end
 
 function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}}
     result = Tuple{String, Proto.Value}[]
-    _t1408 = _make_value_int32(pp, msg.header_row)
-    push!(result, ("csv_header_row", _t1408,))
-    _t1409 = _make_value_int64(pp, msg.skip)
-    push!(result, ("csv_skip", _t1409,))
+    _t1439 = _make_value_int32(pp, msg.header_row)
+    push!(result, ("csv_header_row", _t1439,))
+    _t1440 = _make_value_int64(pp, msg.skip)
+    push!(result, ("csv_skip", _t1440,))
     if msg.new_line != ""
-        _t1410 = _make_value_string(pp, msg.new_line)
-        push!(result, ("csv_new_line", _t1410,))
-    end
-    _t1411 = _make_value_string(pp, msg.delimiter)
-    push!(result, ("csv_delimiter", _t1411,))
-    _t1412 = _make_value_string(pp, msg.quotechar)
-    push!(result, ("csv_quotechar", _t1412,))
-    _t1413 = _make_value_string(pp, msg.escapechar)
-    push!(result, ("csv_escapechar", _t1413,))
+        _t1441 = _make_value_string(pp, msg.new_line)
+        push!(result, ("csv_new_line", _t1441,))
+    end
+    _t1442 = _make_value_string(pp, msg.delimiter)
+    push!(result, ("csv_delimiter", _t1442,))
+    _t1443 = _make_value_string(pp, msg.quotechar)
+    push!(result, ("csv_quotechar", _t1443,))
+    _t1444 = _make_value_string(pp, msg.escapechar)
+    push!(result, ("csv_escapechar", _t1444,))
     if msg.comment != ""
-        _t1414 = _make_value_string(pp, msg.comment)
-        push!(result, ("csv_comment", _t1414,))
+        _t1445 = _make_value_string(pp, msg.comment)
+        push!(result, ("csv_comment", _t1445,))
     end
     for missing_string in msg.missing_strings
-        _t1415 = _make_value_string(pp, missing_string)
-        push!(result, ("csv_missing_strings", _t1415,))
-    end
-    _t1416 = _make_value_string(pp, msg.decimal_separator)
-    push!(result, ("csv_decimal_separator", _t1416,))
-    _t1417 = _make_value_string(pp, msg.encoding)
-    push!(result, ("csv_encoding", _t1417,))
-    _t1418 = _make_value_string(pp, msg.compression)
-    push!(result, ("csv_compression", _t1418,))
+        _t1446 = _make_value_string(pp, missing_string)
+        push!(result, ("csv_missing_strings", _t1446,))
+    end
+    _t1447 = _make_value_string(pp, msg.decimal_separator)
+    push!(result, ("csv_decimal_separator", _t1447,))
+    _t1448 = _make_value_string(pp, msg.encoding)
+    push!(result, ("csv_encoding", _t1448,))
+    _t1449 = _make_value_string(pp, msg.compression)
+    push!(result, ("csv_compression", _t1449,))
     return sort(result)
 end
 
 function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}}
     result = Tuple{String, Proto.Value}[]
-    _t1419 = _make_value_float64(pp, msg.storage_config.epsilon)
-    push!(result, ("betree_config_epsilon", _t1419,))
-    _t1420 = _make_value_int64(pp, msg.storage_config.max_pivots)
-    push!(result, ("betree_config_max_pivots", _t1420,))
-    _t1421 = _make_value_int64(pp, msg.storage_config.max_deltas)
-    push!(result, ("betree_config_max_deltas", _t1421,))
-    _t1422 = _make_value_int64(pp, msg.storage_config.max_leaf)
-    push!(result, ("betree_config_max_leaf", _t1422,))
+    _t1450 = _make_value_float64(pp, msg.storage_config.epsilon)
+    push!(result, ("betree_config_epsilon", _t1450,))
+    _t1451 = _make_value_int64(pp, msg.storage_config.max_pivots)
+    push!(result, ("betree_config_max_pivots", _t1451,))
+    _t1452 = _make_value_int64(pp, msg.storage_config.max_deltas)
+    push!(result, ("betree_config_max_deltas", _t1452,))
+    _t1453 = _make_value_int64(pp, msg.storage_config.max_leaf)
+    push!(result, ("betree_config_max_leaf", _t1453,))
     if _has_proto_field(msg.relation_locator, Symbol("root_pageid"))
         if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid))
-            _t1423 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid))
-            push!(result, ("betree_locator_root_pageid", _t1423,))
+            _t1454 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid))
+            push!(result, ("betree_locator_root_pageid", _t1454,))
         end
     end
     if _has_proto_field(msg.relation_locator, Symbol("inline_data"))
         if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data))
-            _t1424 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data))))
-            push!(result, ("betree_locator_inline_data", _t1424,))
+            _t1455 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data))))
+            push!(result, ("betree_locator_inline_data", _t1455,))
         end
     end
-    _t1425 = _make_value_int64(pp, msg.relation_locator.element_count)
-    push!(result, ("betree_locator_element_count", _t1425,))
-    _t1426 = _make_value_int64(pp, msg.relation_locator.tree_height)
-    push!(result, ("betree_locator_tree_height", _t1426,))
+    _t1456 = _make_value_int64(pp, msg.relation_locator.element_count)
+    push!(result, ("betree_locator_element_count", _t1456,))
+    _t1457 = _make_value_int64(pp, msg.relation_locator.tree_height)
+    push!(result, ("betree_locator_tree_height", _t1457,))
     return sort(result)
 end
 
 function deconstruct_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)::Vector{Tuple{String, Proto.Value}}
     result = Tuple{String, Proto.Value}[]
     if !isnothing(msg.partition_size)
-        _t1427 = _make_value_int64(pp, msg.partition_size)
-        push!(result, ("partition_size", _t1427,))
+        _t1458 = _make_value_int64(pp, msg.partition_size)
+        push!(result, ("partition_size", _t1458,))
     end
     if !isnothing(msg.compression)
-        _t1428 = _make_value_string(pp, msg.compression)
-        push!(result, ("compression", _t1428,))
+        _t1459 = _make_value_string(pp, msg.compression)
+        push!(result, ("compression", _t1459,))
     end
     if !isnothing(msg.syntax_header_row)
-        _t1429 = _make_value_boolean(pp, msg.syntax_header_row)
-        push!(result, ("syntax_header_row", _t1429,))
+        _t1460 = _make_value_boolean(pp, msg.syntax_header_row)
+        push!(result, ("syntax_header_row", _t1460,))
     end
     if !isnothing(msg.syntax_missing_string)
-        _t1430 = _make_value_string(pp, msg.syntax_missing_string)
-        push!(result, ("syntax_missing_string", _t1430,))
+        _t1461 = _make_value_string(pp, msg.syntax_missing_string)
+        push!(result, ("syntax_missing_string", _t1461,))
     end
     if !isnothing(msg.syntax_delim)
-        _t1431 = _make_value_string(pp, msg.syntax_delim)
-        push!(result, ("syntax_delim", _t1431,))
+        _t1462 = _make_value_string(pp, msg.syntax_delim)
+        push!(result, ("syntax_delim", _t1462,))
     end
     if !isnothing(msg.syntax_quotechar)
-        _t1432 = _make_value_string(pp, msg.syntax_quotechar)
-        push!(result, ("syntax_quotechar", _t1432,))
+        _t1463 = _make_value_string(pp, msg.syntax_quotechar)
+        push!(result, ("syntax_quotechar", _t1463,))
     end
     if !isnothing(msg.syntax_escapechar)
-        _t1433 = _make_value_string(pp, msg.syntax_escapechar)
-        push!(result, ("syntax_escapechar", _t1433,))
+        _t1464 = _make_value_string(pp, msg.syntax_escapechar)
+        push!(result, ("syntax_escapechar", _t1464,))
     end
     return sort(result)
 end
@@ -493,7 +493,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI
     if isnothing(name)
         return relation_id_to_uint128(pp, msg)
     else
-        _t1434 = nothing
+        _t1465 = nothing
     end
     return nothing
 end
@@ -512,47 +512,47 @@ end
 # --- Pretty-print functions ---
 
 function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction)
-    flat638 = try_flat(pp, msg, pretty_transaction)
-    if !isnothing(flat638)
-        write(pp, flat638)
+    flat651 = try_flat(pp, msg, pretty_transaction)
+    if !isnothing(flat651)
+        write(pp, flat651)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("configure"))
-            _t1258 = _dollar_dollar.configure
+            _t1284 = _dollar_dollar.configure
         else
-            _t1258 = nothing
+            _t1284 = nothing
         end
         if _has_proto_field(_dollar_dollar, Symbol("sync"))
-            _t1259 = _dollar_dollar.sync
+            _t1285 = _dollar_dollar.sync
         else
-            _t1259 = nothing
+            _t1285 = nothing
         end
-        fields629 = (_t1258, _t1259, _dollar_dollar.epochs,)
-        unwrapped_fields630 = fields629
+        fields642 = (_t1284, _t1285, _dollar_dollar.epochs,)
+        unwrapped_fields643 = fields642
         write(pp, "(transaction")
         indent_sexp!(pp)
-        field631 = unwrapped_fields630[1]
-        if !isnothing(field631)
+        field644 = unwrapped_fields643[1]
+        if !isnothing(field644)
             newline(pp)
-            opt_val632 = field631
-            pretty_configure(pp, opt_val632)
+            opt_val645 = field644
+            pretty_configure(pp, opt_val645)
         end
-        field633 = unwrapped_fields630[2]
-        if !isnothing(field633)
+        field646 = unwrapped_fields643[2]
+        if !isnothing(field646)
             newline(pp)
-            opt_val634 = field633
-            pretty_sync(pp, opt_val634)
+            opt_val647 = field646
+            pretty_sync(pp, opt_val647)
         end
-        field635 = unwrapped_fields630[3]
-        if !isempty(field635)
+        field648 = unwrapped_fields643[3]
+        if !isempty(field648)
             newline(pp)
-            for (i1260, elem636) in enumerate(field635)
-                i637 = i1260 - 1
-                if (i637 > 0)
+            for (i1286, elem649) in enumerate(field648)
+                i650 = i1286 - 1
+                if (i650 > 0)
                     newline(pp)
                 end
-                pretty_epoch(pp, elem636)
+                pretty_epoch(pp, elem649)
             end
         end
         dedent!(pp)
@@ -562,19 +562,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction)
 end
 
 function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure)
-    flat641 = try_flat(pp, msg, pretty_configure)
-    if !isnothing(flat641)
-        write(pp, flat641)
+    flat654 = try_flat(pp, msg, pretty_configure)
+    if !isnothing(flat654)
+        write(pp, flat654)
         return nothing
     else
         _dollar_dollar = msg
-        _t1261 = deconstruct_configure(pp, _dollar_dollar)
-        fields639 = _t1261
-        unwrapped_fields640 = fields639
+        _t1287 = deconstruct_configure(pp, _dollar_dollar)
+        fields652 = _t1287
+        unwrapped_fields653 = fields652
         write(pp, "(configure")
         indent_sexp!(pp)
         newline(pp)
-        pretty_config_dict(pp, unwrapped_fields640)
+        pretty_config_dict(pp, unwrapped_fields653)
         dedent!(pp)
         write(pp, ")")
     end
@@ -582,22 +582,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure)
 end
 
 function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}})
-    flat645 = try_flat(pp, msg, pretty_config_dict)
-    if !isnothing(flat645)
-        write(pp, flat645)
+    flat658 = try_flat(pp, msg, pretty_config_dict)
+    if !isnothing(flat658)
+        write(pp, flat658)
         return nothing
     else
-        fields642 = msg
+        fields655 = msg
         write(pp, "{")
         indent!(pp)
-        if !isempty(fields642)
+        if !isempty(fields655)
             newline(pp)
-            for (i1262, elem643) in enumerate(fields642)
-                i644 = i1262 - 1
-                if (i644 > 0)
+            for (i1288, elem656) in enumerate(fields655)
+                i657 = i1288 - 1
+                if (i657 > 0)
                     newline(pp)
                 end
-                pretty_config_key_value(pp, elem643)
+                pretty_config_key_value(pp, elem656)
             end
         end
         dedent!(pp)
@@ -607,130 +607,130 @@ function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.V
 end
 
 function pretty_config_key_value(pp::PrettyPrinter, msg::Tuple{String, Proto.Value})
-    flat650 = try_flat(pp, msg, pretty_config_key_value)
-    if !isnothing(flat650)
-        write(pp, flat650)
+    flat663 = try_flat(pp, msg, pretty_config_key_value)
+    if !isnothing(flat663)
+        write(pp, flat663)
         return nothing
     else
         _dollar_dollar = msg
-        fields646 = (_dollar_dollar[1], _dollar_dollar[2],)
-        unwrapped_fields647 = fields646
+        fields659 = (_dollar_dollar[1], _dollar_dollar[2],)
+        unwrapped_fields660 = fields659
         write(pp, ":")
-        field648 = unwrapped_fields647[1]
-        write(pp, field648)
+        field661 = unwrapped_fields660[1]
+        write(pp, field661)
         write(pp, " ")
-        field649 = unwrapped_fields647[2]
-        pretty_value(pp, field649)
+        field662 = unwrapped_fields660[2]
+        pretty_value(pp, field662)
     end
     return nothing
 end
 
 function pretty_value(pp::PrettyPrinter, msg::Proto.Value)
-    flat670 = try_flat(pp, msg, pretty_value)
-    if !isnothing(flat670)
-        write(pp, flat670)
+    flat683 = try_flat(pp, msg, pretty_value)
+    if !isnothing(flat683)
+        write(pp, flat683)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("date_value"))
-            _t1263 = _get_oneof_field(_dollar_dollar, :date_value)
+            _t1289 = _get_oneof_field(_dollar_dollar, :date_value)
         else
-            _t1263 = nothing
+            _t1289 = nothing
         end
-        deconstruct_result668 = _t1263
-        if !isnothing(deconstruct_result668)
-            unwrapped669 = deconstruct_result668
-            pretty_date(pp, unwrapped669)
+        deconstruct_result681 = _t1289
+        if !isnothing(deconstruct_result681)
+            unwrapped682 = deconstruct_result681
+            pretty_date(pp, unwrapped682)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("datetime_value"))
-                _t1264 = _get_oneof_field(_dollar_dollar, :datetime_value)
+                _t1290 = _get_oneof_field(_dollar_dollar, :datetime_value)
             else
-                _t1264 = nothing
+                _t1290 = nothing
             end
-            deconstruct_result666 = _t1264
-            if !isnothing(deconstruct_result666)
-                unwrapped667 = deconstruct_result666
-                pretty_datetime(pp, unwrapped667)
+            deconstruct_result679 = _t1290
+            if !isnothing(deconstruct_result679)
+                unwrapped680 = deconstruct_result679
+                pretty_datetime(pp, unwrapped680)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("string_value"))
-                    _t1265 = _get_oneof_field(_dollar_dollar, :string_value)
+                    _t1291 = _get_oneof_field(_dollar_dollar, :string_value)
                 else
-                    _t1265 = nothing
+                    _t1291 = nothing
                 end
-                deconstruct_result664 = _t1265
-                if !isnothing(deconstruct_result664)
-                    unwrapped665 = deconstruct_result664
-                    write(pp, format_string(pp, unwrapped665))
+                deconstruct_result677 = _t1291
+                if !isnothing(deconstruct_result677)
+                    unwrapped678 = deconstruct_result677
+                    write(pp, format_string(pp, unwrapped678))
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("int_value"))
-                        _t1266 = _get_oneof_field(_dollar_dollar, :int_value)
+                        _t1292 = _get_oneof_field(_dollar_dollar, :int_value)
                     else
-                        _t1266 = nothing
+                        _t1292 = nothing
                     end
-                    deconstruct_result662 = _t1266
-                    if !isnothing(deconstruct_result662)
-                        unwrapped663 = deconstruct_result662
-                        write(pp, format_int(pp, unwrapped663))
+                    deconstruct_result675 = _t1292
+                    if !isnothing(deconstruct_result675)
+                        unwrapped676 = deconstruct_result675
+                        write(pp, format_int(pp, unwrapped676))
                     else
                         _dollar_dollar = msg
                         if _has_proto_field(_dollar_dollar, Symbol("float_value"))
-                            _t1267 = _get_oneof_field(_dollar_dollar, :float_value)
+                            _t1293 = _get_oneof_field(_dollar_dollar, :float_value)
                         else
-                            _t1267 = nothing
+                            _t1293 = nothing
                         end
-                        deconstruct_result660 = _t1267
-                        if !isnothing(deconstruct_result660)
-                            unwrapped661 = deconstruct_result660
-                            write(pp, format_float(pp, unwrapped661))
+                        deconstruct_result673 = _t1293
+                        if !isnothing(deconstruct_result673)
+                            unwrapped674 = deconstruct_result673
+                            write(pp, format_float(pp, unwrapped674))
                         else
                             _dollar_dollar = msg
                             if _has_proto_field(_dollar_dollar, Symbol("uint128_value"))
-                                _t1268 = _get_oneof_field(_dollar_dollar, :uint128_value)
+                                _t1294 = _get_oneof_field(_dollar_dollar, :uint128_value)
                             else
-                                _t1268 = nothing
+                                _t1294 = nothing
                             end
-                            deconstruct_result658 = _t1268
-                            if !isnothing(deconstruct_result658)
-                                unwrapped659 = deconstruct_result658
-                                write(pp, format_uint128(pp, unwrapped659))
+                            deconstruct_result671 = _t1294
+                            if !isnothing(deconstruct_result671)
+                                unwrapped672 = deconstruct_result671
+                                write(pp, format_uint128(pp, unwrapped672))
                             else
                                 _dollar_dollar = msg
                                 if _has_proto_field(_dollar_dollar, Symbol("int128_value"))
-                                    _t1269 = _get_oneof_field(_dollar_dollar, :int128_value)
+                                    _t1295 = _get_oneof_field(_dollar_dollar, :int128_value)
                                 else
-                                    _t1269 = nothing
+                                    _t1295 = nothing
                                 end
-                                deconstruct_result656 = _t1269
-                                if !isnothing(deconstruct_result656)
-                                    unwrapped657 = deconstruct_result656
-                                    write(pp, format_int128(pp, unwrapped657))
+                                deconstruct_result669 = _t1295
+                                if !isnothing(deconstruct_result669)
+                                    unwrapped670 = deconstruct_result669
+                                    write(pp, format_int128(pp, unwrapped670))
                                 else
                                     _dollar_dollar = msg
                                     if _has_proto_field(_dollar_dollar, Symbol("decimal_value"))
-                                        _t1270 = _get_oneof_field(_dollar_dollar, :decimal_value)
+                                        _t1296 = _get_oneof_field(_dollar_dollar, :decimal_value)
                                     else
-                                        _t1270 = nothing
+                                        _t1296 = nothing
                                     end
-                                    deconstruct_result654 = _t1270
-                                    if !isnothing(deconstruct_result654)
-                                        unwrapped655 = deconstruct_result654
-                                        write(pp, format_decimal(pp, unwrapped655))
+                                    deconstruct_result667 = _t1296
+                                    if !isnothing(deconstruct_result667)
+                                        unwrapped668 = deconstruct_result667
+                                        write(pp, format_decimal(pp, unwrapped668))
                                     else
                                         _dollar_dollar = msg
                                         if _has_proto_field(_dollar_dollar, Symbol("boolean_value"))
-                                            _t1271 = _get_oneof_field(_dollar_dollar, :boolean_value)
+                                            _t1297 = _get_oneof_field(_dollar_dollar, :boolean_value)
                                         else
-                                            _t1271 = nothing
+                                            _t1297 = nothing
                                         end
-                                        deconstruct_result652 = _t1271
-                                        if !isnothing(deconstruct_result652)
-                                            unwrapped653 = deconstruct_result652
-                                            pretty_boolean_value(pp, unwrapped653)
+                                        deconstruct_result665 = _t1297
+                                        if !isnothing(deconstruct_result665)
+                                            unwrapped666 = deconstruct_result665
+                                            pretty_boolean_value(pp, unwrapped666)
                                         else
-                                            fields651 = msg
+                                            fields664 = msg
                                             write(pp, "missing")
                                         end
                                     end
@@ -746,25 +746,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value)
 end
 
 function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue)
-    flat676 = try_flat(pp, msg, pretty_date)
-    if !isnothing(flat676)
-        write(pp, flat676)
+    flat689 = try_flat(pp, msg, pretty_date)
+    if !isnothing(flat689)
+        write(pp, flat689)
         return nothing
     else
         _dollar_dollar = msg
-        fields671 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),)
-        unwrapped_fields672 = fields671
+        fields684 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),)
+        unwrapped_fields685 = fields684
         write(pp, "(date")
         indent_sexp!(pp)
         newline(pp)
-        field673 = unwrapped_fields672[1]
-        write(pp, format_int(pp, field673))
+        field686 = unwrapped_fields685[1]
+        write(pp, format_int(pp, field686))
         newline(pp)
-        field674 = unwrapped_fields672[2]
-        write(pp, format_int(pp, field674))
+        field687 = unwrapped_fields685[2]
+        write(pp, format_int(pp, field687))
         newline(pp)
-        field675 = unwrapped_fields672[3]
-        write(pp, format_int(pp, field675))
+        field688 = unwrapped_fields685[3]
+        write(pp, format_int(pp, field688))
         dedent!(pp)
         write(pp, ")")
     end
@@ -772,39 +772,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue)
 end
 
 function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue)
-    flat687 = try_flat(pp, msg, pretty_datetime)
-    if !isnothing(flat687)
-        write(pp, flat687)
+    flat700 = try_flat(pp, msg, pretty_datetime)
+    if !isnothing(flat700)
+        write(pp, flat700)
         return nothing
     else
         _dollar_dollar = msg
-        fields677 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),)
-        unwrapped_fields678 = fields677
+        fields690 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),)
+        unwrapped_fields691 = fields690
         write(pp, "(datetime")
         indent_sexp!(pp)
         newline(pp)
-        field679 = unwrapped_fields678[1]
-        write(pp, format_int(pp, field679))
+        field692 = unwrapped_fields691[1]
+        write(pp, format_int(pp, field692))
         newline(pp)
-        field680 = unwrapped_fields678[2]
-        write(pp, format_int(pp, field680))
+        field693 = unwrapped_fields691[2]
+        write(pp, format_int(pp, field693))
         newline(pp)
-        field681 = unwrapped_fields678[3]
-        write(pp, format_int(pp, field681))
+        field694 = unwrapped_fields691[3]
+        write(pp, format_int(pp, field694))
         newline(pp)
-        field682 = unwrapped_fields678[4]
-        write(pp, format_int(pp, field682))
+        field695 = unwrapped_fields691[4]
+        write(pp, format_int(pp, field695))
         newline(pp)
-        field683 = unwrapped_fields678[5]
-        write(pp, format_int(pp, field683))
+        field696 = unwrapped_fields691[5]
+        write(pp, format_int(pp, field696))
         newline(pp)
-        field684 = unwrapped_fields678[6]
-        write(pp, format_int(pp, field684))
-        field685 = unwrapped_fields678[7]
-        if !isnothing(field685)
+        field697 = unwrapped_fields691[6]
+        write(pp, format_int(pp, field697))
+        field698 = unwrapped_fields691[7]
+        if !isnothing(field698)
             newline(pp)
-            opt_val686 = field685
-            write(pp, format_int(pp, opt_val686))
+            opt_val699 = field698
+            write(pp, format_int(pp, opt_val699))
         end
         dedent!(pp)
         write(pp, ")")
@@ -815,24 +815,24 @@ end
 function pretty_boolean_value(pp::PrettyPrinter, msg::Bool)
     _dollar_dollar = msg
     if _dollar_dollar
-        _t1272 = ()
+        _t1298 = ()
     else
-        _t1272 = nothing
+        _t1298 = nothing
     end
-    deconstruct_result690 = _t1272
-    if !isnothing(deconstruct_result690)
-        unwrapped691 = deconstruct_result690
+    deconstruct_result703 = _t1298
+    if !isnothing(deconstruct_result703)
+        unwrapped704 = deconstruct_result703
         write(pp, "true")
     else
         _dollar_dollar = msg
         if !_dollar_dollar
-            _t1273 = ()
+            _t1299 = ()
         else
-            _t1273 = nothing
+            _t1299 = nothing
         end
-        deconstruct_result688 = _t1273
-        if !isnothing(deconstruct_result688)
-            unwrapped689 = deconstruct_result688
+        deconstruct_result701 = _t1299
+        if !isnothing(deconstruct_result701)
+            unwrapped702 = deconstruct_result701
             write(pp, "false")
         else
             throw(ParseError("No matching rule for boolean_value"))
@@ -842,24 +842,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool)
 end
 
 function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync)
-    flat696 = try_flat(pp, msg, pretty_sync)
-    if !isnothing(flat696)
-        write(pp, flat696)
+    flat709 = try_flat(pp, msg, pretty_sync)
+    if !isnothing(flat709)
+        write(pp, flat709)
         return nothing
     else
         _dollar_dollar = msg
-        fields692 = _dollar_dollar.fragments
-        unwrapped_fields693 = fields692
+        fields705 = _dollar_dollar.fragments
+        unwrapped_fields706 = fields705
         write(pp, "(sync")
         indent_sexp!(pp)
-        if !isempty(unwrapped_fields693)
+        if !isempty(unwrapped_fields706)
             newline(pp)
-            for (i1274, elem694) in enumerate(unwrapped_fields693)
-                i695 = i1274 - 1
-                if (i695 > 0)
+            for (i1300, elem707) in enumerate(unwrapped_fields706)
+                i708 = i1300 - 1
+                if (i708 > 0)
                     newline(pp)
                 end
-                pretty_fragment_id(pp, elem694)
+                pretty_fragment_id(pp, elem707)
             end
         end
         dedent!(pp)
@@ -869,52 +869,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync)
 end
 
 function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId)
-    flat699 = try_flat(pp, msg, pretty_fragment_id)
-    if !isnothing(flat699)
-        write(pp, flat699)
+    flat712 = try_flat(pp, msg, pretty_fragment_id)
+    if !isnothing(flat712)
+        write(pp, flat712)
         return nothing
     else
         _dollar_dollar = msg
-        fields697 = fragment_id_to_string(pp, _dollar_dollar)
-        unwrapped_fields698 = fields697
+        fields710 = fragment_id_to_string(pp, _dollar_dollar)
+        unwrapped_fields711 = fields710
         write(pp, ":")
-        write(pp, unwrapped_fields698)
+        write(pp, unwrapped_fields711)
     end
     return nothing
 end
 
 function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch)
-    flat706 = try_flat(pp, msg, pretty_epoch)
-    if !isnothing(flat706)
-        write(pp, flat706)
+    flat719 = try_flat(pp, msg, pretty_epoch)
+    if !isnothing(flat719)
+        write(pp, flat719)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.writes)
-            _t1275 = _dollar_dollar.writes
+            _t1301 = _dollar_dollar.writes
         else
-            _t1275 = nothing
+            _t1301 = nothing
         end
         if !isempty(_dollar_dollar.reads)
-            _t1276 = _dollar_dollar.reads
+            _t1302 = _dollar_dollar.reads
         else
-            _t1276 = nothing
+            _t1302 = nothing
         end
-        fields700 = (_t1275, _t1276,)
-        unwrapped_fields701 = fields700
+        fields713 = (_t1301, _t1302,)
+        unwrapped_fields714 = fields713
         write(pp, "(epoch")
         indent_sexp!(pp)
-        field702 = unwrapped_fields701[1]
-        if !isnothing(field702)
+        field715 = unwrapped_fields714[1]
+        if !isnothing(field715)
             newline(pp)
-            opt_val703 = field702
-            pretty_epoch_writes(pp, opt_val703)
+            opt_val716 = field715
+            pretty_epoch_writes(pp, opt_val716)
         end
-        field704 = unwrapped_fields701[2]
-        if !isnothing(field704)
+        field717 = unwrapped_fields714[2]
+        if !isnothing(field717)
             newline(pp)
-            opt_val705 = field704
-            pretty_epoch_reads(pp, opt_val705)
+            opt_val718 = field717
+            pretty_epoch_reads(pp, opt_val718)
         end
         dedent!(pp)
         write(pp, ")")
@@ -923,22 +923,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch)
 end
 
 function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write})
-    flat710 = try_flat(pp, msg, pretty_epoch_writes)
-    if !isnothing(flat710)
-        write(pp, flat710)
+    flat723 = try_flat(pp, msg, pretty_epoch_writes)
+    if !isnothing(flat723)
+        write(pp, flat723)
         return nothing
     else
-        fields707 = msg
+        fields720 = msg
         write(pp, "(writes")
         indent_sexp!(pp)
-        if !isempty(fields707)
+        if !isempty(fields720)
             newline(pp)
-            for (i1277, elem708) in enumerate(fields707)
-                i709 = i1277 - 1
-                if (i709 > 0)
+            for (i1303, elem721) in enumerate(fields720)
+                i722 = i1303 - 1
+                if (i722 > 0)
                     newline(pp)
                 end
-                pretty_write(pp, elem708)
+                pretty_write(pp, elem721)
             end
         end
         dedent!(pp)
@@ -948,54 +948,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write})
 end
 
 function pretty_write(pp::PrettyPrinter, msg::Proto.Write)
-    flat719 = try_flat(pp, msg, pretty_write)
-    if !isnothing(flat719)
-        write(pp, flat719)
+    flat732 = try_flat(pp, msg, pretty_write)
+    if !isnothing(flat732)
+        write(pp, flat732)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("define"))
-            _t1278 = _get_oneof_field(_dollar_dollar, :define)
+            _t1304 = _get_oneof_field(_dollar_dollar, :define)
         else
-            _t1278 = nothing
+            _t1304 = nothing
         end
-        deconstruct_result717 = _t1278
-        if !isnothing(deconstruct_result717)
-            unwrapped718 = deconstruct_result717
-            pretty_define(pp, unwrapped718)
+        deconstruct_result730 = _t1304
+        if !isnothing(deconstruct_result730)
+            unwrapped731 = deconstruct_result730
+            pretty_define(pp, unwrapped731)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("undefine"))
-                _t1279 = _get_oneof_field(_dollar_dollar, :undefine)
+                _t1305 = _get_oneof_field(_dollar_dollar, :undefine)
             else
-                _t1279 = nothing
+                _t1305 = nothing
             end
-            deconstruct_result715 = _t1279
-            if !isnothing(deconstruct_result715)
-                unwrapped716 = deconstruct_result715
-                pretty_undefine(pp, unwrapped716)
+            deconstruct_result728 = _t1305
+            if !isnothing(deconstruct_result728)
+                unwrapped729 = deconstruct_result728
+                pretty_undefine(pp, unwrapped729)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("context"))
-                    _t1280 = _get_oneof_field(_dollar_dollar, :context)
+                    _t1306 = _get_oneof_field(_dollar_dollar, :context)
                 else
-                    _t1280 = nothing
+                    _t1306 = nothing
                 end
-                deconstruct_result713 = _t1280
-                if !isnothing(deconstruct_result713)
-                    unwrapped714 = deconstruct_result713
-                    pretty_context(pp, unwrapped714)
+                deconstruct_result726 = _t1306
+                if !isnothing(deconstruct_result726)
+                    unwrapped727 = deconstruct_result726
+                    pretty_context(pp, unwrapped727)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("snapshot"))
-                        _t1281 = _get_oneof_field(_dollar_dollar, :snapshot)
+                        _t1307 = _get_oneof_field(_dollar_dollar, :snapshot)
                     else
-                        _t1281 = nothing
+                        _t1307 = nothing
                     end
-                    deconstruct_result711 = _t1281
-                    if !isnothing(deconstruct_result711)
-                        unwrapped712 = deconstruct_result711
-                        pretty_snapshot(pp, unwrapped712)
+                    deconstruct_result724 = _t1307
+                    if !isnothing(deconstruct_result724)
+                        unwrapped725 = deconstruct_result724
+                        pretty_snapshot(pp, unwrapped725)
                     else
                         throw(ParseError("No matching rule for write"))
                     end
@@ -1007,18 +1007,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write)
 end
 
 function pretty_define(pp::PrettyPrinter, msg::Proto.Define)
-    flat722 = try_flat(pp, msg, pretty_define)
-    if !isnothing(flat722)
-        write(pp, flat722)
+    flat735 = try_flat(pp, msg, pretty_define)
+    if !isnothing(flat735)
+        write(pp, flat735)
         return nothing
     else
         _dollar_dollar = msg
-        fields720 = _dollar_dollar.fragment
-        unwrapped_fields721 = fields720
+        fields733 = _dollar_dollar.fragment
+        unwrapped_fields734 = fields733
         write(pp, "(define")
         indent_sexp!(pp)
         newline(pp)
-        pretty_fragment(pp, unwrapped_fields721)
+        pretty_fragment(pp, unwrapped_fields734)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1026,29 +1026,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define)
 end
 
 function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment)
-    flat729 = try_flat(pp, msg, pretty_fragment)
-    if !isnothing(flat729)
-        write(pp, flat729)
+    flat742 = try_flat(pp, msg, pretty_fragment)
+    if !isnothing(flat742)
+        write(pp, flat742)
         return nothing
     else
         _dollar_dollar = msg
         start_pretty_fragment(pp, _dollar_dollar)
-        fields723 = (_dollar_dollar.id, _dollar_dollar.declarations,)
-        unwrapped_fields724 = fields723
+        fields736 = (_dollar_dollar.id, _dollar_dollar.declarations,)
+        unwrapped_fields737 = fields736
         write(pp, "(fragment")
         indent_sexp!(pp)
         newline(pp)
-        field725 = unwrapped_fields724[1]
-        pretty_new_fragment_id(pp, field725)
-        field726 = unwrapped_fields724[2]
-        if !isempty(field726)
+        field738 = unwrapped_fields737[1]
+        pretty_new_fragment_id(pp, field738)
+        field739 = unwrapped_fields737[2]
+        if !isempty(field739)
             newline(pp)
-            for (i1282, elem727) in enumerate(field726)
-                i728 = i1282 - 1
-                if (i728 > 0)
+            for (i1308, elem740) in enumerate(field739)
+                i741 = i1308 - 1
+                if (i741 > 0)
                     newline(pp)
                 end
-                pretty_declaration(pp, elem727)
+                pretty_declaration(pp, elem740)
             end
         end
         dedent!(pp)
@@ -1058,66 +1058,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment)
 end
 
 function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId)
-    flat731 = try_flat(pp, msg, pretty_new_fragment_id)
-    if !isnothing(flat731)
-        write(pp, flat731)
+    flat744 = try_flat(pp, msg, pretty_new_fragment_id)
+    if !isnothing(flat744)
+        write(pp, flat744)
         return nothing
     else
-        fields730 = msg
-        pretty_fragment_id(pp, fields730)
+        fields743 = msg
+        pretty_fragment_id(pp, fields743)
     end
     return nothing
 end
 
 function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration)
-    flat740 = try_flat(pp, msg, pretty_declaration)
-    if !isnothing(flat740)
-        write(pp, flat740)
+    flat753 = try_flat(pp, msg, pretty_declaration)
+    if !isnothing(flat753)
+        write(pp, flat753)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("def"))
-            _t1283 = _get_oneof_field(_dollar_dollar, :def)
+            _t1309 = _get_oneof_field(_dollar_dollar, :def)
         else
-            _t1283 = nothing
+            _t1309 = nothing
         end
-        deconstruct_result738 = _t1283
-        if !isnothing(deconstruct_result738)
-            unwrapped739 = deconstruct_result738
-            pretty_def(pp, unwrapped739)
+        deconstruct_result751 = _t1309
+        if !isnothing(deconstruct_result751)
+            unwrapped752 = deconstruct_result751
+            pretty_def(pp, unwrapped752)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("algorithm"))
-                _t1284 = _get_oneof_field(_dollar_dollar, :algorithm)
+                _t1310 = _get_oneof_field(_dollar_dollar, :algorithm)
             else
-                _t1284 = nothing
+                _t1310 = nothing
             end
-            deconstruct_result736 = _t1284
-            if !isnothing(deconstruct_result736)
-                unwrapped737 = deconstruct_result736
-                pretty_algorithm(pp, unwrapped737)
+            deconstruct_result749 = _t1310
+            if !isnothing(deconstruct_result749)
+                unwrapped750 = deconstruct_result749
+                pretty_algorithm(pp, unwrapped750)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("constraint"))
-                    _t1285 = _get_oneof_field(_dollar_dollar, :constraint)
+                    _t1311 = _get_oneof_field(_dollar_dollar, :constraint)
                 else
-                    _t1285 = nothing
+                    _t1311 = nothing
                 end
-                deconstruct_result734 = _t1285
-                if !isnothing(deconstruct_result734)
-                    unwrapped735 = deconstruct_result734
-                    pretty_constraint(pp, unwrapped735)
+                deconstruct_result747 = _t1311
+                if !isnothing(deconstruct_result747)
+                    unwrapped748 = deconstruct_result747
+                    pretty_constraint(pp, unwrapped748)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("data"))
-                        _t1286 = _get_oneof_field(_dollar_dollar, :data)
+                        _t1312 = _get_oneof_field(_dollar_dollar, :data)
                     else
-                        _t1286 = nothing
+                        _t1312 = nothing
                     end
-                    deconstruct_result732 = _t1286
-                    if !isnothing(deconstruct_result732)
-                        unwrapped733 = deconstruct_result732
-                        pretty_data(pp, unwrapped733)
+                    deconstruct_result745 = _t1312
+                    if !isnothing(deconstruct_result745)
+                        unwrapped746 = deconstruct_result745
+                        pretty_data(pp, unwrapped746)
                     else
                         throw(ParseError("No matching rule for declaration"))
                     end
@@ -1129,32 +1129,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration)
 end
 
 function pretty_def(pp::PrettyPrinter, msg::Proto.Def)
-    flat747 = try_flat(pp, msg, pretty_def)
-    if !isnothing(flat747)
-        write(pp, flat747)
+    flat760 = try_flat(pp, msg, pretty_def)
+    if !isnothing(flat760)
+        write(pp, flat760)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1287 = _dollar_dollar.attrs
+            _t1313 = _dollar_dollar.attrs
         else
-            _t1287 = nothing
+            _t1313 = nothing
         end
-        fields741 = (_dollar_dollar.name, _dollar_dollar.body, _t1287,)
-        unwrapped_fields742 = fields741
+        fields754 = (_dollar_dollar.name, _dollar_dollar.body, _t1313,)
+        unwrapped_fields755 = fields754
         write(pp, "(def")
         indent_sexp!(pp)
         newline(pp)
-        field743 = unwrapped_fields742[1]
-        pretty_relation_id(pp, field743)
+        field756 = unwrapped_fields755[1]
+        pretty_relation_id(pp, field756)
         newline(pp)
-        field744 = unwrapped_fields742[2]
-        pretty_abstraction(pp, field744)
-        field745 = unwrapped_fields742[3]
-        if !isnothing(field745)
+        field757 = unwrapped_fields755[2]
+        pretty_abstraction(pp, field757)
+        field758 = unwrapped_fields755[3]
+        if !isnothing(field758)
             newline(pp)
-            opt_val746 = field745
-            pretty_attrs(pp, opt_val746)
+            opt_val759 = field758
+            pretty_attrs(pp, opt_val759)
         end
         dedent!(pp)
         write(pp, ")")
@@ -1163,30 +1163,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def)
 end
 
 function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId)
-    flat752 = try_flat(pp, msg, pretty_relation_id)
-    if !isnothing(flat752)
-        write(pp, flat752)
+    flat765 = try_flat(pp, msg, pretty_relation_id)
+    if !isnothing(flat765)
+        write(pp, flat765)
         return nothing
     else
         _dollar_dollar = msg
         if !isnothing(relation_id_to_string(pp, _dollar_dollar))
-            _t1289 = deconstruct_relation_id_string(pp, _dollar_dollar)
-            _t1288 = _t1289
+            _t1315 = deconstruct_relation_id_string(pp, _dollar_dollar)
+            _t1314 = _t1315
         else
-            _t1288 = nothing
+            _t1314 = nothing
         end
-        deconstruct_result750 = _t1288
-        if !isnothing(deconstruct_result750)
-            unwrapped751 = deconstruct_result750
+        deconstruct_result763 = _t1314
+        if !isnothing(deconstruct_result763)
+            unwrapped764 = deconstruct_result763
             write(pp, ":")
-            write(pp, unwrapped751)
+            write(pp, unwrapped764)
         else
             _dollar_dollar = msg
-            _t1290 = deconstruct_relation_id_uint128(pp, _dollar_dollar)
-            deconstruct_result748 = _t1290
-            if !isnothing(deconstruct_result748)
-                unwrapped749 = deconstruct_result748
-                write(pp, format_uint128(pp, unwrapped749))
+            _t1316 = deconstruct_relation_id_uint128(pp, _dollar_dollar)
+            deconstruct_result761 = _t1316
+            if !isnothing(deconstruct_result761)
+                unwrapped762 = deconstruct_result761
+                write(pp, format_uint128(pp, unwrapped762))
             else
                 throw(ParseError("No matching rule for relation_id"))
             end
@@ -1196,22 +1196,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId)
 end
 
 function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction)
-    flat757 = try_flat(pp, msg, pretty_abstraction)
-    if !isnothing(flat757)
-        write(pp, flat757)
+    flat770 = try_flat(pp, msg, pretty_abstraction)
+    if !isnothing(flat770)
+        write(pp, flat770)
         return nothing
     else
         _dollar_dollar = msg
-        _t1291 = deconstruct_bindings(pp, _dollar_dollar)
-        fields753 = (_t1291, _dollar_dollar.value,)
-        unwrapped_fields754 = fields753
+        _t1317 = deconstruct_bindings(pp, _dollar_dollar)
+        fields766 = (_t1317, _dollar_dollar.value,)
+        unwrapped_fields767 = fields766
         write(pp, "(")
         indent!(pp)
-        field755 = unwrapped_fields754[1]
-        pretty_bindings(pp, field755)
+        field768 = unwrapped_fields767[1]
+        pretty_bindings(pp, field768)
         newline(pp)
-        field756 = unwrapped_fields754[2]
-        pretty_formula(pp, field756)
+        field769 = unwrapped_fields767[2]
+        pretty_formula(pp, field769)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1219,34 +1219,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction)
 end
 
 function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}})
-    flat765 = try_flat(pp, msg, pretty_bindings)
-    if !isnothing(flat765)
-        write(pp, flat765)
+    flat778 = try_flat(pp, msg, pretty_bindings)
+    if !isnothing(flat778)
+        write(pp, flat778)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar[2])
-            _t1292 = _dollar_dollar[2]
+            _t1318 = _dollar_dollar[2]
         else
-            _t1292 = nothing
+            _t1318 = nothing
         end
-        fields758 = (_dollar_dollar[1], _t1292,)
-        unwrapped_fields759 = fields758
+        fields771 = (_dollar_dollar[1], _t1318,)
+        unwrapped_fields772 = fields771
         write(pp, "[")
         indent!(pp)
-        field760 = unwrapped_fields759[1]
-        for (i1293, elem761) in enumerate(field760)
-            i762 = i1293 - 1
-            if (i762 > 0)
+        field773 = unwrapped_fields772[1]
+        for (i1319, elem774) in enumerate(field773)
+            i775 = i1319 - 1
+            if (i775 > 0)
                 newline(pp)
             end
-            pretty_binding(pp, elem761)
+            pretty_binding(pp, elem774)
         end
-        field763 = unwrapped_fields759[2]
-        if !isnothing(field763)
+        field776 = unwrapped_fields772[2]
+        if !isnothing(field776)
             newline(pp)
-            opt_val764 = field763
-            pretty_value_bindings(pp, opt_val764)
+            opt_val777 = field776
+            pretty_value_bindings(pp, opt_val777)
         end
         dedent!(pp)
         write(pp, "]")
@@ -1255,149 +1255,149 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve
 end
 
 function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding)
-    flat770 = try_flat(pp, msg, pretty_binding)
-    if !isnothing(flat770)
-        write(pp, flat770)
+    flat783 = try_flat(pp, msg, pretty_binding)
+    if !isnothing(flat783)
+        write(pp, flat783)
         return nothing
     else
         _dollar_dollar = msg
-        fields766 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",)
-        unwrapped_fields767 = fields766
-        field768 = unwrapped_fields767[1]
-        write(pp, field768)
+        fields779 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",)
+        unwrapped_fields780 = fields779
+        field781 = unwrapped_fields780[1]
+        write(pp, field781)
         write(pp, "::")
-        field769 = unwrapped_fields767[2]
-        pretty_type(pp, field769)
+        field782 = unwrapped_fields780[2]
+        pretty_type(pp, field782)
     end
     return nothing
 end
 
 function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type")
-    flat793 = try_flat(pp, msg, pretty_type)
-    if !isnothing(flat793)
-        write(pp, flat793)
+    flat806 = try_flat(pp, msg, pretty_type)
+    if !isnothing(flat806)
+        write(pp, flat806)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("unspecified_type"))
-            _t1294 = _get_oneof_field(_dollar_dollar, :unspecified_type)
+            _t1320 = _get_oneof_field(_dollar_dollar, :unspecified_type)
         else
-            _t1294 = nothing
+            _t1320 = nothing
         end
-        deconstruct_result791 = _t1294
-        if !isnothing(deconstruct_result791)
-            unwrapped792 = deconstruct_result791
-            pretty_unspecified_type(pp, unwrapped792)
+        deconstruct_result804 = _t1320
+        if !isnothing(deconstruct_result804)
+            unwrapped805 = deconstruct_result804
+            pretty_unspecified_type(pp, unwrapped805)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("string_type"))
-                _t1295 = _get_oneof_field(_dollar_dollar, :string_type)
+                _t1321 = _get_oneof_field(_dollar_dollar, :string_type)
             else
-                _t1295 = nothing
+                _t1321 = nothing
             end
-            deconstruct_result789 = _t1295
-            if !isnothing(deconstruct_result789)
-                unwrapped790 = deconstruct_result789
-                pretty_string_type(pp, unwrapped790)
+            deconstruct_result802 = _t1321
+            if !isnothing(deconstruct_result802)
+                unwrapped803 = deconstruct_result802
+                pretty_string_type(pp, unwrapped803)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("int_type"))
-                    _t1296 = _get_oneof_field(_dollar_dollar, :int_type)
+                    _t1322 = _get_oneof_field(_dollar_dollar, :int_type)
                 else
-                    _t1296 = nothing
+                    _t1322 = nothing
                 end
-                deconstruct_result787 = _t1296
-                if !isnothing(deconstruct_result787)
-                    unwrapped788 = deconstruct_result787
-                    pretty_int_type(pp, unwrapped788)
+                deconstruct_result800 = _t1322
+                if !isnothing(deconstruct_result800)
+                    unwrapped801 = deconstruct_result800
+                    pretty_int_type(pp, unwrapped801)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("float_type"))
-                        _t1297 = _get_oneof_field(_dollar_dollar, :float_type)
+                        _t1323 = _get_oneof_field(_dollar_dollar, :float_type)
                     else
-                        _t1297 = nothing
+                        _t1323 = nothing
                     end
-                    deconstruct_result785 = _t1297
-                    if !isnothing(deconstruct_result785)
-                        unwrapped786 = deconstruct_result785
-                        pretty_float_type(pp, unwrapped786)
+                    deconstruct_result798 = _t1323
+                    if !isnothing(deconstruct_result798)
+                        unwrapped799 = deconstruct_result798
+                        pretty_float_type(pp, unwrapped799)
                     else
                         _dollar_dollar = msg
                         if _has_proto_field(_dollar_dollar, Symbol("uint128_type"))
-                            _t1298 = _get_oneof_field(_dollar_dollar, :uint128_type)
+                            _t1324 = _get_oneof_field(_dollar_dollar, :uint128_type)
                         else
-                            _t1298 = nothing
+                            _t1324 = nothing
                         end
-                        deconstruct_result783 = _t1298
-                        if !isnothing(deconstruct_result783)
-                            unwrapped784 = deconstruct_result783
-                            pretty_uint128_type(pp, unwrapped784)
+                        deconstruct_result796 = _t1324
+                        if !isnothing(deconstruct_result796)
+                            unwrapped797 = deconstruct_result796
+                            pretty_uint128_type(pp, unwrapped797)
                         else
                             _dollar_dollar = msg
                             if _has_proto_field(_dollar_dollar, Symbol("int128_type"))
-                                _t1299 = _get_oneof_field(_dollar_dollar, :int128_type)
+                                _t1325 = _get_oneof_field(_dollar_dollar, :int128_type)
                             else
-                                _t1299 = nothing
+                                _t1325 = nothing
                             end
-                            deconstruct_result781 = _t1299
-                            if !isnothing(deconstruct_result781)
-                                unwrapped782 = deconstruct_result781
-                                pretty_int128_type(pp, unwrapped782)
+                            deconstruct_result794 = _t1325
+                            if !isnothing(deconstruct_result794)
+                                unwrapped795 = deconstruct_result794
+                                pretty_int128_type(pp, unwrapped795)
                             else
                                 _dollar_dollar = msg
                                 if _has_proto_field(_dollar_dollar, Symbol("date_type"))
-                                    _t1300 = _get_oneof_field(_dollar_dollar, :date_type)
+                                    _t1326 = _get_oneof_field(_dollar_dollar, :date_type)
                                 else
-                                    _t1300 = nothing
+                                    _t1326 = nothing
                                 end
-                                deconstruct_result779 = _t1300
-                                if !isnothing(deconstruct_result779)
-                                    unwrapped780 = deconstruct_result779
-                                    pretty_date_type(pp, unwrapped780)
+                                deconstruct_result792 = _t1326
+                                if !isnothing(deconstruct_result792)
+                                    unwrapped793 = deconstruct_result792
+                                    pretty_date_type(pp, unwrapped793)
                                 else
                                     _dollar_dollar = msg
                                     if _has_proto_field(_dollar_dollar, Symbol("datetime_type"))
-                                        _t1301 = _get_oneof_field(_dollar_dollar, :datetime_type)
+                                        _t1327 = _get_oneof_field(_dollar_dollar, :datetime_type)
                                     else
-                                        _t1301 = nothing
+                                        _t1327 = nothing
                                     end
-                                    deconstruct_result777 = _t1301
-                                    if !isnothing(deconstruct_result777)
-                                        unwrapped778 = deconstruct_result777
-                                        pretty_datetime_type(pp, unwrapped778)
+                                    deconstruct_result790 = _t1327
+                                    if !isnothing(deconstruct_result790)
+                                        unwrapped791 = deconstruct_result790
+                                        pretty_datetime_type(pp, unwrapped791)
                                     else
                                         _dollar_dollar = msg
                                         if _has_proto_field(_dollar_dollar, Symbol("missing_type"))
-                                            _t1302 = _get_oneof_field(_dollar_dollar, :missing_type)
+                                            _t1328 = _get_oneof_field(_dollar_dollar, :missing_type)
                                         else
-                                            _t1302 = nothing
+                                            _t1328 = nothing
                                         end
-                                        deconstruct_result775 = _t1302
-                                        if !isnothing(deconstruct_result775)
-                                            unwrapped776 = deconstruct_result775
-                                            pretty_missing_type(pp, unwrapped776)
+                                        deconstruct_result788 = _t1328
+                                        if !isnothing(deconstruct_result788)
+                                            unwrapped789 = deconstruct_result788
+                                            pretty_missing_type(pp, unwrapped789)
                                         else
                                             _dollar_dollar = msg
                                             if _has_proto_field(_dollar_dollar, Symbol("decimal_type"))
-                                                _t1303 = _get_oneof_field(_dollar_dollar, :decimal_type)
+                                                _t1329 = _get_oneof_field(_dollar_dollar, :decimal_type)
                                             else
-                                                _t1303 = nothing
+                                                _t1329 = nothing
                                             end
-                                            deconstruct_result773 = _t1303
-                                            if !isnothing(deconstruct_result773)
-                                                unwrapped774 = deconstruct_result773
-                                                pretty_decimal_type(pp, unwrapped774)
+                                            deconstruct_result786 = _t1329
+                                            if !isnothing(deconstruct_result786)
+                                                unwrapped787 = deconstruct_result786
+                                                pretty_decimal_type(pp, unwrapped787)
                                             else
                                                 _dollar_dollar = msg
                                                 if _has_proto_field(_dollar_dollar, Symbol("boolean_type"))
-                                                    _t1304 = _get_oneof_field(_dollar_dollar, :boolean_type)
+                                                    _t1330 = _get_oneof_field(_dollar_dollar, :boolean_type)
                                                 else
-                                                    _t1304 = nothing
+                                                    _t1330 = nothing
                                                 end
-                                                deconstruct_result771 = _t1304
-                                                if !isnothing(deconstruct_result771)
-                                                    unwrapped772 = deconstruct_result771
-                                                    pretty_boolean_type(pp, unwrapped772)
+                                                deconstruct_result784 = _t1330
+                                                if !isnothing(deconstruct_result784)
+                                                    unwrapped785 = deconstruct_result784
+                                                    pretty_boolean_type(pp, unwrapped785)
                                                 else
                                                     throw(ParseError("No matching rule for type"))
                                                 end
@@ -1416,76 +1416,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type")
 end
 
 function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType)
-    fields794 = msg
+    fields807 = msg
     write(pp, "UNKNOWN")
     return nothing
 end
 
 function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType)
-    fields795 = msg
+    fields808 = msg
     write(pp, "STRING")
     return nothing
 end
 
 function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType)
-    fields796 = msg
+    fields809 = msg
     write(pp, "INT")
     return nothing
 end
 
 function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType)
-    fields797 = msg
+    fields810 = msg
     write(pp, "FLOAT")
     return nothing
 end
 
 function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type)
-    fields798 = msg
+    fields811 = msg
     write(pp, "UINT128")
     return nothing
 end
 
 function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type)
-    fields799 = msg
+    fields812 = msg
     write(pp, "INT128")
     return nothing
 end
 
 function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType)
-    fields800 = msg
+    fields813 = msg
     write(pp, "DATE")
     return nothing
 end
 
 function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType)
-    fields801 = msg
+    fields814 = msg
     write(pp, "DATETIME")
     return nothing
 end
 
 function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType)
-    fields802 = msg
+    fields815 = msg
     write(pp, "MISSING")
     return nothing
 end
 
 function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType)
-    flat807 = try_flat(pp, msg, pretty_decimal_type)
-    if !isnothing(flat807)
-        write(pp, flat807)
+    flat820 = try_flat(pp, msg, pretty_decimal_type)
+    if !isnothing(flat820)
+        write(pp, flat820)
         return nothing
     else
         _dollar_dollar = msg
-        fields803 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),)
-        unwrapped_fields804 = fields803
+        fields816 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),)
+        unwrapped_fields817 = fields816
         write(pp, "(DECIMAL")
         indent_sexp!(pp)
         newline(pp)
-        field805 = unwrapped_fields804[1]
-        write(pp, format_int(pp, field805))
+        field818 = unwrapped_fields817[1]
+        write(pp, format_int(pp, field818))
         newline(pp)
-        field806 = unwrapped_fields804[2]
-        write(pp, format_int(pp, field806))
+        field819 = unwrapped_fields817[2]
+        write(pp, format_int(pp, field819))
         dedent!(pp)
         write(pp, ")")
     end
@@ -1493,27 +1493,27 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType)
 end
 
 function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType)
-    fields808 = msg
+    fields821 = msg
     write(pp, "BOOLEAN")
     return nothing
 end
 
 function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding})
-    flat812 = try_flat(pp, msg, pretty_value_bindings)
-    if !isnothing(flat812)
-        write(pp, flat812)
+    flat825 = try_flat(pp, msg, pretty_value_bindings)
+    if !isnothing(flat825)
+        write(pp, flat825)
         return nothing
     else
-        fields809 = msg
+        fields822 = msg
         write(pp, "|")
-        if !isempty(fields809)
+        if !isempty(fields822)
             write(pp, " ")
-            for (i1305, elem810) in enumerate(fields809)
-                i811 = i1305 - 1
-                if (i811 > 0)
+            for (i1331, elem823) in enumerate(fields822)
+                i824 = i1331 - 1
+                if (i824 > 0)
                     newline(pp)
                 end
-                pretty_binding(pp, elem810)
+                pretty_binding(pp, elem823)
             end
         end
     end
@@ -1521,153 +1521,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding})
 end
 
 function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula)
-    flat839 = try_flat(pp, msg, pretty_formula)
-    if !isnothing(flat839)
-        write(pp, flat839)
+    flat852 = try_flat(pp, msg, pretty_formula)
+    if !isnothing(flat852)
+        write(pp, flat852)
         return nothing
     else
         _dollar_dollar = msg
         if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args))
-            _t1306 = _get_oneof_field(_dollar_dollar, :conjunction)
+            _t1332 = _get_oneof_field(_dollar_dollar, :conjunction)
         else
-            _t1306 = nothing
+            _t1332 = nothing
         end
-        deconstruct_result837 = _t1306
-        if !isnothing(deconstruct_result837)
-            unwrapped838 = deconstruct_result837
-            pretty_true(pp, unwrapped838)
+        deconstruct_result850 = _t1332
+        if !isnothing(deconstruct_result850)
+            unwrapped851 = deconstruct_result850
+            pretty_true(pp, unwrapped851)
         else
             _dollar_dollar = msg
             if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args))
-                _t1307 = _get_oneof_field(_dollar_dollar, :disjunction)
+                _t1333 = _get_oneof_field(_dollar_dollar, :disjunction)
             else
-                _t1307 = nothing
+                _t1333 = nothing
             end
-            deconstruct_result835 = _t1307
-            if !isnothing(deconstruct_result835)
-                unwrapped836 = deconstruct_result835
-                pretty_false(pp, unwrapped836)
+            deconstruct_result848 = _t1333
+            if !isnothing(deconstruct_result848)
+                unwrapped849 = deconstruct_result848
+                pretty_false(pp, unwrapped849)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("exists"))
-                    _t1308 = _get_oneof_field(_dollar_dollar, :exists)
+                    _t1334 = _get_oneof_field(_dollar_dollar, :exists)
                 else
-                    _t1308 = nothing
+                    _t1334 = nothing
                 end
-                deconstruct_result833 = _t1308
-                if !isnothing(deconstruct_result833)
-                    unwrapped834 = deconstruct_result833
-                    pretty_exists(pp, unwrapped834)
+                deconstruct_result846 = _t1334
+                if !isnothing(deconstruct_result846)
+                    unwrapped847 = deconstruct_result846
+                    pretty_exists(pp, unwrapped847)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("reduce"))
-                        _t1309 = _get_oneof_field(_dollar_dollar, :reduce)
+                        _t1335 = _get_oneof_field(_dollar_dollar, :reduce)
                     else
-                        _t1309 = nothing
+                        _t1335 = nothing
                     end
-                    deconstruct_result831 = _t1309
-                    if !isnothing(deconstruct_result831)
-                        unwrapped832 = deconstruct_result831
-                        pretty_reduce(pp, unwrapped832)
+                    deconstruct_result844 = _t1335
+                    if !isnothing(deconstruct_result844)
+                        unwrapped845 = deconstruct_result844
+                        pretty_reduce(pp, unwrapped845)
                     else
                         _dollar_dollar = msg
                         if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args))
-                            _t1310 = _get_oneof_field(_dollar_dollar, :conjunction)
+                            _t1336 = _get_oneof_field(_dollar_dollar, :conjunction)
                         else
-                            _t1310 = nothing
+                            _t1336 = nothing
                         end
-                        deconstruct_result829 = _t1310
-                        if !isnothing(deconstruct_result829)
-                            unwrapped830 = deconstruct_result829
-                            pretty_conjunction(pp, unwrapped830)
+                        deconstruct_result842 = _t1336
+                        if !isnothing(deconstruct_result842)
+                            unwrapped843 = deconstruct_result842
+                            pretty_conjunction(pp, unwrapped843)
                         else
                             _dollar_dollar = msg
                             if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args))
-                                _t1311 = _get_oneof_field(_dollar_dollar, :disjunction)
+                                _t1337 = _get_oneof_field(_dollar_dollar, :disjunction)
                             else
-                                _t1311 = nothing
+                                _t1337 = nothing
                             end
-                            deconstruct_result827 = _t1311
-                            if !isnothing(deconstruct_result827)
-                                unwrapped828 = deconstruct_result827
-                                pretty_disjunction(pp, unwrapped828)
+                            deconstruct_result840 = _t1337
+                            if !isnothing(deconstruct_result840)
+                                unwrapped841 = deconstruct_result840
+                                pretty_disjunction(pp, unwrapped841)
                             else
                                 _dollar_dollar = msg
                                 if _has_proto_field(_dollar_dollar, Symbol("not"))
-                                    _t1312 = _get_oneof_field(_dollar_dollar, :not)
+                                    _t1338 = _get_oneof_field(_dollar_dollar, :not)
                                 else
-                                    _t1312 = nothing
+                                    _t1338 = nothing
                                 end
-                                deconstruct_result825 = _t1312
-                                if !isnothing(deconstruct_result825)
-                                    unwrapped826 = deconstruct_result825
-                                    pretty_not(pp, unwrapped826)
+                                deconstruct_result838 = _t1338
+                                if !isnothing(deconstruct_result838)
+                                    unwrapped839 = deconstruct_result838
+                                    pretty_not(pp, unwrapped839)
                                 else
                                     _dollar_dollar = msg
                                     if _has_proto_field(_dollar_dollar, Symbol("ffi"))
-                                        _t1313 = _get_oneof_field(_dollar_dollar, :ffi)
+                                        _t1339 = _get_oneof_field(_dollar_dollar, :ffi)
                                     else
-                                        _t1313 = nothing
+                                        _t1339 = nothing
                                     end
-                                    deconstruct_result823 = _t1313
-                                    if !isnothing(deconstruct_result823)
-                                        unwrapped824 = deconstruct_result823
-                                        pretty_ffi(pp, unwrapped824)
+                                    deconstruct_result836 = _t1339
+                                    if !isnothing(deconstruct_result836)
+                                        unwrapped837 = deconstruct_result836
+                                        pretty_ffi(pp, unwrapped837)
                                     else
                                         _dollar_dollar = msg
                                         if _has_proto_field(_dollar_dollar, Symbol("atom"))
-                                            _t1314 = _get_oneof_field(_dollar_dollar, :atom)
+                                            _t1340 = _get_oneof_field(_dollar_dollar, :atom)
                                         else
-                                            _t1314 = nothing
+                                            _t1340 = nothing
                                         end
-                                        deconstruct_result821 = _t1314
-                                        if !isnothing(deconstruct_result821)
-                                            unwrapped822 = deconstruct_result821
-                                            pretty_atom(pp, unwrapped822)
+                                        deconstruct_result834 = _t1340
+                                        if !isnothing(deconstruct_result834)
+                                            unwrapped835 = deconstruct_result834
+                                            pretty_atom(pp, unwrapped835)
                                         else
                                             _dollar_dollar = msg
                                             if _has_proto_field(_dollar_dollar, Symbol("pragma"))
-                                                _t1315 = _get_oneof_field(_dollar_dollar, :pragma)
+                                                _t1341 = _get_oneof_field(_dollar_dollar, :pragma)
                                             else
-                                                _t1315 = nothing
+                                                _t1341 = nothing
                                             end
-                                            deconstruct_result819 = _t1315
-                                            if !isnothing(deconstruct_result819)
-                                                unwrapped820 = deconstruct_result819
-                                                pretty_pragma(pp, unwrapped820)
+                                            deconstruct_result832 = _t1341
+                                            if !isnothing(deconstruct_result832)
+                                                unwrapped833 = deconstruct_result832
+                                                pretty_pragma(pp, unwrapped833)
                                             else
                                                 _dollar_dollar = msg
                                                 if _has_proto_field(_dollar_dollar, Symbol("primitive"))
-                                                    _t1316 = _get_oneof_field(_dollar_dollar, :primitive)
+                                                    _t1342 = _get_oneof_field(_dollar_dollar, :primitive)
                                                 else
-                                                    _t1316 = nothing
+                                                    _t1342 = nothing
                                                 end
-                                                deconstruct_result817 = _t1316
-                                                if !isnothing(deconstruct_result817)
-                                                    unwrapped818 = deconstruct_result817
-                                                    pretty_primitive(pp, unwrapped818)
+                                                deconstruct_result830 = _t1342
+                                                if !isnothing(deconstruct_result830)
+                                                    unwrapped831 = deconstruct_result830
+                                                    pretty_primitive(pp, unwrapped831)
                                                 else
                                                     _dollar_dollar = msg
                                                     if _has_proto_field(_dollar_dollar, Symbol("rel_atom"))
-                                                        _t1317 = _get_oneof_field(_dollar_dollar, :rel_atom)
+                                                        _t1343 = _get_oneof_field(_dollar_dollar, :rel_atom)
                                                     else
-                                                        _t1317 = nothing
+                                                        _t1343 = nothing
                                                     end
-                                                    deconstruct_result815 = _t1317
-                                                    if !isnothing(deconstruct_result815)
-                                                        unwrapped816 = deconstruct_result815
-                                                        pretty_rel_atom(pp, unwrapped816)
+                                                    deconstruct_result828 = _t1343
+                                                    if !isnothing(deconstruct_result828)
+                                                        unwrapped829 = deconstruct_result828
+                                                        pretty_rel_atom(pp, unwrapped829)
                                                     else
                                                         _dollar_dollar = msg
                                                         if _has_proto_field(_dollar_dollar, Symbol("cast"))
-                                                            _t1318 = _get_oneof_field(_dollar_dollar, :cast)
+                                                            _t1344 = _get_oneof_field(_dollar_dollar, :cast)
                                                         else
-                                                            _t1318 = nothing
+                                                            _t1344 = nothing
                                                         end
-                                                        deconstruct_result813 = _t1318
-                                                        if !isnothing(deconstruct_result813)
-                                                            unwrapped814 = deconstruct_result813
-                                                            pretty_cast(pp, unwrapped814)
+                                                        deconstruct_result826 = _t1344
+                                                        if !isnothing(deconstruct_result826)
+                                                            unwrapped827 = deconstruct_result826
+                                                            pretty_cast(pp, unwrapped827)
                                                         else
                                                             throw(ParseError("No matching rule for formula"))
                                                         end
@@ -1688,35 +1688,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula)
 end
 
 function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction)
-    fields840 = msg
+    fields853 = msg
     write(pp, "(true)")
     return nothing
 end
 
 function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction)
-    fields841 = msg
+    fields854 = msg
     write(pp, "(false)")
     return nothing
 end
 
 function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists)
-    flat846 = try_flat(pp, msg, pretty_exists)
-    if !isnothing(flat846)
-        write(pp, flat846)
+    flat859 = try_flat(pp, msg, pretty_exists)
+    if !isnothing(flat859)
+        write(pp, flat859)
         return nothing
     else
         _dollar_dollar = msg
-        _t1319 = deconstruct_bindings(pp, _dollar_dollar.body)
-        fields842 = (_t1319, _dollar_dollar.body.value,)
-        unwrapped_fields843 = fields842
+        _t1345 = deconstruct_bindings(pp, _dollar_dollar.body)
+        fields855 = (_t1345, _dollar_dollar.body.value,)
+        unwrapped_fields856 = fields855
         write(pp, "(exists")
         indent_sexp!(pp)
         newline(pp)
-        field844 = unwrapped_fields843[1]
-        pretty_bindings(pp, field844)
+        field857 = unwrapped_fields856[1]
+        pretty_bindings(pp, field857)
         newline(pp)
-        field845 = unwrapped_fields843[2]
-        pretty_formula(pp, field845)
+        field858 = unwrapped_fields856[2]
+        pretty_formula(pp, field858)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1724,25 +1724,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists)
 end
 
 function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce)
-    flat852 = try_flat(pp, msg, pretty_reduce)
-    if !isnothing(flat852)
-        write(pp, flat852)
+    flat865 = try_flat(pp, msg, pretty_reduce)
+    if !isnothing(flat865)
+        write(pp, flat865)
         return nothing
     else
         _dollar_dollar = msg
-        fields847 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,)
-        unwrapped_fields848 = fields847
+        fields860 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,)
+        unwrapped_fields861 = fields860
         write(pp, "(reduce")
         indent_sexp!(pp)
         newline(pp)
-        field849 = unwrapped_fields848[1]
-        pretty_abstraction(pp, field849)
+        field862 = unwrapped_fields861[1]
+        pretty_abstraction(pp, field862)
         newline(pp)
-        field850 = unwrapped_fields848[2]
-        pretty_abstraction(pp, field850)
+        field863 = unwrapped_fields861[2]
+        pretty_abstraction(pp, field863)
         newline(pp)
-        field851 = unwrapped_fields848[3]
-        pretty_terms(pp, field851)
+        field864 = unwrapped_fields861[3]
+        pretty_terms(pp, field864)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1750,22 +1750,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce)
 end
 
 function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term})
-    flat856 = try_flat(pp, msg, pretty_terms)
-    if !isnothing(flat856)
-        write(pp, flat856)
+    flat869 = try_flat(pp, msg, pretty_terms)
+    if !isnothing(flat869)
+        write(pp, flat869)
         return nothing
     else
-        fields853 = msg
+        fields866 = msg
         write(pp, "(terms")
         indent_sexp!(pp)
-        if !isempty(fields853)
+        if !isempty(fields866)
             newline(pp)
-            for (i1320, elem854) in enumerate(fields853)
-                i855 = i1320 - 1
-                if (i855 > 0)
+            for (i1346, elem867) in enumerate(fields866)
+                i868 = i1346 - 1
+                if (i868 > 0)
                     newline(pp)
                 end
-                pretty_term(pp, elem854)
+                pretty_term(pp, elem867)
             end
         end
         dedent!(pp)
@@ -1775,32 +1775,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term})
 end
 
 function pretty_term(pp::PrettyPrinter, msg::Proto.Term)
-    flat861 = try_flat(pp, msg, pretty_term)
-    if !isnothing(flat861)
-        write(pp, flat861)
+    flat874 = try_flat(pp, msg, pretty_term)
+    if !isnothing(flat874)
+        write(pp, flat874)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("var"))
-            _t1321 = _get_oneof_field(_dollar_dollar, :var)
+            _t1347 = _get_oneof_field(_dollar_dollar, :var)
         else
-            _t1321 = nothing
+            _t1347 = nothing
         end
-        deconstruct_result859 = _t1321
-        if !isnothing(deconstruct_result859)
-            unwrapped860 = deconstruct_result859
-            pretty_var(pp, unwrapped860)
+        deconstruct_result872 = _t1347
+        if !isnothing(deconstruct_result872)
+            unwrapped873 = deconstruct_result872
+            pretty_var(pp, unwrapped873)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("constant"))
-                _t1322 = _get_oneof_field(_dollar_dollar, :constant)
+                _t1348 = _get_oneof_field(_dollar_dollar, :constant)
             else
-                _t1322 = nothing
+                _t1348 = nothing
             end
-            deconstruct_result857 = _t1322
-            if !isnothing(deconstruct_result857)
-                unwrapped858 = deconstruct_result857
-                pretty_constant(pp, unwrapped858)
+            deconstruct_result870 = _t1348
+            if !isnothing(deconstruct_result870)
+                unwrapped871 = deconstruct_result870
+                pretty_constant(pp, unwrapped871)
             else
                 throw(ParseError("No matching rule for term"))
             end
@@ -1810,50 +1810,50 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term)
 end
 
 function pretty_var(pp::PrettyPrinter, msg::Proto.Var)
-    flat864 = try_flat(pp, msg, pretty_var)
-    if !isnothing(flat864)
-        write(pp, flat864)
+    flat877 = try_flat(pp, msg, pretty_var)
+    if !isnothing(flat877)
+        write(pp, flat877)
         return nothing
     else
         _dollar_dollar = msg
-        fields862 = _dollar_dollar.name
-        unwrapped_fields863 = fields862
-        write(pp, unwrapped_fields863)
+        fields875 = _dollar_dollar.name
+        unwrapped_fields876 = fields875
+        write(pp, unwrapped_fields876)
     end
     return nothing
 end
 
 function pretty_constant(pp::PrettyPrinter, msg::Proto.Value)
-    flat866 = try_flat(pp, msg, pretty_constant)
-    if !isnothing(flat866)
-        write(pp, flat866)
+    flat879 = try_flat(pp, msg, pretty_constant)
+    if !isnothing(flat879)
+        write(pp, flat879)
         return nothing
     else
-        fields865 = msg
-        pretty_value(pp, fields865)
+        fields878 = msg
+        pretty_value(pp, fields878)
     end
     return nothing
 end
 
 function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction)
-    flat871 = try_flat(pp, msg, pretty_conjunction)
-    if !isnothing(flat871)
-        write(pp, flat871)
+    flat884 = try_flat(pp, msg, pretty_conjunction)
+    if !isnothing(flat884)
+        write(pp, flat884)
         return nothing
     else
         _dollar_dollar = msg
-        fields867 = _dollar_dollar.args
-        unwrapped_fields868 = fields867
+        fields880 = _dollar_dollar.args
+        unwrapped_fields881 = fields880
         write(pp, "(and")
         indent_sexp!(pp)
-        if !isempty(unwrapped_fields868)
+        if !isempty(unwrapped_fields881)
             newline(pp)
-            for (i1323, elem869) in enumerate(unwrapped_fields868)
-                i870 = i1323 - 1
-                if (i870 > 0)
+            for (i1349, elem882) in enumerate(unwrapped_fields881)
+                i883 = i1349 - 1
+                if (i883 > 0)
                     newline(pp)
                 end
-                pretty_formula(pp, elem869)
+                pretty_formula(pp, elem882)
             end
         end
         dedent!(pp)
@@ -1863,24 +1863,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction)
 end
 
 function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction)
-    flat876 = try_flat(pp, msg, pretty_disjunction)
-    if !isnothing(flat876)
-        write(pp, flat876)
+    flat889 = try_flat(pp, msg, pretty_disjunction)
+    if !isnothing(flat889)
+        write(pp, flat889)
         return nothing
     else
         _dollar_dollar = msg
-        fields872 = _dollar_dollar.args
-        unwrapped_fields873 = fields872
+        fields885 = _dollar_dollar.args
+        unwrapped_fields886 = fields885
         write(pp, "(or")
         indent_sexp!(pp)
-        if !isempty(unwrapped_fields873)
+        if !isempty(unwrapped_fields886)
             newline(pp)
-            for (i1324, elem874) in enumerate(unwrapped_fields873)
-                i875 = i1324 - 1
-                if (i875 > 0)
+            for (i1350, elem887) in enumerate(unwrapped_fields886)
+                i888 = i1350 - 1
+                if (i888 > 0)
                     newline(pp)
                 end
-                pretty_formula(pp, elem874)
+                pretty_formula(pp, elem887)
             end
         end
         dedent!(pp)
@@ -1890,18 +1890,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction)
 end
 
 function pretty_not(pp::PrettyPrinter, msg::Proto.Not)
-    flat879 = try_flat(pp, msg, pretty_not)
-    if !isnothing(flat879)
-        write(pp, flat879)
+    flat892 = try_flat(pp, msg, pretty_not)
+    if !isnothing(flat892)
+        write(pp, flat892)
         return nothing
     else
         _dollar_dollar = msg
-        fields877 = _dollar_dollar.arg
-        unwrapped_fields878 = fields877
+        fields890 = _dollar_dollar.arg
+        unwrapped_fields891 = fields890
         write(pp, "(not")
         indent_sexp!(pp)
         newline(pp)
-        pretty_formula(pp, unwrapped_fields878)
+        pretty_formula(pp, unwrapped_fields891)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1909,25 +1909,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not)
 end
 
 function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI)
-    flat885 = try_flat(pp, msg, pretty_ffi)
-    if !isnothing(flat885)
-        write(pp, flat885)
+    flat898 = try_flat(pp, msg, pretty_ffi)
+    if !isnothing(flat898)
+        write(pp, flat898)
         return nothing
     else
         _dollar_dollar = msg
-        fields880 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,)
-        unwrapped_fields881 = fields880
+        fields893 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,)
+        unwrapped_fields894 = fields893
         write(pp, "(ffi")
         indent_sexp!(pp)
         newline(pp)
-        field882 = unwrapped_fields881[1]
-        pretty_name(pp, field882)
+        field895 = unwrapped_fields894[1]
+        pretty_name(pp, field895)
         newline(pp)
-        field883 = unwrapped_fields881[2]
-        pretty_ffi_args(pp, field883)
+        field896 = unwrapped_fields894[2]
+        pretty_ffi_args(pp, field896)
         newline(pp)
-        field884 = unwrapped_fields881[3]
-        pretty_terms(pp, field884)
+        field897 = unwrapped_fields894[3]
+        pretty_terms(pp, field897)
         dedent!(pp)
         write(pp, ")")
     end
@@ -1935,35 +1935,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI)
 end
 
 function pretty_name(pp::PrettyPrinter, msg::String)
-    flat887 = try_flat(pp, msg, pretty_name)
-    if !isnothing(flat887)
-        write(pp, flat887)
+    flat900 = try_flat(pp, msg, pretty_name)
+    if !isnothing(flat900)
+        write(pp, flat900)
         return nothing
     else
-        fields886 = msg
+        fields899 = msg
         write(pp, ":")
-        write(pp, fields886)
+        write(pp, fields899)
     end
     return nothing
 end
 
 function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction})
-    flat891 = try_flat(pp, msg, pretty_ffi_args)
-    if !isnothing(flat891)
-        write(pp, flat891)
+    flat904 = try_flat(pp, msg, pretty_ffi_args)
+    if !isnothing(flat904)
+        write(pp, flat904)
         return nothing
     else
-        fields888 = msg
+        fields901 = msg
         write(pp, "(args")
         indent_sexp!(pp)
-        if !isempty(fields888)
+        if !isempty(fields901)
             newline(pp)
-            for (i1325, elem889) in enumerate(fields888)
-                i890 = i1325 - 1
-                if (i890 > 0)
+            for (i1351, elem902) in enumerate(fields901)
+                i903 = i1351 - 1
+                if (i903 > 0)
                     newline(pp)
                 end
-                pretty_abstraction(pp, elem889)
+                pretty_abstraction(pp, elem902)
             end
         end
         dedent!(pp)
@@ -1973,28 +1973,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction})
 end
 
 function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom)
-    flat898 = try_flat(pp, msg, pretty_atom)
-    if !isnothing(flat898)
-        write(pp, flat898)
+    flat911 = try_flat(pp, msg, pretty_atom)
+    if !isnothing(flat911)
+        write(pp, flat911)
         return nothing
     else
         _dollar_dollar = msg
-        fields892 = (_dollar_dollar.name, _dollar_dollar.terms,)
-        unwrapped_fields893 = fields892
+        fields905 = (_dollar_dollar.name, _dollar_dollar.terms,)
+        unwrapped_fields906 = fields905
         write(pp, "(atom")
         indent_sexp!(pp)
         newline(pp)
-        field894 = unwrapped_fields893[1]
-        pretty_relation_id(pp, field894)
-        field895 = unwrapped_fields893[2]
-        if !isempty(field895)
+        field907 = unwrapped_fields906[1]
+        pretty_relation_id(pp, field907)
+        field908 = unwrapped_fields906[2]
+        if !isempty(field908)
             newline(pp)
-            for (i1326, elem896) in enumerate(field895)
-                i897 = i1326 - 1
-                if (i897 > 0)
+            for (i1352, elem909) in enumerate(field908)
+                i910 = i1352 - 1
+                if (i910 > 0)
                     newline(pp)
                 end
-                pretty_term(pp, elem896)
+                pretty_term(pp, elem909)
             end
         end
         dedent!(pp)
@@ -2004,28 +2004,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom)
 end
 
 function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma)
-    flat905 = try_flat(pp, msg, pretty_pragma)
-    if !isnothing(flat905)
-        write(pp, flat905)
+    flat918 = try_flat(pp, msg, pretty_pragma)
+    if !isnothing(flat918)
+        write(pp, flat918)
         return nothing
     else
         _dollar_dollar = msg
-        fields899 = (_dollar_dollar.name, _dollar_dollar.terms,)
-        unwrapped_fields900 = fields899
+        fields912 = (_dollar_dollar.name, _dollar_dollar.terms,)
+        unwrapped_fields913 = fields912
         write(pp, "(pragma")
         indent_sexp!(pp)
         newline(pp)
-        field901 = unwrapped_fields900[1]
-        pretty_name(pp, field901)
-        field902 = unwrapped_fields900[2]
-        if !isempty(field902)
+        field914 = unwrapped_fields913[1]
+        pretty_name(pp, field914)
+        field915 = unwrapped_fields913[2]
+        if !isempty(field915)
             newline(pp)
-            for (i1327, elem903) in enumerate(field902)
-                i904 = i1327 - 1
-                if (i904 > 0)
+            for (i1353, elem916) in enumerate(field915)
+                i917 = i1353 - 1
+                if (i917 > 0)
                     newline(pp)
                 end
-                pretty_term(pp, elem903)
+                pretty_term(pp, elem916)
             end
         end
         dedent!(pp)
@@ -2035,118 +2035,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma)
 end
 
 function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat921 = try_flat(pp, msg, pretty_primitive)
-    if !isnothing(flat921)
-        write(pp, flat921)
+    flat934 = try_flat(pp, msg, pretty_primitive)
+    if !isnothing(flat934)
+        write(pp, flat934)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_eq"
-            _t1328 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1354 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1328 = nothing
+            _t1354 = nothing
         end
-        guard_result920 = _t1328
-        if !isnothing(guard_result920)
+        guard_result933 = _t1354
+        if !isnothing(guard_result933)
             pretty_eq(pp, msg)
         else
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_lt_monotype"
-                _t1329 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+                _t1355 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
             else
-                _t1329 = nothing
+                _t1355 = nothing
             end
-            guard_result919 = _t1329
-            if !isnothing(guard_result919)
+            guard_result932 = _t1355
+            if !isnothing(guard_result932)
                 pretty_lt(pp, msg)
             else
                 _dollar_dollar = msg
                 if _dollar_dollar.name == "rel_primitive_lt_eq_monotype"
-                    _t1330 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+                    _t1356 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
                 else
-                    _t1330 = nothing
+                    _t1356 = nothing
                 end
-                guard_result918 = _t1330
-                if !isnothing(guard_result918)
+                guard_result931 = _t1356
+                if !isnothing(guard_result931)
                     pretty_lt_eq(pp, msg)
                 else
                     _dollar_dollar = msg
                     if _dollar_dollar.name == "rel_primitive_gt_monotype"
-                        _t1331 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+                        _t1357 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
                     else
-                        _t1331 = nothing
+                        _t1357 = nothing
                     end
-                    guard_result917 = _t1331
-                    if !isnothing(guard_result917)
+                    guard_result930 = _t1357
+                    if !isnothing(guard_result930)
                         pretty_gt(pp, msg)
                     else
                         _dollar_dollar = msg
                         if _dollar_dollar.name == "rel_primitive_gt_eq_monotype"
-                            _t1332 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+                            _t1358 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
                         else
-                            _t1332 = nothing
+                            _t1358 = nothing
                         end
-                        guard_result916 = _t1332
-                        if !isnothing(guard_result916)
+                        guard_result929 = _t1358
+                        if !isnothing(guard_result929)
                             pretty_gt_eq(pp, msg)
                         else
                             _dollar_dollar = msg
                             if _dollar_dollar.name == "rel_primitive_add_monotype"
-                                _t1333 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+                                _t1359 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
                             else
-                                _t1333 = nothing
+                                _t1359 = nothing
                             end
-                            guard_result915 = _t1333
-                            if !isnothing(guard_result915)
+                            guard_result928 = _t1359
+                            if !isnothing(guard_result928)
                                 pretty_add(pp, msg)
                             else
                                 _dollar_dollar = msg
                                 if _dollar_dollar.name == "rel_primitive_subtract_monotype"
-                                    _t1334 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+                                    _t1360 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
                                 else
-                                    _t1334 = nothing
+                                    _t1360 = nothing
                                 end
-                                guard_result914 = _t1334
-                                if !isnothing(guard_result914)
+                                guard_result927 = _t1360
+                                if !isnothing(guard_result927)
                                     pretty_minus(pp, msg)
                                 else
                                     _dollar_dollar = msg
                                     if _dollar_dollar.name == "rel_primitive_multiply_monotype"
-                                        _t1335 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+                                        _t1361 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
                                     else
-                                        _t1335 = nothing
+                                        _t1361 = nothing
                                     end
-                                    guard_result913 = _t1335
-                                    if !isnothing(guard_result913)
+                                    guard_result926 = _t1361
+                                    if !isnothing(guard_result926)
                                         pretty_multiply(pp, msg)
                                     else
                                         _dollar_dollar = msg
                                         if _dollar_dollar.name == "rel_primitive_divide_monotype"
-                                            _t1336 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+                                            _t1362 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
                                         else
-                                            _t1336 = nothing
+                                            _t1362 = nothing
                                         end
-                                        guard_result912 = _t1336
-                                        if !isnothing(guard_result912)
+                                        guard_result925 = _t1362
+                                        if !isnothing(guard_result925)
                                             pretty_divide(pp, msg)
                                         else
                                             _dollar_dollar = msg
-                                            fields906 = (_dollar_dollar.name, _dollar_dollar.terms,)
-                                            unwrapped_fields907 = fields906
+                                            fields919 = (_dollar_dollar.name, _dollar_dollar.terms,)
+                                            unwrapped_fields920 = fields919
                                             write(pp, "(primitive")
                                             indent_sexp!(pp)
                                             newline(pp)
-                                            field908 = unwrapped_fields907[1]
-                                            pretty_name(pp, field908)
-                                            field909 = unwrapped_fields907[2]
-                                            if !isempty(field909)
+                                            field921 = unwrapped_fields920[1]
+                                            pretty_name(pp, field921)
+                                            field922 = unwrapped_fields920[2]
+                                            if !isempty(field922)
                                                 newline(pp)
-                                                for (i1337, elem910) in enumerate(field909)
-                                                    i911 = i1337 - 1
-                                                    if (i911 > 0)
+                                                for (i1363, elem923) in enumerate(field922)
+                                                    i924 = i1363 - 1
+                                                    if (i924 > 0)
                                                         newline(pp)
                                                     end
-                                                    pretty_rel_term(pp, elem910)
+                                                    pretty_rel_term(pp, elem923)
                                                 end
                                             end
                                             dedent!(pp)
@@ -2165,27 +2165,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat926 = try_flat(pp, msg, pretty_eq)
-    if !isnothing(flat926)
-        write(pp, flat926)
+    flat939 = try_flat(pp, msg, pretty_eq)
+    if !isnothing(flat939)
+        write(pp, flat939)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_eq"
-            _t1338 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1364 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1338 = nothing
+            _t1364 = nothing
         end
-        fields922 = _t1338
-        unwrapped_fields923 = fields922
+        fields935 = _t1364
+        unwrapped_fields936 = fields935
         write(pp, "(=")
         indent_sexp!(pp)
         newline(pp)
-        field924 = unwrapped_fields923[1]
-        pretty_term(pp, field924)
+        field937 = unwrapped_fields936[1]
+        pretty_term(pp, field937)
         newline(pp)
-        field925 = unwrapped_fields923[2]
-        pretty_term(pp, field925)
+        field938 = unwrapped_fields936[2]
+        pretty_term(pp, field938)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2193,27 +2193,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat931 = try_flat(pp, msg, pretty_lt)
-    if !isnothing(flat931)
-        write(pp, flat931)
+    flat944 = try_flat(pp, msg, pretty_lt)
+    if !isnothing(flat944)
+        write(pp, flat944)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_lt_monotype"
-            _t1339 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1365 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1339 = nothing
+            _t1365 = nothing
         end
-        fields927 = _t1339
-        unwrapped_fields928 = fields927
+        fields940 = _t1365
+        unwrapped_fields941 = fields940
         write(pp, "(<")
         indent_sexp!(pp)
         newline(pp)
-        field929 = unwrapped_fields928[1]
-        pretty_term(pp, field929)
+        field942 = unwrapped_fields941[1]
+        pretty_term(pp, field942)
         newline(pp)
-        field930 = unwrapped_fields928[2]
-        pretty_term(pp, field930)
+        field943 = unwrapped_fields941[2]
+        pretty_term(pp, field943)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2221,27 +2221,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat936 = try_flat(pp, msg, pretty_lt_eq)
-    if !isnothing(flat936)
-        write(pp, flat936)
+    flat949 = try_flat(pp, msg, pretty_lt_eq)
+    if !isnothing(flat949)
+        write(pp, flat949)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_lt_eq_monotype"
-            _t1340 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1366 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1340 = nothing
+            _t1366 = nothing
         end
-        fields932 = _t1340
-        unwrapped_fields933 = fields932
+        fields945 = _t1366
+        unwrapped_fields946 = fields945
         write(pp, "(<=")
         indent_sexp!(pp)
         newline(pp)
-        field934 = unwrapped_fields933[1]
-        pretty_term(pp, field934)
+        field947 = unwrapped_fields946[1]
+        pretty_term(pp, field947)
         newline(pp)
-        field935 = unwrapped_fields933[2]
-        pretty_term(pp, field935)
+        field948 = unwrapped_fields946[2]
+        pretty_term(pp, field948)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2249,27 +2249,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat941 = try_flat(pp, msg, pretty_gt)
-    if !isnothing(flat941)
-        write(pp, flat941)
+    flat954 = try_flat(pp, msg, pretty_gt)
+    if !isnothing(flat954)
+        write(pp, flat954)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_gt_monotype"
-            _t1341 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1367 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1341 = nothing
+            _t1367 = nothing
         end
-        fields937 = _t1341
-        unwrapped_fields938 = fields937
+        fields950 = _t1367
+        unwrapped_fields951 = fields950
         write(pp, "(>")
         indent_sexp!(pp)
         newline(pp)
-        field939 = unwrapped_fields938[1]
-        pretty_term(pp, field939)
+        field952 = unwrapped_fields951[1]
+        pretty_term(pp, field952)
         newline(pp)
-        field940 = unwrapped_fields938[2]
-        pretty_term(pp, field940)
+        field953 = unwrapped_fields951[2]
+        pretty_term(pp, field953)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2277,27 +2277,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat946 = try_flat(pp, msg, pretty_gt_eq)
-    if !isnothing(flat946)
-        write(pp, flat946)
+    flat959 = try_flat(pp, msg, pretty_gt_eq)
+    if !isnothing(flat959)
+        write(pp, flat959)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_gt_eq_monotype"
-            _t1342 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
+            _t1368 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),)
         else
-            _t1342 = nothing
+            _t1368 = nothing
         end
-        fields942 = _t1342
-        unwrapped_fields943 = fields942
+        fields955 = _t1368
+        unwrapped_fields956 = fields955
         write(pp, "(>=")
         indent_sexp!(pp)
         newline(pp)
-        field944 = unwrapped_fields943[1]
-        pretty_term(pp, field944)
+        field957 = unwrapped_fields956[1]
+        pretty_term(pp, field957)
         newline(pp)
-        field945 = unwrapped_fields943[2]
-        pretty_term(pp, field945)
+        field958 = unwrapped_fields956[2]
+        pretty_term(pp, field958)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2305,30 +2305,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat952 = try_flat(pp, msg, pretty_add)
-    if !isnothing(flat952)
-        write(pp, flat952)
+    flat965 = try_flat(pp, msg, pretty_add)
+    if !isnothing(flat965)
+        write(pp, flat965)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_add_monotype"
-            _t1343 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+            _t1369 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
         else
-            _t1343 = nothing
+            _t1369 = nothing
         end
-        fields947 = _t1343
-        unwrapped_fields948 = fields947
+        fields960 = _t1369
+        unwrapped_fields961 = fields960
         write(pp, "(+")
         indent_sexp!(pp)
         newline(pp)
-        field949 = unwrapped_fields948[1]
-        pretty_term(pp, field949)
+        field962 = unwrapped_fields961[1]
+        pretty_term(pp, field962)
         newline(pp)
-        field950 = unwrapped_fields948[2]
-        pretty_term(pp, field950)
+        field963 = unwrapped_fields961[2]
+        pretty_term(pp, field963)
         newline(pp)
-        field951 = unwrapped_fields948[3]
-        pretty_term(pp, field951)
+        field964 = unwrapped_fields961[3]
+        pretty_term(pp, field964)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2336,30 +2336,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat958 = try_flat(pp, msg, pretty_minus)
-    if !isnothing(flat958)
-        write(pp, flat958)
+    flat971 = try_flat(pp, msg, pretty_minus)
+    if !isnothing(flat971)
+        write(pp, flat971)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_subtract_monotype"
-            _t1344 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+            _t1370 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
         else
-            _t1344 = nothing
+            _t1370 = nothing
         end
-        fields953 = _t1344
-        unwrapped_fields954 = fields953
+        fields966 = _t1370
+        unwrapped_fields967 = fields966
         write(pp, "(-")
         indent_sexp!(pp)
         newline(pp)
-        field955 = unwrapped_fields954[1]
-        pretty_term(pp, field955)
+        field968 = unwrapped_fields967[1]
+        pretty_term(pp, field968)
         newline(pp)
-        field956 = unwrapped_fields954[2]
-        pretty_term(pp, field956)
+        field969 = unwrapped_fields967[2]
+        pretty_term(pp, field969)
         newline(pp)
-        field957 = unwrapped_fields954[3]
-        pretty_term(pp, field957)
+        field970 = unwrapped_fields967[3]
+        pretty_term(pp, field970)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2367,30 +2367,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat964 = try_flat(pp, msg, pretty_multiply)
-    if !isnothing(flat964)
-        write(pp, flat964)
+    flat977 = try_flat(pp, msg, pretty_multiply)
+    if !isnothing(flat977)
+        write(pp, flat977)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_multiply_monotype"
-            _t1345 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+            _t1371 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
         else
-            _t1345 = nothing
+            _t1371 = nothing
         end
-        fields959 = _t1345
-        unwrapped_fields960 = fields959
+        fields972 = _t1371
+        unwrapped_fields973 = fields972
         write(pp, "(*")
         indent_sexp!(pp)
         newline(pp)
-        field961 = unwrapped_fields960[1]
-        pretty_term(pp, field961)
+        field974 = unwrapped_fields973[1]
+        pretty_term(pp, field974)
         newline(pp)
-        field962 = unwrapped_fields960[2]
-        pretty_term(pp, field962)
+        field975 = unwrapped_fields973[2]
+        pretty_term(pp, field975)
         newline(pp)
-        field963 = unwrapped_fields960[3]
-        pretty_term(pp, field963)
+        field976 = unwrapped_fields973[3]
+        pretty_term(pp, field976)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2398,30 +2398,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive)
-    flat970 = try_flat(pp, msg, pretty_divide)
-    if !isnothing(flat970)
-        write(pp, flat970)
+    flat983 = try_flat(pp, msg, pretty_divide)
+    if !isnothing(flat983)
+        write(pp, flat983)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name == "rel_primitive_divide_monotype"
-            _t1346 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
+            _t1372 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),)
         else
-            _t1346 = nothing
+            _t1372 = nothing
         end
-        fields965 = _t1346
-        unwrapped_fields966 = fields965
+        fields978 = _t1372
+        unwrapped_fields979 = fields978
         write(pp, "(/")
         indent_sexp!(pp)
         newline(pp)
-        field967 = unwrapped_fields966[1]
-        pretty_term(pp, field967)
+        field980 = unwrapped_fields979[1]
+        pretty_term(pp, field980)
         newline(pp)
-        field968 = unwrapped_fields966[2]
-        pretty_term(pp, field968)
+        field981 = unwrapped_fields979[2]
+        pretty_term(pp, field981)
         newline(pp)
-        field969 = unwrapped_fields966[3]
-        pretty_term(pp, field969)
+        field982 = unwrapped_fields979[3]
+        pretty_term(pp, field982)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2429,32 +2429,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive)
 end
 
 function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm)
-    flat975 = try_flat(pp, msg, pretty_rel_term)
-    if !isnothing(flat975)
-        write(pp, flat975)
+    flat988 = try_flat(pp, msg, pretty_rel_term)
+    if !isnothing(flat988)
+        write(pp, flat988)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("specialized_value"))
-            _t1347 = _get_oneof_field(_dollar_dollar, :specialized_value)
+            _t1373 = _get_oneof_field(_dollar_dollar, :specialized_value)
         else
-            _t1347 = nothing
+            _t1373 = nothing
         end
-        deconstruct_result973 = _t1347
-        if !isnothing(deconstruct_result973)
-            unwrapped974 = deconstruct_result973
-            pretty_specialized_value(pp, unwrapped974)
+        deconstruct_result986 = _t1373
+        if !isnothing(deconstruct_result986)
+            unwrapped987 = deconstruct_result986
+            pretty_specialized_value(pp, unwrapped987)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("term"))
-                _t1348 = _get_oneof_field(_dollar_dollar, :term)
+                _t1374 = _get_oneof_field(_dollar_dollar, :term)
             else
-                _t1348 = nothing
+                _t1374 = nothing
             end
-            deconstruct_result971 = _t1348
-            if !isnothing(deconstruct_result971)
-                unwrapped972 = deconstruct_result971
-                pretty_term(pp, unwrapped972)
+            deconstruct_result984 = _t1374
+            if !isnothing(deconstruct_result984)
+                unwrapped985 = deconstruct_result984
+                pretty_term(pp, unwrapped985)
             else
                 throw(ParseError("No matching rule for rel_term"))
             end
@@ -2464,41 +2464,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm)
 end
 
 function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value)
-    flat977 = try_flat(pp, msg, pretty_specialized_value)
-    if !isnothing(flat977)
-        write(pp, flat977)
+    flat990 = try_flat(pp, msg, pretty_specialized_value)
+    if !isnothing(flat990)
+        write(pp, flat990)
         return nothing
     else
-        fields976 = msg
+        fields989 = msg
         write(pp, "#")
-        pretty_value(pp, fields976)
+        pretty_value(pp, fields989)
     end
     return nothing
 end
 
 function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom)
-    flat984 = try_flat(pp, msg, pretty_rel_atom)
-    if !isnothing(flat984)
-        write(pp, flat984)
+    flat997 = try_flat(pp, msg, pretty_rel_atom)
+    if !isnothing(flat997)
+        write(pp, flat997)
         return nothing
     else
         _dollar_dollar = msg
-        fields978 = (_dollar_dollar.name, _dollar_dollar.terms,)
-        unwrapped_fields979 = fields978
+        fields991 = (_dollar_dollar.name, _dollar_dollar.terms,)
+        unwrapped_fields992 = fields991
         write(pp, "(relatom")
         indent_sexp!(pp)
         newline(pp)
-        field980 = unwrapped_fields979[1]
-        pretty_name(pp, field980)
-        field981 = unwrapped_fields979[2]
-        if !isempty(field981)
+        field993 = unwrapped_fields992[1]
+        pretty_name(pp, field993)
+        field994 = unwrapped_fields992[2]
+        if !isempty(field994)
             newline(pp)
-            for (i1349, elem982) in enumerate(field981)
-                i983 = i1349 - 1
-                if (i983 > 0)
+            for (i1375, elem995) in enumerate(field994)
+                i996 = i1375 - 1
+                if (i996 > 0)
                     newline(pp)
                 end
-                pretty_rel_term(pp, elem982)
+                pretty_rel_term(pp, elem995)
             end
         end
         dedent!(pp)
@@ -2508,22 +2508,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom)
 end
 
 function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast)
-    flat989 = try_flat(pp, msg, pretty_cast)
-    if !isnothing(flat989)
-        write(pp, flat989)
+    flat1002 = try_flat(pp, msg, pretty_cast)
+    if !isnothing(flat1002)
+        write(pp, flat1002)
         return nothing
     else
         _dollar_dollar = msg
-        fields985 = (_dollar_dollar.input, _dollar_dollar.result,)
-        unwrapped_fields986 = fields985
+        fields998 = (_dollar_dollar.input, _dollar_dollar.result,)
+        unwrapped_fields999 = fields998
         write(pp, "(cast")
         indent_sexp!(pp)
         newline(pp)
-        field987 = unwrapped_fields986[1]
-        pretty_term(pp, field987)
+        field1000 = unwrapped_fields999[1]
+        pretty_term(pp, field1000)
         newline(pp)
-        field988 = unwrapped_fields986[2]
-        pretty_term(pp, field988)
+        field1001 = unwrapped_fields999[2]
+        pretty_term(pp, field1001)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2531,22 +2531,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast)
 end
 
 function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute})
-    flat993 = try_flat(pp, msg, pretty_attrs)
-    if !isnothing(flat993)
-        write(pp, flat993)
+    flat1006 = try_flat(pp, msg, pretty_attrs)
+    if !isnothing(flat1006)
+        write(pp, flat1006)
         return nothing
     else
-        fields990 = msg
+        fields1003 = msg
         write(pp, "(attrs")
         indent_sexp!(pp)
-        if !isempty(fields990)
+        if !isempty(fields1003)
             newline(pp)
-            for (i1350, elem991) in enumerate(fields990)
-                i992 = i1350 - 1
-                if (i992 > 0)
+            for (i1376, elem1004) in enumerate(fields1003)
+                i1005 = i1376 - 1
+                if (i1005 > 0)
                     newline(pp)
                 end
-                pretty_attribute(pp, elem991)
+                pretty_attribute(pp, elem1004)
             end
         end
         dedent!(pp)
@@ -2556,28 +2556,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute})
 end
 
 function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute)
-    flat1000 = try_flat(pp, msg, pretty_attribute)
-    if !isnothing(flat1000)
-        write(pp, flat1000)
+    flat1013 = try_flat(pp, msg, pretty_attribute)
+    if !isnothing(flat1013)
+        write(pp, flat1013)
         return nothing
     else
         _dollar_dollar = msg
-        fields994 = (_dollar_dollar.name, _dollar_dollar.args,)
-        unwrapped_fields995 = fields994
+        fields1007 = (_dollar_dollar.name, _dollar_dollar.args,)
+        unwrapped_fields1008 = fields1007
         write(pp, "(attribute")
         indent_sexp!(pp)
         newline(pp)
-        field996 = unwrapped_fields995[1]
-        pretty_name(pp, field996)
-        field997 = unwrapped_fields995[2]
-        if !isempty(field997)
+        field1009 = unwrapped_fields1008[1]
+        pretty_name(pp, field1009)
+        field1010 = unwrapped_fields1008[2]
+        if !isempty(field1010)
             newline(pp)
-            for (i1351, elem998) in enumerate(field997)
-                i999 = i1351 - 1
-                if (i999 > 0)
+            for (i1377, elem1011) in enumerate(field1010)
+                i1012 = i1377 - 1
+                if (i1012 > 0)
                     newline(pp)
                 end
-                pretty_value(pp, elem998)
+                pretty_value(pp, elem1011)
             end
         end
         dedent!(pp)
@@ -2587,30 +2587,30 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute)
 end
 
 function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm)
-    flat1007 = try_flat(pp, msg, pretty_algorithm)
-    if !isnothing(flat1007)
-        write(pp, flat1007)
+    flat1020 = try_flat(pp, msg, pretty_algorithm)
+    if !isnothing(flat1020)
+        write(pp, flat1020)
         return nothing
     else
         _dollar_dollar = msg
-        fields1001 = (_dollar_dollar.var"#global", _dollar_dollar.body,)
-        unwrapped_fields1002 = fields1001
+        fields1014 = (_dollar_dollar.var"#global", _dollar_dollar.body,)
+        unwrapped_fields1015 = fields1014
         write(pp, "(algorithm")
         indent_sexp!(pp)
-        field1003 = unwrapped_fields1002[1]
-        if !isempty(field1003)
+        field1016 = unwrapped_fields1015[1]
+        if !isempty(field1016)
             newline(pp)
-            for (i1352, elem1004) in enumerate(field1003)
-                i1005 = i1352 - 1
-                if (i1005 > 0)
+            for (i1378, elem1017) in enumerate(field1016)
+                i1018 = i1378 - 1
+                if (i1018 > 0)
                     newline(pp)
                 end
-                pretty_relation_id(pp, elem1004)
+                pretty_relation_id(pp, elem1017)
             end
         end
         newline(pp)
-        field1006 = unwrapped_fields1002[2]
-        pretty_script(pp, field1006)
+        field1019 = unwrapped_fields1015[2]
+        pretty_script(pp, field1019)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2618,24 +2618,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm)
 end
 
 function pretty_script(pp::PrettyPrinter, msg::Proto.Script)
-    flat1012 = try_flat(pp, msg, pretty_script)
-    if !isnothing(flat1012)
-        write(pp, flat1012)
+    flat1025 = try_flat(pp, msg, pretty_script)
+    if !isnothing(flat1025)
+        write(pp, flat1025)
         return nothing
     else
         _dollar_dollar = msg
-        fields1008 = _dollar_dollar.constructs
-        unwrapped_fields1009 = fields1008
+        fields1021 = _dollar_dollar.constructs
+        unwrapped_fields1022 = fields1021
         write(pp, "(script")
         indent_sexp!(pp)
-        if !isempty(unwrapped_fields1009)
+        if !isempty(unwrapped_fields1022)
             newline(pp)
-            for (i1353, elem1010) in enumerate(unwrapped_fields1009)
-                i1011 = i1353 - 1
-                if (i1011 > 0)
+            for (i1379, elem1023) in enumerate(unwrapped_fields1022)
+                i1024 = i1379 - 1
+                if (i1024 > 0)
                     newline(pp)
                 end
-                pretty_construct(pp, elem1010)
+                pretty_construct(pp, elem1023)
             end
         end
         dedent!(pp)
@@ -2645,32 +2645,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script)
 end
 
 function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct)
-    flat1017 = try_flat(pp, msg, pretty_construct)
-    if !isnothing(flat1017)
-        write(pp, flat1017)
+    flat1030 = try_flat(pp, msg, pretty_construct)
+    if !isnothing(flat1030)
+        write(pp, flat1030)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("loop"))
-            _t1354 = _get_oneof_field(_dollar_dollar, :loop)
+            _t1380 = _get_oneof_field(_dollar_dollar, :loop)
         else
-            _t1354 = nothing
+            _t1380 = nothing
         end
-        deconstruct_result1015 = _t1354
-        if !isnothing(deconstruct_result1015)
-            unwrapped1016 = deconstruct_result1015
-            pretty_loop(pp, unwrapped1016)
+        deconstruct_result1028 = _t1380
+        if !isnothing(deconstruct_result1028)
+            unwrapped1029 = deconstruct_result1028
+            pretty_loop(pp, unwrapped1029)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("instruction"))
-                _t1355 = _get_oneof_field(_dollar_dollar, :instruction)
+                _t1381 = _get_oneof_field(_dollar_dollar, :instruction)
             else
-                _t1355 = nothing
+                _t1381 = nothing
             end
-            deconstruct_result1013 = _t1355
-            if !isnothing(deconstruct_result1013)
-                unwrapped1014 = deconstruct_result1013
-                pretty_instruction(pp, unwrapped1014)
+            deconstruct_result1026 = _t1381
+            if !isnothing(deconstruct_result1026)
+                unwrapped1027 = deconstruct_result1026
+                pretty_instruction(pp, unwrapped1027)
             else
                 throw(ParseError("No matching rule for construct"))
             end
@@ -2680,22 +2680,22 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct)
 end
 
 function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop)
-    flat1022 = try_flat(pp, msg, pretty_loop)
-    if !isnothing(flat1022)
-        write(pp, flat1022)
+    flat1035 = try_flat(pp, msg, pretty_loop)
+    if !isnothing(flat1035)
+        write(pp, flat1035)
         return nothing
     else
         _dollar_dollar = msg
-        fields1018 = (_dollar_dollar.init, _dollar_dollar.body,)
-        unwrapped_fields1019 = fields1018
+        fields1031 = (_dollar_dollar.init, _dollar_dollar.body,)
+        unwrapped_fields1032 = fields1031
         write(pp, "(loop")
         indent_sexp!(pp)
         newline(pp)
-        field1020 = unwrapped_fields1019[1]
-        pretty_init(pp, field1020)
+        field1033 = unwrapped_fields1032[1]
+        pretty_init(pp, field1033)
         newline(pp)
-        field1021 = unwrapped_fields1019[2]
-        pretty_script(pp, field1021)
+        field1034 = unwrapped_fields1032[2]
+        pretty_script(pp, field1034)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2703,22 +2703,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop)
 end
 
 function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction})
-    flat1026 = try_flat(pp, msg, pretty_init)
-    if !isnothing(flat1026)
-        write(pp, flat1026)
+    flat1039 = try_flat(pp, msg, pretty_init)
+    if !isnothing(flat1039)
+        write(pp, flat1039)
         return nothing
     else
-        fields1023 = msg
+        fields1036 = msg
         write(pp, "(init")
         indent_sexp!(pp)
-        if !isempty(fields1023)
+        if !isempty(fields1036)
             newline(pp)
-            for (i1356, elem1024) in enumerate(fields1023)
-                i1025 = i1356 - 1
-                if (i1025 > 0)
+            for (i1382, elem1037) in enumerate(fields1036)
+                i1038 = i1382 - 1
+                if (i1038 > 0)
                     newline(pp)
                 end
-                pretty_instruction(pp, elem1024)
+                pretty_instruction(pp, elem1037)
             end
         end
         dedent!(pp)
@@ -2728,65 +2728,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction})
 end
 
 function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction)
-    flat1037 = try_flat(pp, msg, pretty_instruction)
-    if !isnothing(flat1037)
-        write(pp, flat1037)
+    flat1050 = try_flat(pp, msg, pretty_instruction)
+    if !isnothing(flat1050)
+        write(pp, flat1050)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("assign"))
-            _t1357 = _get_oneof_field(_dollar_dollar, :assign)
+            _t1383 = _get_oneof_field(_dollar_dollar, :assign)
         else
-            _t1357 = nothing
+            _t1383 = nothing
         end
-        deconstruct_result1035 = _t1357
-        if !isnothing(deconstruct_result1035)
-            unwrapped1036 = deconstruct_result1035
-            pretty_assign(pp, unwrapped1036)
+        deconstruct_result1048 = _t1383
+        if !isnothing(deconstruct_result1048)
+            unwrapped1049 = deconstruct_result1048
+            pretty_assign(pp, unwrapped1049)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("upsert"))
-                _t1358 = _get_oneof_field(_dollar_dollar, :upsert)
+                _t1384 = _get_oneof_field(_dollar_dollar, :upsert)
             else
-                _t1358 = nothing
+                _t1384 = nothing
             end
-            deconstruct_result1033 = _t1358
-            if !isnothing(deconstruct_result1033)
-                unwrapped1034 = deconstruct_result1033
-                pretty_upsert(pp, unwrapped1034)
+            deconstruct_result1046 = _t1384
+            if !isnothing(deconstruct_result1046)
+                unwrapped1047 = deconstruct_result1046
+                pretty_upsert(pp, unwrapped1047)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("#break"))
-                    _t1359 = _get_oneof_field(_dollar_dollar, :var"#break")
+                    _t1385 = _get_oneof_field(_dollar_dollar, :var"#break")
                 else
-                    _t1359 = nothing
+                    _t1385 = nothing
                 end
-                deconstruct_result1031 = _t1359
-                if !isnothing(deconstruct_result1031)
-                    unwrapped1032 = deconstruct_result1031
-                    pretty_break(pp, unwrapped1032)
+                deconstruct_result1044 = _t1385
+                if !isnothing(deconstruct_result1044)
+                    unwrapped1045 = deconstruct_result1044
+                    pretty_break(pp, unwrapped1045)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("monoid_def"))
-                        _t1360 = _get_oneof_field(_dollar_dollar, :monoid_def)
+                        _t1386 = _get_oneof_field(_dollar_dollar, :monoid_def)
                     else
-                        _t1360 = nothing
+                        _t1386 = nothing
                     end
-                    deconstruct_result1029 = _t1360
-                    if !isnothing(deconstruct_result1029)
-                        unwrapped1030 = deconstruct_result1029
-                        pretty_monoid_def(pp, unwrapped1030)
+                    deconstruct_result1042 = _t1386
+                    if !isnothing(deconstruct_result1042)
+                        unwrapped1043 = deconstruct_result1042
+                        pretty_monoid_def(pp, unwrapped1043)
                     else
                         _dollar_dollar = msg
                         if _has_proto_field(_dollar_dollar, Symbol("monus_def"))
-                            _t1361 = _get_oneof_field(_dollar_dollar, :monus_def)
+                            _t1387 = _get_oneof_field(_dollar_dollar, :monus_def)
                         else
-                            _t1361 = nothing
+                            _t1387 = nothing
                         end
-                        deconstruct_result1027 = _t1361
-                        if !isnothing(deconstruct_result1027)
-                            unwrapped1028 = deconstruct_result1027
-                            pretty_monus_def(pp, unwrapped1028)
+                        deconstruct_result1040 = _t1387
+                        if !isnothing(deconstruct_result1040)
+                            unwrapped1041 = deconstruct_result1040
+                            pretty_monus_def(pp, unwrapped1041)
                         else
                             throw(ParseError("No matching rule for instruction"))
                         end
@@ -2799,32 +2799,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction)
 end
 
 function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign)
-    flat1044 = try_flat(pp, msg, pretty_assign)
-    if !isnothing(flat1044)
-        write(pp, flat1044)
+    flat1057 = try_flat(pp, msg, pretty_assign)
+    if !isnothing(flat1057)
+        write(pp, flat1057)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1362 = _dollar_dollar.attrs
+            _t1388 = _dollar_dollar.attrs
         else
-            _t1362 = nothing
+            _t1388 = nothing
         end
-        fields1038 = (_dollar_dollar.name, _dollar_dollar.body, _t1362,)
-        unwrapped_fields1039 = fields1038
+        fields1051 = (_dollar_dollar.name, _dollar_dollar.body, _t1388,)
+        unwrapped_fields1052 = fields1051
         write(pp, "(assign")
         indent_sexp!(pp)
         newline(pp)
-        field1040 = unwrapped_fields1039[1]
-        pretty_relation_id(pp, field1040)
+        field1053 = unwrapped_fields1052[1]
+        pretty_relation_id(pp, field1053)
         newline(pp)
-        field1041 = unwrapped_fields1039[2]
-        pretty_abstraction(pp, field1041)
-        field1042 = unwrapped_fields1039[3]
-        if !isnothing(field1042)
+        field1054 = unwrapped_fields1052[2]
+        pretty_abstraction(pp, field1054)
+        field1055 = unwrapped_fields1052[3]
+        if !isnothing(field1055)
             newline(pp)
-            opt_val1043 = field1042
-            pretty_attrs(pp, opt_val1043)
+            opt_val1056 = field1055
+            pretty_attrs(pp, opt_val1056)
         end
         dedent!(pp)
         write(pp, ")")
@@ -2833,32 +2833,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign)
 end
 
 function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert)
-    flat1051 = try_flat(pp, msg, pretty_upsert)
-    if !isnothing(flat1051)
-        write(pp, flat1051)
+    flat1064 = try_flat(pp, msg, pretty_upsert)
+    if !isnothing(flat1064)
+        write(pp, flat1064)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1363 = _dollar_dollar.attrs
+            _t1389 = _dollar_dollar.attrs
         else
-            _t1363 = nothing
+            _t1389 = nothing
         end
-        fields1045 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1363,)
-        unwrapped_fields1046 = fields1045
+        fields1058 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1389,)
+        unwrapped_fields1059 = fields1058
         write(pp, "(upsert")
         indent_sexp!(pp)
         newline(pp)
-        field1047 = unwrapped_fields1046[1]
-        pretty_relation_id(pp, field1047)
+        field1060 = unwrapped_fields1059[1]
+        pretty_relation_id(pp, field1060)
         newline(pp)
-        field1048 = unwrapped_fields1046[2]
-        pretty_abstraction_with_arity(pp, field1048)
-        field1049 = unwrapped_fields1046[3]
-        if !isnothing(field1049)
+        field1061 = unwrapped_fields1059[2]
+        pretty_abstraction_with_arity(pp, field1061)
+        field1062 = unwrapped_fields1059[3]
+        if !isnothing(field1062)
             newline(pp)
-            opt_val1050 = field1049
-            pretty_attrs(pp, opt_val1050)
+            opt_val1063 = field1062
+            pretty_attrs(pp, opt_val1063)
         end
         dedent!(pp)
         write(pp, ")")
@@ -2867,22 +2867,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert)
 end
 
 function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64})
-    flat1056 = try_flat(pp, msg, pretty_abstraction_with_arity)
-    if !isnothing(flat1056)
-        write(pp, flat1056)
+    flat1069 = try_flat(pp, msg, pretty_abstraction_with_arity)
+    if !isnothing(flat1069)
+        write(pp, flat1069)
         return nothing
     else
         _dollar_dollar = msg
-        _t1364 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2])
-        fields1052 = (_t1364, _dollar_dollar[1].value,)
-        unwrapped_fields1053 = fields1052
+        _t1390 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2])
+        fields1065 = (_t1390, _dollar_dollar[1].value,)
+        unwrapped_fields1066 = fields1065
         write(pp, "(")
         indent!(pp)
-        field1054 = unwrapped_fields1053[1]
-        pretty_bindings(pp, field1054)
+        field1067 = unwrapped_fields1066[1]
+        pretty_bindings(pp, field1067)
         newline(pp)
-        field1055 = unwrapped_fields1053[2]
-        pretty_formula(pp, field1055)
+        field1068 = unwrapped_fields1066[2]
+        pretty_formula(pp, field1068)
         dedent!(pp)
         write(pp, ")")
     end
@@ -2890,32 +2890,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr
 end
 
 function pretty_break(pp::PrettyPrinter, msg::Proto.Break)
-    flat1063 = try_flat(pp, msg, pretty_break)
-    if !isnothing(flat1063)
-        write(pp, flat1063)
+    flat1076 = try_flat(pp, msg, pretty_break)
+    if !isnothing(flat1076)
+        write(pp, flat1076)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1365 = _dollar_dollar.attrs
+            _t1391 = _dollar_dollar.attrs
         else
-            _t1365 = nothing
+            _t1391 = nothing
         end
-        fields1057 = (_dollar_dollar.name, _dollar_dollar.body, _t1365,)
-        unwrapped_fields1058 = fields1057
+        fields1070 = (_dollar_dollar.name, _dollar_dollar.body, _t1391,)
+        unwrapped_fields1071 = fields1070
         write(pp, "(break")
         indent_sexp!(pp)
         newline(pp)
-        field1059 = unwrapped_fields1058[1]
-        pretty_relation_id(pp, field1059)
+        field1072 = unwrapped_fields1071[1]
+        pretty_relation_id(pp, field1072)
         newline(pp)
-        field1060 = unwrapped_fields1058[2]
-        pretty_abstraction(pp, field1060)
-        field1061 = unwrapped_fields1058[3]
-        if !isnothing(field1061)
+        field1073 = unwrapped_fields1071[2]
+        pretty_abstraction(pp, field1073)
+        field1074 = unwrapped_fields1071[3]
+        if !isnothing(field1074)
             newline(pp)
-            opt_val1062 = field1061
-            pretty_attrs(pp, opt_val1062)
+            opt_val1075 = field1074
+            pretty_attrs(pp, opt_val1075)
         end
         dedent!(pp)
         write(pp, ")")
@@ -2924,35 +2924,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break)
 end
 
 function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef)
-    flat1071 = try_flat(pp, msg, pretty_monoid_def)
-    if !isnothing(flat1071)
-        write(pp, flat1071)
+    flat1084 = try_flat(pp, msg, pretty_monoid_def)
+    if !isnothing(flat1084)
+        write(pp, flat1084)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1366 = _dollar_dollar.attrs
+            _t1392 = _dollar_dollar.attrs
         else
-            _t1366 = nothing
+            _t1392 = nothing
         end
-        fields1064 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1366,)
-        unwrapped_fields1065 = fields1064
+        fields1077 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1392,)
+        unwrapped_fields1078 = fields1077
         write(pp, "(monoid")
         indent_sexp!(pp)
         newline(pp)
-        field1066 = unwrapped_fields1065[1]
-        pretty_monoid(pp, field1066)
+        field1079 = unwrapped_fields1078[1]
+        pretty_monoid(pp, field1079)
         newline(pp)
-        field1067 = unwrapped_fields1065[2]
-        pretty_relation_id(pp, field1067)
+        field1080 = unwrapped_fields1078[2]
+        pretty_relation_id(pp, field1080)
         newline(pp)
-        field1068 = unwrapped_fields1065[3]
-        pretty_abstraction_with_arity(pp, field1068)
-        field1069 = unwrapped_fields1065[4]
-        if !isnothing(field1069)
+        field1081 = unwrapped_fields1078[3]
+        pretty_abstraction_with_arity(pp, field1081)
+        field1082 = unwrapped_fields1078[4]
+        if !isnothing(field1082)
             newline(pp)
-            opt_val1070 = field1069
-            pretty_attrs(pp, opt_val1070)
+            opt_val1083 = field1082
+            pretty_attrs(pp, opt_val1083)
         end
         dedent!(pp)
         write(pp, ")")
@@ -2961,54 +2961,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef)
 end
 
 function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid)
-    flat1080 = try_flat(pp, msg, pretty_monoid)
-    if !isnothing(flat1080)
-        write(pp, flat1080)
+    flat1093 = try_flat(pp, msg, pretty_monoid)
+    if !isnothing(flat1093)
+        write(pp, flat1093)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("or_monoid"))
-            _t1367 = _get_oneof_field(_dollar_dollar, :or_monoid)
+            _t1393 = _get_oneof_field(_dollar_dollar, :or_monoid)
         else
-            _t1367 = nothing
+            _t1393 = nothing
         end
-        deconstruct_result1078 = _t1367
-        if !isnothing(deconstruct_result1078)
-            unwrapped1079 = deconstruct_result1078
-            pretty_or_monoid(pp, unwrapped1079)
+        deconstruct_result1091 = _t1393
+        if !isnothing(deconstruct_result1091)
+            unwrapped1092 = deconstruct_result1091
+            pretty_or_monoid(pp, unwrapped1092)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("min_monoid"))
-                _t1368 = _get_oneof_field(_dollar_dollar, :min_monoid)
+                _t1394 = _get_oneof_field(_dollar_dollar, :min_monoid)
             else
-                _t1368 = nothing
+                _t1394 = nothing
             end
-            deconstruct_result1076 = _t1368
-            if !isnothing(deconstruct_result1076)
-                unwrapped1077 = deconstruct_result1076
-                pretty_min_monoid(pp, unwrapped1077)
+            deconstruct_result1089 = _t1394
+            if !isnothing(deconstruct_result1089)
+                unwrapped1090 = deconstruct_result1089
+                pretty_min_monoid(pp, unwrapped1090)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("max_monoid"))
-                    _t1369 = _get_oneof_field(_dollar_dollar, :max_monoid)
+                    _t1395 = _get_oneof_field(_dollar_dollar, :max_monoid)
                 else
-                    _t1369 = nothing
+                    _t1395 = nothing
                 end
-                deconstruct_result1074 = _t1369
-                if !isnothing(deconstruct_result1074)
-                    unwrapped1075 = deconstruct_result1074
-                    pretty_max_monoid(pp, unwrapped1075)
+                deconstruct_result1087 = _t1395
+                if !isnothing(deconstruct_result1087)
+                    unwrapped1088 = deconstruct_result1087
+                    pretty_max_monoid(pp, unwrapped1088)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("sum_monoid"))
-                        _t1370 = _get_oneof_field(_dollar_dollar, :sum_monoid)
+                        _t1396 = _get_oneof_field(_dollar_dollar, :sum_monoid)
                     else
-                        _t1370 = nothing
+                        _t1396 = nothing
                     end
-                    deconstruct_result1072 = _t1370
-                    if !isnothing(deconstruct_result1072)
-                        unwrapped1073 = deconstruct_result1072
-                        pretty_sum_monoid(pp, unwrapped1073)
+                    deconstruct_result1085 = _t1396
+                    if !isnothing(deconstruct_result1085)
+                        unwrapped1086 = deconstruct_result1085
+                        pretty_sum_monoid(pp, unwrapped1086)
                     else
                         throw(ParseError("No matching rule for monoid"))
                     end
@@ -3020,24 +3020,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid)
 end
 
 function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid)
-    fields1081 = msg
+    fields1094 = msg
     write(pp, "(or)")
     return nothing
 end
 
 function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid)
-    flat1084 = try_flat(pp, msg, pretty_min_monoid)
-    if !isnothing(flat1084)
-        write(pp, flat1084)
+    flat1097 = try_flat(pp, msg, pretty_min_monoid)
+    if !isnothing(flat1097)
+        write(pp, flat1097)
         return nothing
     else
         _dollar_dollar = msg
-        fields1082 = _dollar_dollar.var"#type"
-        unwrapped_fields1083 = fields1082
+        fields1095 = _dollar_dollar.var"#type"
+        unwrapped_fields1096 = fields1095
         write(pp, "(min")
         indent_sexp!(pp)
         newline(pp)
-        pretty_type(pp, unwrapped_fields1083)
+        pretty_type(pp, unwrapped_fields1096)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3045,18 +3045,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid)
 end
 
 function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid)
-    flat1087 = try_flat(pp, msg, pretty_max_monoid)
-    if !isnothing(flat1087)
-        write(pp, flat1087)
+    flat1100 = try_flat(pp, msg, pretty_max_monoid)
+    if !isnothing(flat1100)
+        write(pp, flat1100)
         return nothing
     else
         _dollar_dollar = msg
-        fields1085 = _dollar_dollar.var"#type"
-        unwrapped_fields1086 = fields1085
+        fields1098 = _dollar_dollar.var"#type"
+        unwrapped_fields1099 = fields1098
         write(pp, "(max")
         indent_sexp!(pp)
         newline(pp)
-        pretty_type(pp, unwrapped_fields1086)
+        pretty_type(pp, unwrapped_fields1099)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3064,18 +3064,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid)
 end
 
 function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid)
-    flat1090 = try_flat(pp, msg, pretty_sum_monoid)
-    if !isnothing(flat1090)
-        write(pp, flat1090)
+    flat1103 = try_flat(pp, msg, pretty_sum_monoid)
+    if !isnothing(flat1103)
+        write(pp, flat1103)
         return nothing
     else
         _dollar_dollar = msg
-        fields1088 = _dollar_dollar.var"#type"
-        unwrapped_fields1089 = fields1088
+        fields1101 = _dollar_dollar.var"#type"
+        unwrapped_fields1102 = fields1101
         write(pp, "(sum")
         indent_sexp!(pp)
         newline(pp)
-        pretty_type(pp, unwrapped_fields1089)
+        pretty_type(pp, unwrapped_fields1102)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3083,35 +3083,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid)
 end
 
 function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef)
-    flat1098 = try_flat(pp, msg, pretty_monus_def)
-    if !isnothing(flat1098)
-        write(pp, flat1098)
+    flat1111 = try_flat(pp, msg, pretty_monus_def)
+    if !isnothing(flat1111)
+        write(pp, flat1111)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.attrs)
-            _t1371 = _dollar_dollar.attrs
+            _t1397 = _dollar_dollar.attrs
         else
-            _t1371 = nothing
+            _t1397 = nothing
         end
-        fields1091 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1371,)
-        unwrapped_fields1092 = fields1091
+        fields1104 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1397,)
+        unwrapped_fields1105 = fields1104
         write(pp, "(monus")
         indent_sexp!(pp)
         newline(pp)
-        field1093 = unwrapped_fields1092[1]
-        pretty_monoid(pp, field1093)
+        field1106 = unwrapped_fields1105[1]
+        pretty_monoid(pp, field1106)
         newline(pp)
-        field1094 = unwrapped_fields1092[2]
-        pretty_relation_id(pp, field1094)
+        field1107 = unwrapped_fields1105[2]
+        pretty_relation_id(pp, field1107)
         newline(pp)
-        field1095 = unwrapped_fields1092[3]
-        pretty_abstraction_with_arity(pp, field1095)
-        field1096 = unwrapped_fields1092[4]
-        if !isnothing(field1096)
+        field1108 = unwrapped_fields1105[3]
+        pretty_abstraction_with_arity(pp, field1108)
+        field1109 = unwrapped_fields1105[4]
+        if !isnothing(field1109)
             newline(pp)
-            opt_val1097 = field1096
-            pretty_attrs(pp, opt_val1097)
+            opt_val1110 = field1109
+            pretty_attrs(pp, opt_val1110)
         end
         dedent!(pp)
         write(pp, ")")
@@ -3120,28 +3120,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef)
 end
 
 function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint)
-    flat1105 = try_flat(pp, msg, pretty_constraint)
-    if !isnothing(flat1105)
-        write(pp, flat1105)
+    flat1118 = try_flat(pp, msg, pretty_constraint)
+    if !isnothing(flat1118)
+        write(pp, flat1118)
         return nothing
     else
         _dollar_dollar = msg
-        fields1099 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,)
-        unwrapped_fields1100 = fields1099
+        fields1112 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,)
+        unwrapped_fields1113 = fields1112
         write(pp, "(functional_dependency")
         indent_sexp!(pp)
         newline(pp)
-        field1101 = unwrapped_fields1100[1]
-        pretty_relation_id(pp, field1101)
+        field1114 = unwrapped_fields1113[1]
+        pretty_relation_id(pp, field1114)
         newline(pp)
-        field1102 = unwrapped_fields1100[2]
-        pretty_abstraction(pp, field1102)
+        field1115 = unwrapped_fields1113[2]
+        pretty_abstraction(pp, field1115)
         newline(pp)
-        field1103 = unwrapped_fields1100[3]
-        pretty_functional_dependency_keys(pp, field1103)
+        field1116 = unwrapped_fields1113[3]
+        pretty_functional_dependency_keys(pp, field1116)
         newline(pp)
-        field1104 = unwrapped_fields1100[4]
-        pretty_functional_dependency_values(pp, field1104)
+        field1117 = unwrapped_fields1113[4]
+        pretty_functional_dependency_values(pp, field1117)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3149,22 +3149,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint)
 end
 
 function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var})
-    flat1109 = try_flat(pp, msg, pretty_functional_dependency_keys)
-    if !isnothing(flat1109)
-        write(pp, flat1109)
+    flat1122 = try_flat(pp, msg, pretty_functional_dependency_keys)
+    if !isnothing(flat1122)
+        write(pp, flat1122)
         return nothing
     else
-        fields1106 = msg
+        fields1119 = msg
         write(pp, "(keys")
         indent_sexp!(pp)
-        if !isempty(fields1106)
+        if !isempty(fields1119)
             newline(pp)
-            for (i1372, elem1107) in enumerate(fields1106)
-                i1108 = i1372 - 1
-                if (i1108 > 0)
+            for (i1398, elem1120) in enumerate(fields1119)
+                i1121 = i1398 - 1
+                if (i1121 > 0)
                     newline(pp)
                 end
-                pretty_var(pp, elem1107)
+                pretty_var(pp, elem1120)
             end
         end
         dedent!(pp)
@@ -3174,22 +3174,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.
 end
 
 function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var})
-    flat1113 = try_flat(pp, msg, pretty_functional_dependency_values)
-    if !isnothing(flat1113)
-        write(pp, flat1113)
+    flat1126 = try_flat(pp, msg, pretty_functional_dependency_values)
+    if !isnothing(flat1126)
+        write(pp, flat1126)
         return nothing
     else
-        fields1110 = msg
+        fields1123 = msg
         write(pp, "(values")
         indent_sexp!(pp)
-        if !isempty(fields1110)
+        if !isempty(fields1123)
             newline(pp)
-            for (i1373, elem1111) in enumerate(fields1110)
-                i1112 = i1373 - 1
-                if (i1112 > 0)
+            for (i1399, elem1124) in enumerate(fields1123)
+                i1125 = i1399 - 1
+                if (i1125 > 0)
                     newline(pp)
                 end
-                pretty_var(pp, elem1111)
+                pretty_var(pp, elem1124)
             end
         end
         dedent!(pp)
@@ -3199,43 +3199,43 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot
 end
 
 function pretty_data(pp::PrettyPrinter, msg::Proto.Data)
-    flat1120 = try_flat(pp, msg, pretty_data)
-    if !isnothing(flat1120)
-        write(pp, flat1120)
+    flat1133 = try_flat(pp, msg, pretty_data)
+    if !isnothing(flat1133)
+        write(pp, flat1133)
         return nothing
     else
         _dollar_dollar = msg
-        if _has_proto_field(_dollar_dollar, Symbol("rel_edb"))
-            _t1374 = _get_oneof_field(_dollar_dollar, :rel_edb)
+        if _has_proto_field(_dollar_dollar, Symbol("edb"))
+            _t1400 = _get_oneof_field(_dollar_dollar, :edb)
         else
-            _t1374 = nothing
+            _t1400 = nothing
         end
-        deconstruct_result1118 = _t1374
-        if !isnothing(deconstruct_result1118)
-            unwrapped1119 = deconstruct_result1118
-            pretty_rel_edb(pp, unwrapped1119)
+        deconstruct_result1131 = _t1400
+        if !isnothing(deconstruct_result1131)
+            unwrapped1132 = deconstruct_result1131
+            pretty_edb(pp, unwrapped1132)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("betree_relation"))
-                _t1375 = _get_oneof_field(_dollar_dollar, :betree_relation)
+                _t1401 = _get_oneof_field(_dollar_dollar, :betree_relation)
             else
-                _t1375 = nothing
+                _t1401 = nothing
             end
-            deconstruct_result1116 = _t1375
-            if !isnothing(deconstruct_result1116)
-                unwrapped1117 = deconstruct_result1116
-                pretty_betree_relation(pp, unwrapped1117)
+            deconstruct_result1129 = _t1401
+            if !isnothing(deconstruct_result1129)
+                unwrapped1130 = deconstruct_result1129
+                pretty_betree_relation(pp, unwrapped1130)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("csv_data"))
-                    _t1376 = _get_oneof_field(_dollar_dollar, :csv_data)
+                    _t1402 = _get_oneof_field(_dollar_dollar, :csv_data)
                 else
-                    _t1376 = nothing
+                    _t1402 = nothing
                 end
-                deconstruct_result1114 = _t1376
-                if !isnothing(deconstruct_result1114)
-                    unwrapped1115 = deconstruct_result1114
-                    pretty_csv_data(pp, unwrapped1115)
+                deconstruct_result1127 = _t1402
+                if !isnothing(deconstruct_result1127)
+                    unwrapped1128 = deconstruct_result1127
+                    pretty_csv_data(pp, unwrapped1128)
                 else
                     throw(ParseError("No matching rule for data"))
                 end
@@ -3245,47 +3245,47 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data)
     return nothing
 end
 
-function pretty_rel_edb(pp::PrettyPrinter, msg::Proto.RelEDB)
-    flat1126 = try_flat(pp, msg, pretty_rel_edb)
-    if !isnothing(flat1126)
-        write(pp, flat1126)
+function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB)
+    flat1139 = try_flat(pp, msg, pretty_edb)
+    if !isnothing(flat1139)
+        write(pp, flat1139)
         return nothing
     else
         _dollar_dollar = msg
-        fields1121 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,)
-        unwrapped_fields1122 = fields1121
-        write(pp, "(rel_edb")
+        fields1134 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,)
+        unwrapped_fields1135 = fields1134
+        write(pp, "(edb")
         indent_sexp!(pp)
         newline(pp)
-        field1123 = unwrapped_fields1122[1]
-        pretty_relation_id(pp, field1123)
+        field1136 = unwrapped_fields1135[1]
+        pretty_relation_id(pp, field1136)
         newline(pp)
-        field1124 = unwrapped_fields1122[2]
-        pretty_rel_edb_path(pp, field1124)
+        field1137 = unwrapped_fields1135[2]
+        pretty_edb_path(pp, field1137)
         newline(pp)
-        field1125 = unwrapped_fields1122[3]
-        pretty_rel_edb_types(pp, field1125)
+        field1138 = unwrapped_fields1135[3]
+        pretty_edb_types(pp, field1138)
         dedent!(pp)
         write(pp, ")")
     end
     return nothing
 end
 
-function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String})
-    flat1130 = try_flat(pp, msg, pretty_rel_edb_path)
-    if !isnothing(flat1130)
-        write(pp, flat1130)
+function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String})
+    flat1143 = try_flat(pp, msg, pretty_edb_path)
+    if !isnothing(flat1143)
+        write(pp, flat1143)
         return nothing
     else
-        fields1127 = msg
+        fields1140 = msg
         write(pp, "[")
         indent!(pp)
-        for (i1377, elem1128) in enumerate(fields1127)
-            i1129 = i1377 - 1
-            if (i1129 > 0)
+        for (i1403, elem1141) in enumerate(fields1140)
+            i1142 = i1403 - 1
+            if (i1142 > 0)
                 newline(pp)
             end
-            write(pp, format_string(pp, elem1128))
+            write(pp, format_string(pp, elem1141))
         end
         dedent!(pp)
         write(pp, "]")
@@ -3293,21 +3293,21 @@ function pretty_rel_edb_path(pp::PrettyPrinter, msg::Vector{String})
     return nothing
 end
 
-function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"})
-    flat1134 = try_flat(pp, msg, pretty_rel_edb_types)
-    if !isnothing(flat1134)
-        write(pp, flat1134)
+function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"})
+    flat1147 = try_flat(pp, msg, pretty_edb_types)
+    if !isnothing(flat1147)
+        write(pp, flat1147)
         return nothing
     else
-        fields1131 = msg
+        fields1144 = msg
         write(pp, "[")
         indent!(pp)
-        for (i1378, elem1132) in enumerate(fields1131)
-            i1133 = i1378 - 1
-            if (i1133 > 0)
+        for (i1404, elem1145) in enumerate(fields1144)
+            i1146 = i1404 - 1
+            if (i1146 > 0)
                 newline(pp)
             end
-            pretty_type(pp, elem1132)
+            pretty_type(pp, elem1145)
         end
         dedent!(pp)
         write(pp, "]")
@@ -3316,22 +3316,22 @@ function pretty_rel_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"})
 end
 
 function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation)
-    flat1139 = try_flat(pp, msg, pretty_betree_relation)
-    if !isnothing(flat1139)
-        write(pp, flat1139)
+    flat1152 = try_flat(pp, msg, pretty_betree_relation)
+    if !isnothing(flat1152)
+        write(pp, flat1152)
         return nothing
     else
         _dollar_dollar = msg
-        fields1135 = (_dollar_dollar.name, _dollar_dollar.relation_info,)
-        unwrapped_fields1136 = fields1135
+        fields1148 = (_dollar_dollar.name, _dollar_dollar.relation_info,)
+        unwrapped_fields1149 = fields1148
         write(pp, "(betree_relation")
         indent_sexp!(pp)
         newline(pp)
-        field1137 = unwrapped_fields1136[1]
-        pretty_relation_id(pp, field1137)
+        field1150 = unwrapped_fields1149[1]
+        pretty_relation_id(pp, field1150)
         newline(pp)
-        field1138 = unwrapped_fields1136[2]
-        pretty_betree_info(pp, field1138)
+        field1151 = unwrapped_fields1149[2]
+        pretty_betree_info(pp, field1151)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3339,26 +3339,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation)
 end
 
 function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo)
-    flat1145 = try_flat(pp, msg, pretty_betree_info)
-    if !isnothing(flat1145)
-        write(pp, flat1145)
+    flat1158 = try_flat(pp, msg, pretty_betree_info)
+    if !isnothing(flat1158)
+        write(pp, flat1158)
         return nothing
     else
         _dollar_dollar = msg
-        _t1379 = deconstruct_betree_info_config(pp, _dollar_dollar)
-        fields1140 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1379,)
-        unwrapped_fields1141 = fields1140
+        _t1405 = deconstruct_betree_info_config(pp, _dollar_dollar)
+        fields1153 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1405,)
+        unwrapped_fields1154 = fields1153
         write(pp, "(betree_info")
         indent_sexp!(pp)
         newline(pp)
-        field1142 = unwrapped_fields1141[1]
-        pretty_betree_info_key_types(pp, field1142)
+        field1155 = unwrapped_fields1154[1]
+        pretty_betree_info_key_types(pp, field1155)
         newline(pp)
-        field1143 = unwrapped_fields1141[2]
-        pretty_betree_info_value_types(pp, field1143)
+        field1156 = unwrapped_fields1154[2]
+        pretty_betree_info_value_types(pp, field1156)
         newline(pp)
-        field1144 = unwrapped_fields1141[3]
-        pretty_config_dict(pp, field1144)
+        field1157 = unwrapped_fields1154[3]
+        pretty_config_dict(pp, field1157)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3366,22 +3366,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo)
 end
 
 function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"})
-    flat1149 = try_flat(pp, msg, pretty_betree_info_key_types)
-    if !isnothing(flat1149)
-        write(pp, flat1149)
+    flat1162 = try_flat(pp, msg, pretty_betree_info_key_types)
+    if !isnothing(flat1162)
+        write(pp, flat1162)
         return nothing
     else
-        fields1146 = msg
+        fields1159 = msg
         write(pp, "(key_types")
         indent_sexp!(pp)
-        if !isempty(fields1146)
+        if !isempty(fields1159)
             newline(pp)
-            for (i1380, elem1147) in enumerate(fields1146)
-                i1148 = i1380 - 1
-                if (i1148 > 0)
+            for (i1406, elem1160) in enumerate(fields1159)
+                i1161 = i1406 - 1
+                if (i1161 > 0)
                     newline(pp)
                 end
-                pretty_type(pp, elem1147)
+                pretty_type(pp, elem1160)
             end
         end
         dedent!(pp)
@@ -3391,22 +3391,22 @@ function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#
 end
 
 function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"})
-    flat1153 = try_flat(pp, msg, pretty_betree_info_value_types)
-    if !isnothing(flat1153)
-        write(pp, flat1153)
+    flat1166 = try_flat(pp, msg, pretty_betree_info_value_types)
+    if !isnothing(flat1166)
+        write(pp, flat1166)
         return nothing
     else
-        fields1150 = msg
+        fields1163 = msg
         write(pp, "(value_types")
         indent_sexp!(pp)
-        if !isempty(fields1150)
+        if !isempty(fields1163)
             newline(pp)
-            for (i1381, elem1151) in enumerate(fields1150)
-                i1152 = i1381 - 1
-                if (i1152 > 0)
+            for (i1407, elem1164) in enumerate(fields1163)
+                i1165 = i1407 - 1
+                if (i1165 > 0)
                     newline(pp)
                 end
-                pretty_type(pp, elem1151)
+                pretty_type(pp, elem1164)
             end
         end
         dedent!(pp)
@@ -3416,28 +3416,28 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var
 end
 
 function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData)
-    flat1160 = try_flat(pp, msg, pretty_csv_data)
-    if !isnothing(flat1160)
-        write(pp, flat1160)
+    flat1173 = try_flat(pp, msg, pretty_csv_data)
+    if !isnothing(flat1173)
+        write(pp, flat1173)
         return nothing
     else
         _dollar_dollar = msg
-        fields1154 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,)
-        unwrapped_fields1155 = fields1154
+        fields1167 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,)
+        unwrapped_fields1168 = fields1167
         write(pp, "(csv_data")
         indent_sexp!(pp)
         newline(pp)
-        field1156 = unwrapped_fields1155[1]
-        pretty_csvlocator(pp, field1156)
+        field1169 = unwrapped_fields1168[1]
+        pretty_csvlocator(pp, field1169)
         newline(pp)
-        field1157 = unwrapped_fields1155[2]
-        pretty_csv_config(pp, field1157)
+        field1170 = unwrapped_fields1168[2]
+        pretty_csv_config(pp, field1170)
         newline(pp)
-        field1158 = unwrapped_fields1155[3]
-        pretty_csv_columns(pp, field1158)
+        field1171 = unwrapped_fields1168[3]
+        pretty_gnf_columns(pp, field1171)
         newline(pp)
-        field1159 = unwrapped_fields1155[4]
-        pretty_csv_asof(pp, field1159)
+        field1172 = unwrapped_fields1168[4]
+        pretty_csv_asof(pp, field1172)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3445,37 +3445,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData)
 end
 
 function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator)
-    flat1167 = try_flat(pp, msg, pretty_csvlocator)
-    if !isnothing(flat1167)
-        write(pp, flat1167)
+    flat1180 = try_flat(pp, msg, pretty_csvlocator)
+    if !isnothing(flat1180)
+        write(pp, flat1180)
         return nothing
     else
         _dollar_dollar = msg
         if !isempty(_dollar_dollar.paths)
-            _t1382 = _dollar_dollar.paths
+            _t1408 = _dollar_dollar.paths
         else
-            _t1382 = nothing
+            _t1408 = nothing
         end
         if String(copy(_dollar_dollar.inline_data)) != ""
-            _t1383 = String(copy(_dollar_dollar.inline_data))
+            _t1409 = String(copy(_dollar_dollar.inline_data))
         else
-            _t1383 = nothing
+            _t1409 = nothing
         end
-        fields1161 = (_t1382, _t1383,)
-        unwrapped_fields1162 = fields1161
+        fields1174 = (_t1408, _t1409,)
+        unwrapped_fields1175 = fields1174
         write(pp, "(csv_locator")
         indent_sexp!(pp)
-        field1163 = unwrapped_fields1162[1]
-        if !isnothing(field1163)
+        field1176 = unwrapped_fields1175[1]
+        if !isnothing(field1176)
             newline(pp)
-            opt_val1164 = field1163
-            pretty_csv_locator_paths(pp, opt_val1164)
+            opt_val1177 = field1176
+            pretty_csv_locator_paths(pp, opt_val1177)
         end
-        field1165 = unwrapped_fields1162[2]
-        if !isnothing(field1165)
+        field1178 = unwrapped_fields1175[2]
+        if !isnothing(field1178)
             newline(pp)
-            opt_val1166 = field1165
-            pretty_csv_locator_inline_data(pp, opt_val1166)
+            opt_val1179 = field1178
+            pretty_csv_locator_inline_data(pp, opt_val1179)
         end
         dedent!(pp)
         write(pp, ")")
@@ -3484,22 +3484,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator)
 end
 
 function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String})
-    flat1171 = try_flat(pp, msg, pretty_csv_locator_paths)
-    if !isnothing(flat1171)
-        write(pp, flat1171)
+    flat1184 = try_flat(pp, msg, pretty_csv_locator_paths)
+    if !isnothing(flat1184)
+        write(pp, flat1184)
         return nothing
     else
-        fields1168 = msg
+        fields1181 = msg
         write(pp, "(paths")
         indent_sexp!(pp)
-        if !isempty(fields1168)
+        if !isempty(fields1181)
             newline(pp)
-            for (i1384, elem1169) in enumerate(fields1168)
-                i1170 = i1384 - 1
-                if (i1170 > 0)
+            for (i1410, elem1182) in enumerate(fields1181)
+                i1183 = i1410 - 1
+                if (i1183 > 0)
                     newline(pp)
                 end
-                write(pp, format_string(pp, elem1169))
+                write(pp, format_string(pp, elem1182))
             end
         end
         dedent!(pp)
@@ -3509,16 +3509,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String})
 end
 
 function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String)
-    flat1173 = try_flat(pp, msg, pretty_csv_locator_inline_data)
-    if !isnothing(flat1173)
-        write(pp, flat1173)
+    flat1186 = try_flat(pp, msg, pretty_csv_locator_inline_data)
+    if !isnothing(flat1186)
+        write(pp, flat1186)
         return nothing
     else
-        fields1172 = msg
+        fields1185 = msg
         write(pp, "(inline_data")
         indent_sexp!(pp)
         newline(pp)
-        write(pp, format_string(pp, fields1172))
+        write(pp, format_string(pp, fields1185))
         dedent!(pp)
         write(pp, ")")
     end
@@ -3526,42 +3526,42 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String)
 end
 
 function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)
-    flat1176 = try_flat(pp, msg, pretty_csv_config)
-    if !isnothing(flat1176)
-        write(pp, flat1176)
+    flat1189 = try_flat(pp, msg, pretty_csv_config)
+    if !isnothing(flat1189)
+        write(pp, flat1189)
         return nothing
     else
         _dollar_dollar = msg
-        _t1385 = deconstruct_csv_config(pp, _dollar_dollar)
-        fields1174 = _t1385
-        unwrapped_fields1175 = fields1174
+        _t1411 = deconstruct_csv_config(pp, _dollar_dollar)
+        fields1187 = _t1411
+        unwrapped_fields1188 = fields1187
         write(pp, "(csv_config")
         indent_sexp!(pp)
         newline(pp)
-        pretty_config_dict(pp, unwrapped_fields1175)
+        pretty_config_dict(pp, unwrapped_fields1188)
         dedent!(pp)
         write(pp, ")")
     end
     return nothing
 end
 
-function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn})
-    flat1180 = try_flat(pp, msg, pretty_csv_columns)
-    if !isnothing(flat1180)
-        write(pp, flat1180)
+function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn})
+    flat1193 = try_flat(pp, msg, pretty_gnf_columns)
+    if !isnothing(flat1193)
+        write(pp, flat1193)
         return nothing
     else
-        fields1177 = msg
+        fields1190 = msg
         write(pp, "(columns")
         indent_sexp!(pp)
-        if !isempty(fields1177)
+        if !isempty(fields1190)
             newline(pp)
-            for (i1386, elem1178) in enumerate(fields1177)
-                i1179 = i1386 - 1
-                if (i1179 > 0)
+            for (i1412, elem1191) in enumerate(fields1190)
+                i1192 = i1412 - 1
+                if (i1192 > 0)
                     newline(pp)
                 end
-                pretty_csv_column(pp, elem1178)
+                pretty_gnf_column(pp, elem1191)
             end
         end
         dedent!(pp)
@@ -3570,32 +3570,40 @@ function pretty_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.CSVColumn})
     return nothing
 end
 
-function pretty_csv_column(pp::PrettyPrinter, msg::Proto.CSVColumn)
-    flat1188 = try_flat(pp, msg, pretty_csv_column)
-    if !isnothing(flat1188)
-        write(pp, flat1188)
+function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn)
+    flat1202 = try_flat(pp, msg, pretty_gnf_column)
+    if !isnothing(flat1202)
+        write(pp, flat1202)
         return nothing
     else
         _dollar_dollar = msg
-        fields1181 = (_dollar_dollar.column_name, _dollar_dollar.target_id, _dollar_dollar.types,)
-        unwrapped_fields1182 = fields1181
+        if _has_proto_field(_dollar_dollar, Symbol("target_id"))
+            _t1413 = _dollar_dollar.target_id
+        else
+            _t1413 = nothing
+        end
+        fields1194 = (_dollar_dollar.column_path, _t1413, _dollar_dollar.types,)
+        unwrapped_fields1195 = fields1194
         write(pp, "(column")
         indent_sexp!(pp)
         newline(pp)
-        field1183 = unwrapped_fields1182[1]
-        write(pp, format_string(pp, field1183))
-        newline(pp)
-        field1184 = unwrapped_fields1182[2]
-        pretty_relation_id(pp, field1184)
+        field1196 = unwrapped_fields1195[1]
+        pretty_gnf_column_path(pp, field1196)
+        field1197 = unwrapped_fields1195[2]
+        if !isnothing(field1197)
+            newline(pp)
+            opt_val1198 = field1197
+            pretty_relation_id(pp, opt_val1198)
+        end
         newline(pp)
         write(pp, "[")
-        field1185 = unwrapped_fields1182[3]
-        for (i1387, elem1186) in enumerate(field1185)
-            i1187 = i1387 - 1
-            if (i1187 > 0)
+        field1199 = unwrapped_fields1195[3]
+        for (i1414, elem1200) in enumerate(field1199)
+            i1201 = i1414 - 1
+            if (i1201 > 0)
                 newline(pp)
             end
-            pretty_type(pp, elem1186)
+            pretty_type(pp, elem1200)
         end
         write(pp, "]")
         dedent!(pp)
@@ -3604,17 +3612,62 @@ function pretty_csv_column(pp::PrettyPrinter, msg::Proto.CSVColumn)
     return nothing
 end
 
+function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String})
+    flat1209 = try_flat(pp, msg, pretty_gnf_column_path)
+    if !isnothing(flat1209)
+        write(pp, flat1209)
+        return nothing
+    else
+        _dollar_dollar = msg
+        if length(_dollar_dollar) == 1
+            _t1415 = _dollar_dollar[1]
+        else
+            _t1415 = nothing
+        end
+        deconstruct_result1207 = _t1415
+        if !isnothing(deconstruct_result1207)
+            unwrapped1208 = deconstruct_result1207
+            write(pp, format_string(pp, unwrapped1208))
+        else
+            _dollar_dollar = msg
+            if length(_dollar_dollar) != 1
+                _t1416 = _dollar_dollar
+            else
+                _t1416 = nothing
+            end
+            deconstruct_result1203 = _t1416
+            if !isnothing(deconstruct_result1203)
+                unwrapped1204 = deconstruct_result1203
+                write(pp, "[")
+                indent!(pp)
+                for (i1417, elem1205) in enumerate(unwrapped1204)
+                    i1206 = i1417 - 1
+                    if (i1206 > 0)
+                        newline(pp)
+                    end
+                    write(pp, format_string(pp, elem1205))
+                end
+                dedent!(pp)
+                write(pp, "]")
+            else
+                throw(ParseError("No matching rule for gnf_column_path"))
+            end
+        end
+    end
+    return nothing
+end
+
 function pretty_csv_asof(pp::PrettyPrinter, msg::String)
-    flat1190 = try_flat(pp, msg, pretty_csv_asof)
-    if !isnothing(flat1190)
-        write(pp, flat1190)
+    flat1211 = try_flat(pp, msg, pretty_csv_asof)
+    if !isnothing(flat1211)
+        write(pp, flat1211)
         return nothing
     else
-        fields1189 = msg
+        fields1210 = msg
         write(pp, "(asof")
         indent_sexp!(pp)
         newline(pp)
-        write(pp, format_string(pp, fields1189))
+        write(pp, format_string(pp, fields1210))
         dedent!(pp)
         write(pp, ")")
     end
@@ -3622,18 +3675,18 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String)
 end
 
 function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine)
-    flat1193 = try_flat(pp, msg, pretty_undefine)
-    if !isnothing(flat1193)
-        write(pp, flat1193)
+    flat1214 = try_flat(pp, msg, pretty_undefine)
+    if !isnothing(flat1214)
+        write(pp, flat1214)
         return nothing
     else
         _dollar_dollar = msg
-        fields1191 = _dollar_dollar.fragment_id
-        unwrapped_fields1192 = fields1191
+        fields1212 = _dollar_dollar.fragment_id
+        unwrapped_fields1213 = fields1212
         write(pp, "(undefine")
         indent_sexp!(pp)
         newline(pp)
-        pretty_fragment_id(pp, unwrapped_fields1192)
+        pretty_fragment_id(pp, unwrapped_fields1213)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3641,24 +3694,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine)
 end
 
 function pretty_context(pp::PrettyPrinter, msg::Proto.Context)
-    flat1198 = try_flat(pp, msg, pretty_context)
-    if !isnothing(flat1198)
-        write(pp, flat1198)
+    flat1219 = try_flat(pp, msg, pretty_context)
+    if !isnothing(flat1219)
+        write(pp, flat1219)
         return nothing
     else
         _dollar_dollar = msg
-        fields1194 = _dollar_dollar.relations
-        unwrapped_fields1195 = fields1194
+        fields1215 = _dollar_dollar.relations
+        unwrapped_fields1216 = fields1215
         write(pp, "(context")
         indent_sexp!(pp)
-        if !isempty(unwrapped_fields1195)
+        if !isempty(unwrapped_fields1216)
             newline(pp)
-            for (i1388, elem1196) in enumerate(unwrapped_fields1195)
-                i1197 = i1388 - 1
-                if (i1197 > 0)
+            for (i1418, elem1217) in enumerate(unwrapped_fields1216)
+                i1218 = i1418 - 1
+                if (i1218 > 0)
                     newline(pp)
                 end
-                pretty_relation_id(pp, elem1196)
+                pretty_relation_id(pp, elem1217)
             end
         end
         dedent!(pp)
@@ -3668,45 +3721,67 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context)
 end
 
 function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot)
-    flat1203 = try_flat(pp, msg, pretty_snapshot)
-    if !isnothing(flat1203)
-        write(pp, flat1203)
+    flat1224 = try_flat(pp, msg, pretty_snapshot)
+    if !isnothing(flat1224)
+        write(pp, flat1224)
         return nothing
     else
         _dollar_dollar = msg
-        fields1199 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,)
-        unwrapped_fields1200 = fields1199
+        fields1220 = _dollar_dollar.mappings
+        unwrapped_fields1221 = fields1220
         write(pp, "(snapshot")
         indent_sexp!(pp)
-        newline(pp)
-        field1201 = unwrapped_fields1200[1]
-        pretty_rel_edb_path(pp, field1201)
-        newline(pp)
-        field1202 = unwrapped_fields1200[2]
-        pretty_relation_id(pp, field1202)
+        if !isempty(unwrapped_fields1221)
+            newline(pp)
+            for (i1419, elem1222) in enumerate(unwrapped_fields1221)
+                i1223 = i1419 - 1
+                if (i1223 > 0)
+                    newline(pp)
+                end
+                pretty_snapshot_mapping(pp, elem1222)
+            end
+        end
         dedent!(pp)
         write(pp, ")")
     end
     return nothing
 end
 
+function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping)
+    flat1229 = try_flat(pp, msg, pretty_snapshot_mapping)
+    if !isnothing(flat1229)
+        write(pp, flat1229)
+        return nothing
+    else
+        _dollar_dollar = msg
+        fields1225 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,)
+        unwrapped_fields1226 = fields1225
+        field1227 = unwrapped_fields1226[1]
+        pretty_edb_path(pp, field1227)
+        write(pp, " ")
+        field1228 = unwrapped_fields1226[2]
+        pretty_relation_id(pp, field1228)
+    end
+    return nothing
+end
+
 function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read})
-    flat1207 = try_flat(pp, msg, pretty_epoch_reads)
-    if !isnothing(flat1207)
-        write(pp, flat1207)
+    flat1233 = try_flat(pp, msg, pretty_epoch_reads)
+    if !isnothing(flat1233)
+        write(pp, flat1233)
         return nothing
     else
-        fields1204 = msg
+        fields1230 = msg
         write(pp, "(reads")
         indent_sexp!(pp)
-        if !isempty(fields1204)
+        if !isempty(fields1230)
             newline(pp)
-            for (i1389, elem1205) in enumerate(fields1204)
-                i1206 = i1389 - 1
-                if (i1206 > 0)
+            for (i1420, elem1231) in enumerate(fields1230)
+                i1232 = i1420 - 1
+                if (i1232 > 0)
                     newline(pp)
                 end
-                pretty_read(pp, elem1205)
+                pretty_read(pp, elem1231)
             end
         end
         dedent!(pp)
@@ -3716,65 +3791,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read})
 end
 
 function pretty_read(pp::PrettyPrinter, msg::Proto.Read)
-    flat1218 = try_flat(pp, msg, pretty_read)
-    if !isnothing(flat1218)
-        write(pp, flat1218)
+    flat1244 = try_flat(pp, msg, pretty_read)
+    if !isnothing(flat1244)
+        write(pp, flat1244)
         return nothing
     else
         _dollar_dollar = msg
         if _has_proto_field(_dollar_dollar, Symbol("demand"))
-            _t1390 = _get_oneof_field(_dollar_dollar, :demand)
+            _t1421 = _get_oneof_field(_dollar_dollar, :demand)
         else
-            _t1390 = nothing
+            _t1421 = nothing
         end
-        deconstruct_result1216 = _t1390
-        if !isnothing(deconstruct_result1216)
-            unwrapped1217 = deconstruct_result1216
-            pretty_demand(pp, unwrapped1217)
+        deconstruct_result1242 = _t1421
+        if !isnothing(deconstruct_result1242)
+            unwrapped1243 = deconstruct_result1242
+            pretty_demand(pp, unwrapped1243)
         else
             _dollar_dollar = msg
             if _has_proto_field(_dollar_dollar, Symbol("output"))
-                _t1391 = _get_oneof_field(_dollar_dollar, :output)
+                _t1422 = _get_oneof_field(_dollar_dollar, :output)
             else
-                _t1391 = nothing
+                _t1422 = nothing
             end
-            deconstruct_result1214 = _t1391
-            if !isnothing(deconstruct_result1214)
-                unwrapped1215 = deconstruct_result1214
-                pretty_output(pp, unwrapped1215)
+            deconstruct_result1240 = _t1422
+            if !isnothing(deconstruct_result1240)
+                unwrapped1241 = deconstruct_result1240
+                pretty_output(pp, unwrapped1241)
             else
                 _dollar_dollar = msg
                 if _has_proto_field(_dollar_dollar, Symbol("what_if"))
-                    _t1392 = _get_oneof_field(_dollar_dollar, :what_if)
+                    _t1423 = _get_oneof_field(_dollar_dollar, :what_if)
                 else
-                    _t1392 = nothing
+                    _t1423 = nothing
                 end
-                deconstruct_result1212 = _t1392
-                if !isnothing(deconstruct_result1212)
-                    unwrapped1213 = deconstruct_result1212
-                    pretty_what_if(pp, unwrapped1213)
+                deconstruct_result1238 = _t1423
+                if !isnothing(deconstruct_result1238)
+                    unwrapped1239 = deconstruct_result1238
+                    pretty_what_if(pp, unwrapped1239)
                 else
                     _dollar_dollar = msg
                     if _has_proto_field(_dollar_dollar, Symbol("abort"))
-                        _t1393 = _get_oneof_field(_dollar_dollar, :abort)
+                        _t1424 = _get_oneof_field(_dollar_dollar, :abort)
                     else
-                        _t1393 = nothing
+                        _t1424 = nothing
                     end
-                    deconstruct_result1210 = _t1393
-                    if !isnothing(deconstruct_result1210)
-                        unwrapped1211 = deconstruct_result1210
-                        pretty_abort(pp, unwrapped1211)
+                    deconstruct_result1236 = _t1424
+                    if !isnothing(deconstruct_result1236)
+                        unwrapped1237 = deconstruct_result1236
+                        pretty_abort(pp, unwrapped1237)
                     else
                         _dollar_dollar = msg
                         if _has_proto_field(_dollar_dollar, Symbol("#export"))
-                            _t1394 = _get_oneof_field(_dollar_dollar, :var"#export")
+                            _t1425 = _get_oneof_field(_dollar_dollar, :var"#export")
                         else
-                            _t1394 = nothing
+                            _t1425 = nothing
                         end
-                        deconstruct_result1208 = _t1394
-                        if !isnothing(deconstruct_result1208)
-                            unwrapped1209 = deconstruct_result1208
-                            pretty_export(pp, unwrapped1209)
+                        deconstruct_result1234 = _t1425
+                        if !isnothing(deconstruct_result1234)
+                            unwrapped1235 = deconstruct_result1234
+                            pretty_export(pp, unwrapped1235)
                         else
                             throw(ParseError("No matching rule for read"))
                         end
@@ -3787,18 +3862,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read)
 end
 
 function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand)
-    flat1221 = try_flat(pp, msg, pretty_demand)
-    if !isnothing(flat1221)
-        write(pp, flat1221)
+    flat1247 = try_flat(pp, msg, pretty_demand)
+    if !isnothing(flat1247)
+        write(pp, flat1247)
         return nothing
     else
         _dollar_dollar = msg
-        fields1219 = _dollar_dollar.relation_id
-        unwrapped_fields1220 = fields1219
+        fields1245 = _dollar_dollar.relation_id
+        unwrapped_fields1246 = fields1245
         write(pp, "(demand")
         indent_sexp!(pp)
         newline(pp)
-        pretty_relation_id(pp, unwrapped_fields1220)
+        pretty_relation_id(pp, unwrapped_fields1246)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3806,22 +3881,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand)
 end
 
 function pretty_output(pp::PrettyPrinter, msg::Proto.Output)
-    flat1226 = try_flat(pp, msg, pretty_output)
-    if !isnothing(flat1226)
-        write(pp, flat1226)
+    flat1252 = try_flat(pp, msg, pretty_output)
+    if !isnothing(flat1252)
+        write(pp, flat1252)
         return nothing
     else
         _dollar_dollar = msg
-        fields1222 = (_dollar_dollar.name, _dollar_dollar.relation_id,)
-        unwrapped_fields1223 = fields1222
+        fields1248 = (_dollar_dollar.name, _dollar_dollar.relation_id,)
+        unwrapped_fields1249 = fields1248
         write(pp, "(output")
         indent_sexp!(pp)
         newline(pp)
-        field1224 = unwrapped_fields1223[1]
-        pretty_name(pp, field1224)
+        field1250 = unwrapped_fields1249[1]
+        pretty_name(pp, field1250)
         newline(pp)
-        field1225 = unwrapped_fields1223[2]
-        pretty_relation_id(pp, field1225)
+        field1251 = unwrapped_fields1249[2]
+        pretty_relation_id(pp, field1251)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3829,22 +3904,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output)
 end
 
 function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf)
-    flat1231 = try_flat(pp, msg, pretty_what_if)
-    if !isnothing(flat1231)
-        write(pp, flat1231)
+    flat1257 = try_flat(pp, msg, pretty_what_if)
+    if !isnothing(flat1257)
+        write(pp, flat1257)
         return nothing
     else
         _dollar_dollar = msg
-        fields1227 = (_dollar_dollar.branch, _dollar_dollar.epoch,)
-        unwrapped_fields1228 = fields1227
+        fields1253 = (_dollar_dollar.branch, _dollar_dollar.epoch,)
+        unwrapped_fields1254 = fields1253
         write(pp, "(what_if")
         indent_sexp!(pp)
         newline(pp)
-        field1229 = unwrapped_fields1228[1]
-        pretty_name(pp, field1229)
+        field1255 = unwrapped_fields1254[1]
+        pretty_name(pp, field1255)
         newline(pp)
-        field1230 = unwrapped_fields1228[2]
-        pretty_epoch(pp, field1230)
+        field1256 = unwrapped_fields1254[2]
+        pretty_epoch(pp, field1256)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3852,30 +3927,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf)
 end
 
 function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort)
-    flat1237 = try_flat(pp, msg, pretty_abort)
-    if !isnothing(flat1237)
-        write(pp, flat1237)
+    flat1263 = try_flat(pp, msg, pretty_abort)
+    if !isnothing(flat1263)
+        write(pp, flat1263)
         return nothing
     else
         _dollar_dollar = msg
         if _dollar_dollar.name != "abort"
-            _t1395 = _dollar_dollar.name
+            _t1426 = _dollar_dollar.name
         else
-            _t1395 = nothing
+            _t1426 = nothing
         end
-        fields1232 = (_t1395, _dollar_dollar.relation_id,)
-        unwrapped_fields1233 = fields1232
+        fields1258 = (_t1426, _dollar_dollar.relation_id,)
+        unwrapped_fields1259 = fields1258
         write(pp, "(abort")
         indent_sexp!(pp)
-        field1234 = unwrapped_fields1233[1]
-        if !isnothing(field1234)
+        field1260 = unwrapped_fields1259[1]
+        if !isnothing(field1260)
             newline(pp)
-            opt_val1235 = field1234
-            pretty_name(pp, opt_val1235)
+            opt_val1261 = field1260
+            pretty_name(pp, opt_val1261)
         end
         newline(pp)
-        field1236 = unwrapped_fields1233[2]
-        pretty_relation_id(pp, field1236)
+        field1262 = unwrapped_fields1259[2]
+        pretty_relation_id(pp, field1262)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3883,18 +3958,18 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort)
 end
 
 function pretty_export(pp::PrettyPrinter, msg::Proto.Export)
-    flat1240 = try_flat(pp, msg, pretty_export)
-    if !isnothing(flat1240)
-        write(pp, flat1240)
+    flat1266 = try_flat(pp, msg, pretty_export)
+    if !isnothing(flat1266)
+        write(pp, flat1266)
         return nothing
     else
         _dollar_dollar = msg
-        fields1238 = _get_oneof_field(_dollar_dollar, :csv_config)
-        unwrapped_fields1239 = fields1238
+        fields1264 = _get_oneof_field(_dollar_dollar, :csv_config)
+        unwrapped_fields1265 = fields1264
         write(pp, "(export")
         indent_sexp!(pp)
         newline(pp)
-        pretty_export_csv_config(pp, unwrapped_fields1239)
+        pretty_export_csv_config(pp, unwrapped_fields1265)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3902,26 +3977,26 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export)
 end
 
 function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)
-    flat1246 = try_flat(pp, msg, pretty_export_csv_config)
-    if !isnothing(flat1246)
-        write(pp, flat1246)
+    flat1272 = try_flat(pp, msg, pretty_export_csv_config)
+    if !isnothing(flat1272)
+        write(pp, flat1272)
         return nothing
     else
         _dollar_dollar = msg
-        _t1396 = deconstruct_export_csv_config(pp, _dollar_dollar)
-        fields1241 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1396,)
-        unwrapped_fields1242 = fields1241
+        _t1427 = deconstruct_export_csv_config(pp, _dollar_dollar)
+        fields1267 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1427,)
+        unwrapped_fields1268 = fields1267
         write(pp, "(export_csv_config")
         indent_sexp!(pp)
         newline(pp)
-        field1243 = unwrapped_fields1242[1]
-        pretty_export_csv_path(pp, field1243)
+        field1269 = unwrapped_fields1268[1]
+        pretty_export_csv_path(pp, field1269)
         newline(pp)
-        field1244 = unwrapped_fields1242[2]
-        pretty_export_csv_columns(pp, field1244)
+        field1270 = unwrapped_fields1268[2]
+        pretty_export_csv_columns(pp, field1270)
         newline(pp)
-        field1245 = unwrapped_fields1242[3]
-        pretty_config_dict(pp, field1245)
+        field1271 = unwrapped_fields1268[3]
+        pretty_config_dict(pp, field1271)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3929,16 +4004,16 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)
 end
 
 function pretty_export_csv_path(pp::PrettyPrinter, msg::String)
-    flat1248 = try_flat(pp, msg, pretty_export_csv_path)
-    if !isnothing(flat1248)
-        write(pp, flat1248)
+    flat1274 = try_flat(pp, msg, pretty_export_csv_path)
+    if !isnothing(flat1274)
+        write(pp, flat1274)
         return nothing
     else
-        fields1247 = msg
+        fields1273 = msg
         write(pp, "(path")
         indent_sexp!(pp)
         newline(pp)
-        write(pp, format_string(pp, fields1247))
+        write(pp, format_string(pp, fields1273))
         dedent!(pp)
         write(pp, ")")
     end
@@ -3946,22 +4021,22 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String)
 end
 
 function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn})
-    flat1252 = try_flat(pp, msg, pretty_export_csv_columns)
-    if !isnothing(flat1252)
-        write(pp, flat1252)
+    flat1278 = try_flat(pp, msg, pretty_export_csv_columns)
+    if !isnothing(flat1278)
+        write(pp, flat1278)
         return nothing
     else
-        fields1249 = msg
+        fields1275 = msg
         write(pp, "(columns")
         indent_sexp!(pp)
-        if !isempty(fields1249)
+        if !isempty(fields1275)
             newline(pp)
-            for (i1397, elem1250) in enumerate(fields1249)
-                i1251 = i1397 - 1
-                if (i1251 > 0)
+            for (i1428, elem1276) in enumerate(fields1275)
+                i1277 = i1428 - 1
+                if (i1277 > 0)
                     newline(pp)
                 end
-                pretty_export_csv_column(pp, elem1250)
+                pretty_export_csv_column(pp, elem1276)
             end
         end
         dedent!(pp)
@@ -3971,22 +4046,22 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Vector{Proto.ExportCS
 end
 
 function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn)
-    flat1257 = try_flat(pp, msg, pretty_export_csv_column)
-    if !isnothing(flat1257)
-        write(pp, flat1257)
+    flat1283 = try_flat(pp, msg, pretty_export_csv_column)
+    if !isnothing(flat1283)
+        write(pp, flat1283)
         return nothing
     else
         _dollar_dollar = msg
-        fields1253 = (_dollar_dollar.column_name, _dollar_dollar.column_data,)
-        unwrapped_fields1254 = fields1253
+        fields1279 = (_dollar_dollar.column_name, _dollar_dollar.column_data,)
+        unwrapped_fields1280 = fields1279
         write(pp, "(column")
         indent_sexp!(pp)
         newline(pp)
-        field1255 = unwrapped_fields1254[1]
-        write(pp, format_string(pp, field1255))
+        field1281 = unwrapped_fields1280[1]
+        write(pp, format_string(pp, field1281))
         newline(pp)
-        field1256 = unwrapped_fields1254[2]
-        pretty_relation_id(pp, field1256)
+        field1282 = unwrapped_fields1280[2]
+        pretty_relation_id(pp, field1282)
         dedent!(pp)
         write(pp, ")")
     end
@@ -3999,12 +4074,12 @@ end
 function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo)
     write(pp, "(debug_info")
     indent_sexp!(pp)
-    for (i1435, _rid) in enumerate(msg.ids)
-        _idx = i1435 - 1
+    for (i1466, _rid) in enumerate(msg.ids)
+        _idx = i1466 - 1
         newline(pp)
         write(pp, "(")
-        _t1436 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high)
-        _pprint_dispatch(pp, _t1436)
+        _t1467 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high)
+        _pprint_dispatch(pp, _t1467)
         write(pp, " ")
         write(pp, format_string(pp, msg.orig_names[_idx + 1]))
         write(pp, ")")
@@ -4076,8 +4151,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe
     _pprint_dispatch(pp, msg.guard)
     newline(pp)
     write(pp, ":keys (")
-    for (i1437, _elem) in enumerate(msg.keys)
-        _idx = i1437 - 1
+    for (i1468, _elem) in enumerate(msg.keys)
+        _idx = i1468 - 1
         if (_idx > 0)
             write(pp, " ")
         end
@@ -4086,8 +4161,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe
     write(pp, ")")
     newline(pp)
     write(pp, ":values (")
-    for (i1438, _elem) in enumerate(msg.values)
-        _idx = i1438 - 1
+    for (i1469, _elem) in enumerate(msg.values)
+        _idx = i1469 - 1
         if (_idx > 0)
             write(pp, " ")
         end
@@ -4218,19 +4293,20 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.MonusDef) = pretty_monus_def(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Constraint) = pretty_constraint(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.Var}) = pretty_functional_dependency_keys(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Data) = pretty_data(pp, x)
-_pprint_dispatch(pp::PrettyPrinter, x::Proto.RelEDB) = pretty_rel_edb(pp, x)
-_pprint_dispatch(pp::PrettyPrinter, x::Vector{String}) = pretty_rel_edb_path(pp, x)
-_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.var"#Type"}) = pretty_rel_edb_types(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Proto.EDB) = pretty_edb(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Vector{String}) = pretty_edb_path(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.var"#Type"}) = pretty_edb_types(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeRelation) = pretty_betree_relation(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.BeTreeInfo) = pretty_betree_info(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVData) = pretty_csv_data(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVLocator) = pretty_csvlocator(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVConfig) = pretty_csv_config(pp, x)
-_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.CSVColumn}) = pretty_csv_columns(pp, x)
-_pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVColumn) = pretty_csv_column(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.GNFColumn}) = pretty_gnf_columns(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Proto.GNFColumn) = pretty_gnf_column(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Undefine) = pretty_undefine(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Context) = pretty_context(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Snapshot) = pretty_snapshot(pp, x)
+_pprint_dispatch(pp::PrettyPrinter, x::Proto.SnapshotMapping) = pretty_snapshot_mapping(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.Read}) = pretty_epoch_reads(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Read) = pretty_read(pp, x)
 _pprint_dispatch(pp::PrettyPrinter, x::Proto.Demand) = pretty_demand(pp, x)
diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl
index f11882d0..dd57c823 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/src/properties.jl
@@ -132,10 +132,10 @@ end
 function global_ids(data::Data)
     dt = data.data_type
     isnothing(dt) && error("Data has no data_type set")
-    if dt.name == :rel_edb
-        rel_edb = dt[]::RelEDB
-        @assert !isnothing(rel_edb.target_id)
-        return [persistent_id(rel_edb.target_id)]
+    if dt.name == :edb
+        edb = dt[]::EDB
+        @assert !isnothing(edb.target_id)
+        return [persistent_id(edb.target_id)]
     elseif dt.name == :betree_relation
         betree_relation = dt[]::BeTreeRelation
         @assert !isnothing(betree_relation.name)
@@ -156,5 +156,5 @@ end
 
 function _is_valid_data(data::Data)
     dt = data.data_type
-    return !isnothing(dt) && dt.name in [:rel_edb, :betree_relation, :csv_data]
+    return !isnothing(dt) && dt.name in [:edb, :betree_relation, :csv_data]
 end
diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl
index b4d262b9..ce27d659 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl
@@ -1363,23 +1363,67 @@ end
     @test d1 == d2 && d2 == d4 && d1 == d4
 end
 
+@testitem "Equality for SnapshotMapping" tags=[:ring1, :unit] begin
+    using LogicalQueryProtocol: SnapshotMapping, RelationId
+
+    r1 = RelationId(id_low=0x1234, id_high=0x0)
+    r2 = RelationId(id_low=0x1234, id_high=0x0)
+    r3 = RelationId(id_low=0x5678, id_high=0x0)
+
+    m1 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1)
+    m2 = SnapshotMapping(destination_path=["my_edb"], source_relation=r2)
+    m3 = SnapshotMapping(destination_path=["other_edb"], source_relation=r1)
+    m4 = SnapshotMapping(destination_path=["my_edb"], source_relation=r3)
+    m5 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1)
+
+    # Equality and inequality
+    @test m1 == m2
+    @test m1 != m3
+    @test m1 != m4
+    @test isequal(m1, m2)
+
+    # Hash consistency
+    @test hash(m1) == hash(m2)
+
+    # Reflexivity
+    @test m1 == m1
+    @test isequal(m1, m1)
+
+    # Symmetry
+    @test m1 == m2 && m2 == m1
+
+    # Transitivity
+    @test m1 == m2 && m2 == m5 && m1 == m5
+
+    # Multi-segment path
+    m6 = SnapshotMapping(destination_path=["schema", "table"], source_relation=r1)
+    m7 = SnapshotMapping(destination_path=["schema", "table"], source_relation=r1)
+    @test m6 == m7
+    @test hash(m6) == hash(m7)
+    @test m6 != m1
+end
+
 @testitem "Equality for Snapshot" tags=[:ring1, :unit] begin
-    using LogicalQueryProtocol: Snapshot, RelationId
+    using LogicalQueryProtocol: Snapshot, SnapshotMapping, RelationId
 
     r1 = RelationId(id_low=0x1234, id_high=0x0)
     r2 = RelationId(id_low=0x1234, id_high=0x0)
     r3 = RelationId(id_low=0x5678, id_high=0x0)
 
-    s1 = Snapshot(destination_path=["my_edb"], source_relation=r1)
-    s2 = Snapshot(destination_path=["my_edb"], source_relation=r2)
-    s3 = Snapshot(destination_path=["other_edb"], source_relation=r1)
-    s4 = Snapshot(destination_path=["my_edb"], source_relation=r3)
-    s5 = Snapshot(destination_path=["my_edb"], source_relation=r1)
+    m1 = SnapshotMapping(destination_path=["my_edb"], source_relation=r1)
+    m2 = SnapshotMapping(destination_path=["other_edb"], source_relation=r3)
+
+    s1 = Snapshot(mappings=[m1, m2])
+    s2 = Snapshot(mappings=[
+        SnapshotMapping(destination_path=["my_edb"], source_relation=r2),
+        SnapshotMapping(destination_path=["other_edb"], source_relation=r3),
+    ])
+    s3 = Snapshot(mappings=[m1])
+    s4 = Snapshot(mappings=[m1, m2])
 
     # Equality and inequality
     @test s1 == s2
     @test s1 != s3
-    @test s1 != s4
     @test isequal(s1, s2)
 
     # Hash consistency
@@ -1393,14 +1437,7 @@ end
     @test s1 == s2 && s2 == s1
 
     # Transitivity
-    @test s1 == s2 && s2 == s5 && s1 == s5
-
-    # Multi-segment path
-    s6 = Snapshot(destination_path=["schema", "table"], source_relation=r1)
-    s7 = Snapshot(destination_path=["schema", "table"], source_relation=r1)
-    @test s6 == s7
-    @test hash(s6) == hash(s7)
-    @test s6 != s1
+    @test s1 == s2 && s2 == s4 && s1 == s4
 end
 
 @testitem "Equality for Configure" tags=[:ring1, :unit] begin
@@ -1940,8 +1977,8 @@ end
     @test b1 != b5
 end
 
-@testitem "Equality for RelEDB" tags=[:ring1, :unit] begin
-    using LogicalQueryProtocol: RelEDB, RelationId, var"#Type", IntType
+@testitem "Equality for EDB" tags=[:ring1, :unit] begin
+    using LogicalQueryProtocol: EDB, RelationId, var"#Type", IntType
     using ProtoBuf: OneOf
 
     r1 = RelationId(id_low=1, id_high=0)
@@ -1949,11 +1986,11 @@ end
     r3 = RelationId(id_low=2, id_high=0)
     t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType()))
 
-    e1 = RelEDB(target_id=r1, path=["table", "column"], types=[t1])
-    e2 = RelEDB(target_id=r2, path=["table", "column"], types=[t1])
-    e3 = RelEDB(target_id=r3, path=["table", "column"], types=[t1])
-    e4 = RelEDB(target_id=r1, path=["other", "column"], types=[t1])
-    e5 = RelEDB(target_id=r1, path=["table", "column"], types=[t1])
+    e1 = EDB(target_id=r1, path=["table", "column"], types=[t1])
+    e2 = EDB(target_id=r2, path=["table", "column"], types=[t1])
+    e3 = EDB(target_id=r3, path=["table", "column"], types=[t1])
+    e4 = EDB(target_id=r1, path=["other", "column"], types=[t1])
+    e5 = EDB(target_id=r1, path=["table", "column"], types=[t1])
 
     # Equality and inequality
     @test e1 == e2
@@ -2013,8 +2050,8 @@ end
     @test b1 == b2 && b2 == b5 && b1 == b5
 end
 
-@testitem "Equality for CSVColumn" tags=[:ring1, :unit] begin
-    using LogicalQueryProtocol: CSVColumn, RelationId, var"#Type", IntType
+@testitem "Equality for GNFColumn" tags=[:ring1, :unit] begin
+    using LogicalQueryProtocol: GNFColumn, RelationId, var"#Type", IntType
     using ProtoBuf: OneOf
 
     r1 = RelationId(id_low=1, id_high=0)
@@ -2022,11 +2059,11 @@ end
     r3 = RelationId(id_low=2, id_high=0)
     t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType()))
 
-    c1 = CSVColumn(column_name="age", target_id=r1, types=[t1])
-    c2 = CSVColumn(column_name="age", target_id=r2, types=[t1])
-    c3 = CSVColumn(column_name="name", target_id=r1, types=[t1])
-    c4 = CSVColumn(column_name="age", target_id=r3, types=[t1])
-    c5 = CSVColumn(column_name="age", target_id=r1, types=[t1])
+    c1 = GNFColumn(column_path=["age"], target_id=r1, types=[t1])
+    c2 = GNFColumn(column_path=["age"], target_id=r2, types=[t1])
+    c3 = GNFColumn(column_path=["name"], target_id=r1, types=[t1])
+    c4 = GNFColumn(column_path=["age"], target_id=r3, types=[t1])
+    c5 = GNFColumn(column_path=["age"], target_id=r1, types=[t1])
 
     # Equality and inequality
     @test c1 == c2
@@ -2086,7 +2123,7 @@ end
 end
 
 @testitem "Equality for CSVData" tags=[:ring1, :unit] begin
-    using LogicalQueryProtocol: CSVData, CSVLocator, CSVConfig, CSVColumn, RelationId, var"#Type", IntType
+    using LogicalQueryProtocol: CSVData, CSVLocator, CSVConfig, GNFColumn, RelationId, var"#Type", IntType
     using ProtoBuf: OneOf
 
     loc1 = CSVLocator(paths=["/path/to/file.csv"], inline_data=UInt8[])
@@ -2096,7 +2133,7 @@ end
     cfg2 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="")
     r1 = RelationId(id_low=1, id_high=0)
     t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType()))
-    col1 = CSVColumn(column_name="age", target_id=r1, types=[t1])
+    col1 = GNFColumn(column_path=["age"], target_id=r1, types=[t1])
 
     d1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="2024-01-01")
     d2 = CSVData(locator=loc2, config=cfg2, columns=[col1], asof="2024-01-01")
@@ -2127,27 +2164,27 @@ end
 end
 
 @testitem "Equality for Data (OneOf type)" tags=[:ring1, :unit] begin
-    using LogicalQueryProtocol: Data, RelEDB, BeTreeRelation, CSVData, RelationId, BeTreeInfo, CSVLocator, CSVConfig, CSVColumn, var"#Type", IntType
+    using LogicalQueryProtocol: Data, EDB, BeTreeRelation, CSVData, RelationId, BeTreeInfo, CSVLocator, CSVConfig, GNFColumn, var"#Type", IntType
     using ProtoBuf: OneOf
 
     r1 = RelationId(id_low=1, id_high=0)
     t1 = var"#Type"(var"#type"=OneOf(:int_type, IntType()))
-    edb1 = RelEDB(target_id=r1, path=["table"], types=[t1])
-    edb2 = RelEDB(target_id=r1, path=["table"], types=[t1])
+    edb1 = EDB(target_id=r1, path=["table"], types=[t1])
+    edb2 = EDB(target_id=r1, path=["table"], types=[t1])
     info1 = BeTreeInfo(key_types=[t1], value_types=[], storage_config=nothing, relation_locator=nothing)
     betree1 = BeTreeRelation(name=r1, relation_info=info1)
     loc1 = CSVLocator(paths=["/file.csv"], inline_data=UInt8[])
     cfg1 = CSVConfig(header_row=1, skip=0, new_line="\n", delimiter=",", quotechar="\"", escapechar="\\", comment="", missing_strings=[], decimal_separator=".", encoding="", compression="")
-    col1 = CSVColumn(column_name="col", target_id=r1, types=[t1])
+    col1 = GNFColumn(column_path=["col"], target_id=r1, types=[t1])
     csv1 = CSVData(locator=loc1, config=cfg1, columns=[col1], asof="")
 
-    d1 = Data(data_type=OneOf(:rel_edb, edb1))
-    d2 = Data(data_type=OneOf(:rel_edb, edb2))
+    d1 = Data(data_type=OneOf(:edb, edb1))
+    d2 = Data(data_type=OneOf(:edb, edb2))
     d3 = Data(data_type=OneOf(:betree_relation, betree1))
     d4 = Data(data_type=OneOf(:csv_data, csv1))
     d5 = Data(data_type=nothing)
     d6 = Data(data_type=nothing)
-    d7 = Data(data_type=OneOf(:rel_edb, edb1))
+    d7 = Data(data_type=OneOf(:edb, edb1))
 
     # Same discriminant, same value
     @test d1 == d2
diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl
index c002fb4e..45f21d45 100644
--- a/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl
+++ b/sdks/julia/LogicalQueryProtocol.jl/test/extra_pretty_tests.jl
@@ -186,13 +186,13 @@ end
     using ProtoBuf: OneOf
 
     pp = PrettyPrinter()
-    rel_edb = Proto.RelEDB(
+    edb = Proto.EDB(
         target_id=Proto.RelationId(UInt64(1), UInt64(0)),
         path=["base", "rel"],
     )
-    msg = Proto.Data(OneOf(:rel_edb, rel_edb))
+    msg = Proto.Data(OneOf(:edb, edb))
     _pprint_dispatch(pp, msg)
-    @test startswith(get_output(pp), "(rel_edb")
+    @test startswith(get_output(pp), "(edb")
 end
 
 @testitem "Extra pretty - oneof: Read" setup=[PrettySetup] begin
diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py
index 2c023fb0..2199507e 100644
--- a/sdks/python/src/lqp/gen/parser.py
+++ b/sdks/python/src/lqp/gen/parser.py
@@ -298,177 +298,177 @@ def relation_id_to_uint128(self, msg):
     def _extract_value_int32(self, value: Optional[logic_pb2.Value], default: int) -> int:
         if value is not None:
             assert value is not None
-            _t1311 = value.HasField("int_value")
+            _t1339 = value.HasField("int_value")
         else:
-            _t1311 = False
-        if _t1311:
+            _t1339 = False
+        if _t1339:
             assert value is not None
             return int(value.int_value)
         else:
-            _t1312 = None
+            _t1340 = None
         return int(default)
 
     def _extract_value_int64(self, value: Optional[logic_pb2.Value], default: int) -> int:
         if value is not None:
             assert value is not None
-            _t1313 = value.HasField("int_value")
+            _t1341 = value.HasField("int_value")
         else:
-            _t1313 = False
-        if _t1313:
+            _t1341 = False
+        if _t1341:
             assert value is not None
             return value.int_value
         else:
-            _t1314 = None
+            _t1342 = None
         return default
 
     def _extract_value_string(self, value: Optional[logic_pb2.Value], default: str) -> str:
         if value is not None:
             assert value is not None
-            _t1315 = value.HasField("string_value")
+            _t1343 = value.HasField("string_value")
         else:
-            _t1315 = False
-        if _t1315:
+            _t1343 = False
+        if _t1343:
             assert value is not None
             return value.string_value
         else:
-            _t1316 = None
+            _t1344 = None
         return default
 
     def _extract_value_boolean(self, value: Optional[logic_pb2.Value], default: bool) -> bool:
         if value is not None:
             assert value is not None
-            _t1317 = value.HasField("boolean_value")
+            _t1345 = value.HasField("boolean_value")
         else:
-            _t1317 = False
-        if _t1317:
+            _t1345 = False
+        if _t1345:
             assert value is not None
             return value.boolean_value
         else:
-            _t1318 = None
+            _t1346 = None
         return default
 
     def _extract_value_string_list(self, value: Optional[logic_pb2.Value], default: Sequence[str]) -> Sequence[str]:
         if value is not None:
             assert value is not None
-            _t1319 = value.HasField("string_value")
+            _t1347 = value.HasField("string_value")
         else:
-            _t1319 = False
-        if _t1319:
+            _t1347 = False
+        if _t1347:
             assert value is not None
             return [value.string_value]
         else:
-            _t1320 = None
+            _t1348 = None
         return default
 
     def _try_extract_value_int64(self, value: Optional[logic_pb2.Value]) -> Optional[int]:
         if value is not None:
             assert value is not None
-            _t1321 = value.HasField("int_value")
+            _t1349 = value.HasField("int_value")
         else:
-            _t1321 = False
-        if _t1321:
+            _t1349 = False
+        if _t1349:
             assert value is not None
             return value.int_value
         else:
-            _t1322 = None
+            _t1350 = None
         return None
 
     def _try_extract_value_float64(self, value: Optional[logic_pb2.Value]) -> Optional[float]:
         if value is not None:
             assert value is not None
-            _t1323 = value.HasField("float_value")
+            _t1351 = value.HasField("float_value")
         else:
-            _t1323 = False
-        if _t1323:
+            _t1351 = False
+        if _t1351:
             assert value is not None
             return value.float_value
         else:
-            _t1324 = None
+            _t1352 = None
         return None
 
     def _try_extract_value_bytes(self, value: Optional[logic_pb2.Value]) -> Optional[bytes]:
         if value is not None:
             assert value is not None
-            _t1325 = value.HasField("string_value")
+            _t1353 = value.HasField("string_value")
         else:
-            _t1325 = False
-        if _t1325:
+            _t1353 = False
+        if _t1353:
             assert value is not None
             return value.string_value.encode()
         else:
-            _t1326 = None
+            _t1354 = None
         return None
 
     def _try_extract_value_uint128(self, value: Optional[logic_pb2.Value]) -> Optional[logic_pb2.UInt128Value]:
         if value is not None:
             assert value is not None
-            _t1327 = value.HasField("uint128_value")
+            _t1355 = value.HasField("uint128_value")
         else:
-            _t1327 = False
-        if _t1327:
+            _t1355 = False
+        if _t1355:
             assert value is not None
             return value.uint128_value
         else:
-            _t1328 = None
+            _t1356 = None
         return None
 
     def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.CSVConfig:
         config = dict(config_dict)
-        _t1329 = self._extract_value_int32(config.get("csv_header_row"), 1)
-        header_row = _t1329
-        _t1330 = self._extract_value_int64(config.get("csv_skip"), 0)
-        skip = _t1330
-        _t1331 = self._extract_value_string(config.get("csv_new_line"), "")
-        new_line = _t1331
-        _t1332 = self._extract_value_string(config.get("csv_delimiter"), ",")
-        delimiter = _t1332
-        _t1333 = self._extract_value_string(config.get("csv_quotechar"), '"')
-        quotechar = _t1333
-        _t1334 = self._extract_value_string(config.get("csv_escapechar"), '"')
-        escapechar = _t1334
-        _t1335 = self._extract_value_string(config.get("csv_comment"), "")
-        comment = _t1335
-        _t1336 = self._extract_value_string_list(config.get("csv_missing_strings"), [])
-        missing_strings = _t1336
-        _t1337 = self._extract_value_string(config.get("csv_decimal_separator"), ".")
-        decimal_separator = _t1337
-        _t1338 = self._extract_value_string(config.get("csv_encoding"), "utf-8")
-        encoding = _t1338
-        _t1339 = self._extract_value_string(config.get("csv_compression"), "auto")
-        compression = _t1339
-        _t1340 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression)
-        return _t1340
+        _t1357 = self._extract_value_int32(config.get("csv_header_row"), 1)
+        header_row = _t1357
+        _t1358 = self._extract_value_int64(config.get("csv_skip"), 0)
+        skip = _t1358
+        _t1359 = self._extract_value_string(config.get("csv_new_line"), "")
+        new_line = _t1359
+        _t1360 = self._extract_value_string(config.get("csv_delimiter"), ",")
+        delimiter = _t1360
+        _t1361 = self._extract_value_string(config.get("csv_quotechar"), '"')
+        quotechar = _t1361
+        _t1362 = self._extract_value_string(config.get("csv_escapechar"), '"')
+        escapechar = _t1362
+        _t1363 = self._extract_value_string(config.get("csv_comment"), "")
+        comment = _t1363
+        _t1364 = self._extract_value_string_list(config.get("csv_missing_strings"), [])
+        missing_strings = _t1364
+        _t1365 = self._extract_value_string(config.get("csv_decimal_separator"), ".")
+        decimal_separator = _t1365
+        _t1366 = self._extract_value_string(config.get("csv_encoding"), "utf-8")
+        encoding = _t1366
+        _t1367 = self._extract_value_string(config.get("csv_compression"), "auto")
+        compression = _t1367
+        _t1368 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression)
+        return _t1368
 
     def construct_betree_info(self, key_types: Sequence[logic_pb2.Type], value_types: Sequence[logic_pb2.Type], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.BeTreeInfo:
         config = dict(config_dict)
-        _t1341 = self._try_extract_value_float64(config.get("betree_config_epsilon"))
-        epsilon = _t1341
-        _t1342 = self._try_extract_value_int64(config.get("betree_config_max_pivots"))
-        max_pivots = _t1342
-        _t1343 = self._try_extract_value_int64(config.get("betree_config_max_deltas"))
-        max_deltas = _t1343
-        _t1344 = self._try_extract_value_int64(config.get("betree_config_max_leaf"))
-        max_leaf = _t1344
-        _t1345 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf)
-        storage_config = _t1345
-        _t1346 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid"))
-        root_pageid = _t1346
-        _t1347 = self._try_extract_value_bytes(config.get("betree_locator_inline_data"))
-        inline_data = _t1347
-        _t1348 = self._try_extract_value_int64(config.get("betree_locator_element_count"))
-        element_count = _t1348
-        _t1349 = self._try_extract_value_int64(config.get("betree_locator_tree_height"))
-        tree_height = _t1349
-        _t1350 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height)
-        relation_locator = _t1350
-        _t1351 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator)
-        return _t1351
+        _t1369 = self._try_extract_value_float64(config.get("betree_config_epsilon"))
+        epsilon = _t1369
+        _t1370 = self._try_extract_value_int64(config.get("betree_config_max_pivots"))
+        max_pivots = _t1370
+        _t1371 = self._try_extract_value_int64(config.get("betree_config_max_deltas"))
+        max_deltas = _t1371
+        _t1372 = self._try_extract_value_int64(config.get("betree_config_max_leaf"))
+        max_leaf = _t1372
+        _t1373 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf)
+        storage_config = _t1373
+        _t1374 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid"))
+        root_pageid = _t1374
+        _t1375 = self._try_extract_value_bytes(config.get("betree_locator_inline_data"))
+        inline_data = _t1375
+        _t1376 = self._try_extract_value_int64(config.get("betree_locator_element_count"))
+        element_count = _t1376
+        _t1377 = self._try_extract_value_int64(config.get("betree_locator_tree_height"))
+        tree_height = _t1377
+        _t1378 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height)
+        relation_locator = _t1378
+        _t1379 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator)
+        return _t1379
 
     def default_configure(self) -> transactions_pb2.Configure:
-        _t1352 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF)
-        ivm_config = _t1352
-        _t1353 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config)
-        return _t1353
+        _t1380 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF)
+        ivm_config = _t1380
+        _t1381 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config)
+        return _t1381
 
     def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure:
         config = dict(config_dict)
@@ -485,31 +485,31 @@ def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]
                         maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL
                     else:
                         maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF
-        _t1354 = transactions_pb2.IVMConfig(level=maintenance_level)
-        ivm_config = _t1354
-        _t1355 = self._extract_value_int64(config.get("semantics_version"), 0)
-        semantics_version = _t1355
-        _t1356 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config)
-        return _t1356
+        _t1382 = transactions_pb2.IVMConfig(level=maintenance_level)
+        ivm_config = _t1382
+        _t1383 = self._extract_value_int64(config.get("semantics_version"), 0)
+        semantics_version = _t1383
+        _t1384 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config)
+        return _t1384
 
     def export_csv_config(self, path: str, columns: Sequence[transactions_pb2.ExportCSVColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.ExportCSVConfig:
         config = dict(config_dict)
-        _t1357 = self._extract_value_int64(config.get("partition_size"), 0)
-        partition_size = _t1357
-        _t1358 = self._extract_value_string(config.get("compression"), "")
-        compression = _t1358
-        _t1359 = self._extract_value_boolean(config.get("syntax_header_row"), True)
-        syntax_header_row = _t1359
-        _t1360 = self._extract_value_string(config.get("syntax_missing_string"), "")
-        syntax_missing_string = _t1360
-        _t1361 = self._extract_value_string(config.get("syntax_delim"), ",")
-        syntax_delim = _t1361
-        _t1362 = self._extract_value_string(config.get("syntax_quotechar"), '"')
-        syntax_quotechar = _t1362
-        _t1363 = self._extract_value_string(config.get("syntax_escapechar"), "\\")
-        syntax_escapechar = _t1363
-        _t1364 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar)
-        return _t1364
+        _t1385 = self._extract_value_int64(config.get("partition_size"), 0)
+        partition_size = _t1385
+        _t1386 = self._extract_value_string(config.get("compression"), "")
+        compression = _t1386
+        _t1387 = self._extract_value_boolean(config.get("syntax_header_row"), True)
+        syntax_header_row = _t1387
+        _t1388 = self._extract_value_string(config.get("syntax_missing_string"), "")
+        syntax_missing_string = _t1388
+        _t1389 = self._extract_value_string(config.get("syntax_delim"), ",")
+        syntax_delim = _t1389
+        _t1390 = self._extract_value_string(config.get("syntax_quotechar"), '"')
+        syntax_quotechar = _t1390
+        _t1391 = self._extract_value_string(config.get("syntax_escapechar"), "\\")
+        syntax_escapechar = _t1391
+        _t1392 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar)
+        return _t1392
 
     # --- Parse methods ---
 
@@ -517,2336 +517,2383 @@ def parse_transaction(self) -> transactions_pb2.Transaction:
         self.consume_literal("(")
         self.consume_literal("transaction")
         if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)):
-            _t713 = self.parse_configure()
-            _t712 = _t713
+            _t733 = self.parse_configure()
+            _t732 = _t733
         else:
-            _t712 = None
-        configure356 = _t712
+            _t732 = None
+        configure366 = _t732
         if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)):
-            _t715 = self.parse_sync()
-            _t714 = _t715
-        else:
-            _t714 = None
-        sync357 = _t714
-        xs358 = []
-        cond359 = self.match_lookahead_literal("(", 0)
-        while cond359:
-            _t716 = self.parse_epoch()
-            item360 = _t716
-            xs358.append(item360)
-            cond359 = self.match_lookahead_literal("(", 0)
-        epochs361 = xs358
-        self.consume_literal(")")
-        _t717 = self.default_configure()
-        _t718 = transactions_pb2.Transaction(epochs=epochs361, configure=(configure356 if configure356 is not None else _t717), sync=sync357)
-        return _t718
+            _t735 = self.parse_sync()
+            _t734 = _t735
+        else:
+            _t734 = None
+        sync367 = _t734
+        xs368 = []
+        cond369 = self.match_lookahead_literal("(", 0)
+        while cond369:
+            _t736 = self.parse_epoch()
+            item370 = _t736
+            xs368.append(item370)
+            cond369 = self.match_lookahead_literal("(", 0)
+        epochs371 = xs368
+        self.consume_literal(")")
+        _t737 = self.default_configure()
+        _t738 = transactions_pb2.Transaction(epochs=epochs371, configure=(configure366 if configure366 is not None else _t737), sync=sync367)
+        return _t738
 
     def parse_configure(self) -> transactions_pb2.Configure:
         self.consume_literal("(")
         self.consume_literal("configure")
-        _t719 = self.parse_config_dict()
-        config_dict362 = _t719
+        _t739 = self.parse_config_dict()
+        config_dict372 = _t739
         self.consume_literal(")")
-        _t720 = self.construct_configure(config_dict362)
-        return _t720
+        _t740 = self.construct_configure(config_dict372)
+        return _t740
 
     def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]:
         self.consume_literal("{")
-        xs363 = []
-        cond364 = self.match_lookahead_literal(":", 0)
-        while cond364:
-            _t721 = self.parse_config_key_value()
-            item365 = _t721
-            xs363.append(item365)
-            cond364 = self.match_lookahead_literal(":", 0)
-        config_key_values366 = xs363
+        xs373 = []
+        cond374 = self.match_lookahead_literal(":", 0)
+        while cond374:
+            _t741 = self.parse_config_key_value()
+            item375 = _t741
+            xs373.append(item375)
+            cond374 = self.match_lookahead_literal(":", 0)
+        config_key_values376 = xs373
         self.consume_literal("}")
-        return config_key_values366
+        return config_key_values376
 
     def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]:
         self.consume_literal(":")
-        symbol367 = self.consume_terminal("SYMBOL")
-        _t722 = self.parse_value()
-        value368 = _t722
-        return (symbol367, value368,)
+        symbol377 = self.consume_terminal("SYMBOL")
+        _t742 = self.parse_value()
+        value378 = _t742
+        return (symbol377, value378,)
 
     def parse_value(self) -> logic_pb2.Value:
         if self.match_lookahead_literal("true", 0):
-            _t723 = 9
+            _t743 = 9
         else:
             if self.match_lookahead_literal("missing", 0):
-                _t724 = 8
+                _t744 = 8
             else:
                 if self.match_lookahead_literal("false", 0):
-                    _t725 = 9
+                    _t745 = 9
                 else:
                     if self.match_lookahead_literal("(", 0):
                         if self.match_lookahead_literal("datetime", 1):
-                            _t727 = 1
+                            _t747 = 1
                         else:
                             if self.match_lookahead_literal("date", 1):
-                                _t728 = 0
+                                _t748 = 0
                             else:
-                                _t728 = -1
-                            _t727 = _t728
-                        _t726 = _t727
+                                _t748 = -1
+                            _t747 = _t748
+                        _t746 = _t747
                     else:
                         if self.match_lookahead_terminal("UINT128", 0):
-                            _t729 = 5
+                            _t749 = 5
                         else:
                             if self.match_lookahead_terminal("STRING", 0):
-                                _t730 = 2
+                                _t750 = 2
                             else:
                                 if self.match_lookahead_terminal("INT128", 0):
-                                    _t731 = 6
+                                    _t751 = 6
                                 else:
                                     if self.match_lookahead_terminal("INT", 0):
-                                        _t732 = 3
+                                        _t752 = 3
                                     else:
                                         if self.match_lookahead_terminal("FLOAT", 0):
-                                            _t733 = 4
+                                            _t753 = 4
                                         else:
                                             if self.match_lookahead_terminal("DECIMAL", 0):
-                                                _t734 = 7
+                                                _t754 = 7
                                             else:
-                                                _t734 = -1
-                                            _t733 = _t734
-                                        _t732 = _t733
-                                    _t731 = _t732
-                                _t730 = _t731
-                            _t729 = _t730
-                        _t726 = _t729
-                    _t725 = _t726
-                _t724 = _t725
-            _t723 = _t724
-        prediction369 = _t723
-        if prediction369 == 9:
-            _t736 = self.parse_boolean_value()
-            boolean_value378 = _t736
-            _t737 = logic_pb2.Value(boolean_value=boolean_value378)
-            _t735 = _t737
-        else:
-            if prediction369 == 8:
+                                                _t754 = -1
+                                            _t753 = _t754
+                                        _t752 = _t753
+                                    _t751 = _t752
+                                _t750 = _t751
+                            _t749 = _t750
+                        _t746 = _t749
+                    _t745 = _t746
+                _t744 = _t745
+            _t743 = _t744
+        prediction379 = _t743
+        if prediction379 == 9:
+            _t756 = self.parse_boolean_value()
+            boolean_value388 = _t756
+            _t757 = logic_pb2.Value(boolean_value=boolean_value388)
+            _t755 = _t757
+        else:
+            if prediction379 == 8:
                 self.consume_literal("missing")
-                _t739 = logic_pb2.MissingValue()
-                _t740 = logic_pb2.Value(missing_value=_t739)
-                _t738 = _t740
+                _t759 = logic_pb2.MissingValue()
+                _t760 = logic_pb2.Value(missing_value=_t759)
+                _t758 = _t760
             else:
-                if prediction369 == 7:
-                    decimal377 = self.consume_terminal("DECIMAL")
-                    _t742 = logic_pb2.Value(decimal_value=decimal377)
-                    _t741 = _t742
+                if prediction379 == 7:
+                    decimal387 = self.consume_terminal("DECIMAL")
+                    _t762 = logic_pb2.Value(decimal_value=decimal387)
+                    _t761 = _t762
                 else:
-                    if prediction369 == 6:
-                        int128376 = self.consume_terminal("INT128")
-                        _t744 = logic_pb2.Value(int128_value=int128376)
-                        _t743 = _t744
+                    if prediction379 == 6:
+                        int128386 = self.consume_terminal("INT128")
+                        _t764 = logic_pb2.Value(int128_value=int128386)
+                        _t763 = _t764
                     else:
-                        if prediction369 == 5:
-                            uint128375 = self.consume_terminal("UINT128")
-                            _t746 = logic_pb2.Value(uint128_value=uint128375)
-                            _t745 = _t746
+                        if prediction379 == 5:
+                            uint128385 = self.consume_terminal("UINT128")
+                            _t766 = logic_pb2.Value(uint128_value=uint128385)
+                            _t765 = _t766
                         else:
-                            if prediction369 == 4:
-                                float374 = self.consume_terminal("FLOAT")
-                                _t748 = logic_pb2.Value(float_value=float374)
-                                _t747 = _t748
+                            if prediction379 == 4:
+                                float384 = self.consume_terminal("FLOAT")
+                                _t768 = logic_pb2.Value(float_value=float384)
+                                _t767 = _t768
                             else:
-                                if prediction369 == 3:
-                                    int373 = self.consume_terminal("INT")
-                                    _t750 = logic_pb2.Value(int_value=int373)
-                                    _t749 = _t750
+                                if prediction379 == 3:
+                                    int383 = self.consume_terminal("INT")
+                                    _t770 = logic_pb2.Value(int_value=int383)
+                                    _t769 = _t770
                                 else:
-                                    if prediction369 == 2:
-                                        string372 = self.consume_terminal("STRING")
-                                        _t752 = logic_pb2.Value(string_value=string372)
-                                        _t751 = _t752
+                                    if prediction379 == 2:
+                                        string382 = self.consume_terminal("STRING")
+                                        _t772 = logic_pb2.Value(string_value=string382)
+                                        _t771 = _t772
                                     else:
-                                        if prediction369 == 1:
-                                            _t754 = self.parse_datetime()
-                                            datetime371 = _t754
-                                            _t755 = logic_pb2.Value(datetime_value=datetime371)
-                                            _t753 = _t755
+                                        if prediction379 == 1:
+                                            _t774 = self.parse_datetime()
+                                            datetime381 = _t774
+                                            _t775 = logic_pb2.Value(datetime_value=datetime381)
+                                            _t773 = _t775
                                         else:
-                                            if prediction369 == 0:
-                                                _t757 = self.parse_date()
-                                                date370 = _t757
-                                                _t758 = logic_pb2.Value(date_value=date370)
-                                                _t756 = _t758
+                                            if prediction379 == 0:
+                                                _t777 = self.parse_date()
+                                                date380 = _t777
+                                                _t778 = logic_pb2.Value(date_value=date380)
+                                                _t776 = _t778
                                             else:
                                                 raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                                            _t753 = _t756
-                                        _t751 = _t753
-                                    _t749 = _t751
-                                _t747 = _t749
-                            _t745 = _t747
-                        _t743 = _t745
-                    _t741 = _t743
-                _t738 = _t741
-            _t735 = _t738
-        return _t735
+                                            _t773 = _t776
+                                        _t771 = _t773
+                                    _t769 = _t771
+                                _t767 = _t769
+                            _t765 = _t767
+                        _t763 = _t765
+                    _t761 = _t763
+                _t758 = _t761
+            _t755 = _t758
+        return _t755
 
     def parse_date(self) -> logic_pb2.DateValue:
         self.consume_literal("(")
         self.consume_literal("date")
-        int379 = self.consume_terminal("INT")
-        int_3380 = self.consume_terminal("INT")
-        int_4381 = self.consume_terminal("INT")
+        int389 = self.consume_terminal("INT")
+        int_3390 = self.consume_terminal("INT")
+        int_4391 = self.consume_terminal("INT")
         self.consume_literal(")")
-        _t759 = logic_pb2.DateValue(year=int(int379), month=int(int_3380), day=int(int_4381))
-        return _t759
+        _t779 = logic_pb2.DateValue(year=int(int389), month=int(int_3390), day=int(int_4391))
+        return _t779
 
     def parse_datetime(self) -> logic_pb2.DateTimeValue:
         self.consume_literal("(")
         self.consume_literal("datetime")
-        int382 = self.consume_terminal("INT")
-        int_3383 = self.consume_terminal("INT")
-        int_4384 = self.consume_terminal("INT")
-        int_5385 = self.consume_terminal("INT")
-        int_6386 = self.consume_terminal("INT")
-        int_7387 = self.consume_terminal("INT")
+        int392 = self.consume_terminal("INT")
+        int_3393 = self.consume_terminal("INT")
+        int_4394 = self.consume_terminal("INT")
+        int_5395 = self.consume_terminal("INT")
+        int_6396 = self.consume_terminal("INT")
+        int_7397 = self.consume_terminal("INT")
         if self.match_lookahead_terminal("INT", 0):
-            _t760 = self.consume_terminal("INT")
+            _t780 = self.consume_terminal("INT")
         else:
-            _t760 = None
-        int_8388 = _t760
+            _t780 = None
+        int_8398 = _t780
         self.consume_literal(")")
-        _t761 = logic_pb2.DateTimeValue(year=int(int382), month=int(int_3383), day=int(int_4384), hour=int(int_5385), minute=int(int_6386), second=int(int_7387), microsecond=int((int_8388 if int_8388 is not None else 0)))
-        return _t761
+        _t781 = logic_pb2.DateTimeValue(year=int(int392), month=int(int_3393), day=int(int_4394), hour=int(int_5395), minute=int(int_6396), second=int(int_7397), microsecond=int((int_8398 if int_8398 is not None else 0)))
+        return _t781
 
     def parse_boolean_value(self) -> bool:
         if self.match_lookahead_literal("true", 0):
-            _t762 = 0
+            _t782 = 0
         else:
             if self.match_lookahead_literal("false", 0):
-                _t763 = 1
+                _t783 = 1
             else:
-                _t763 = -1
-            _t762 = _t763
-        prediction389 = _t762
-        if prediction389 == 1:
+                _t783 = -1
+            _t782 = _t783
+        prediction399 = _t782
+        if prediction399 == 1:
             self.consume_literal("false")
-            _t764 = False
+            _t784 = False
         else:
-            if prediction389 == 0:
+            if prediction399 == 0:
                 self.consume_literal("true")
-                _t765 = True
+                _t785 = True
             else:
                 raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-            _t764 = _t765
-        return _t764
+            _t784 = _t785
+        return _t784
 
     def parse_sync(self) -> transactions_pb2.Sync:
         self.consume_literal("(")
         self.consume_literal("sync")
-        xs390 = []
-        cond391 = self.match_lookahead_literal(":", 0)
-        while cond391:
-            _t766 = self.parse_fragment_id()
-            item392 = _t766
-            xs390.append(item392)
-            cond391 = self.match_lookahead_literal(":", 0)
-        fragment_ids393 = xs390
-        self.consume_literal(")")
-        _t767 = transactions_pb2.Sync(fragments=fragment_ids393)
-        return _t767
+        xs400 = []
+        cond401 = self.match_lookahead_literal(":", 0)
+        while cond401:
+            _t786 = self.parse_fragment_id()
+            item402 = _t786
+            xs400.append(item402)
+            cond401 = self.match_lookahead_literal(":", 0)
+        fragment_ids403 = xs400
+        self.consume_literal(")")
+        _t787 = transactions_pb2.Sync(fragments=fragment_ids403)
+        return _t787
 
     def parse_fragment_id(self) -> fragments_pb2.FragmentId:
         self.consume_literal(":")
-        symbol394 = self.consume_terminal("SYMBOL")
-        return fragments_pb2.FragmentId(id=symbol394.encode())
+        symbol404 = self.consume_terminal("SYMBOL")
+        return fragments_pb2.FragmentId(id=symbol404.encode())
 
     def parse_epoch(self) -> transactions_pb2.Epoch:
         self.consume_literal("(")
         self.consume_literal("epoch")
         if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)):
-            _t769 = self.parse_epoch_writes()
-            _t768 = _t769
+            _t789 = self.parse_epoch_writes()
+            _t788 = _t789
         else:
-            _t768 = None
-        epoch_writes395 = _t768
+            _t788 = None
+        epoch_writes405 = _t788
         if self.match_lookahead_literal("(", 0):
-            _t771 = self.parse_epoch_reads()
-            _t770 = _t771
+            _t791 = self.parse_epoch_reads()
+            _t790 = _t791
         else:
-            _t770 = None
-        epoch_reads396 = _t770
+            _t790 = None
+        epoch_reads406 = _t790
         self.consume_literal(")")
-        _t772 = transactions_pb2.Epoch(writes=(epoch_writes395 if epoch_writes395 is not None else []), reads=(epoch_reads396 if epoch_reads396 is not None else []))
-        return _t772
+        _t792 = transactions_pb2.Epoch(writes=(epoch_writes405 if epoch_writes405 is not None else []), reads=(epoch_reads406 if epoch_reads406 is not None else []))
+        return _t792
 
     def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]:
         self.consume_literal("(")
         self.consume_literal("writes")
-        xs397 = []
-        cond398 = self.match_lookahead_literal("(", 0)
-        while cond398:
-            _t773 = self.parse_write()
-            item399 = _t773
-            xs397.append(item399)
-            cond398 = self.match_lookahead_literal("(", 0)
-        writes400 = xs397
+        xs407 = []
+        cond408 = self.match_lookahead_literal("(", 0)
+        while cond408:
+            _t793 = self.parse_write()
+            item409 = _t793
+            xs407.append(item409)
+            cond408 = self.match_lookahead_literal("(", 0)
+        writes410 = xs407
         self.consume_literal(")")
-        return writes400
+        return writes410
 
     def parse_write(self) -> transactions_pb2.Write:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("undefine", 1):
-                _t775 = 1
+                _t795 = 1
             else:
                 if self.match_lookahead_literal("snapshot", 1):
-                    _t776 = 3
+                    _t796 = 3
                 else:
                     if self.match_lookahead_literal("define", 1):
-                        _t777 = 0
+                        _t797 = 0
                     else:
                         if self.match_lookahead_literal("context", 1):
-                            _t778 = 2
+                            _t798 = 2
                         else:
-                            _t778 = -1
-                        _t777 = _t778
-                    _t776 = _t777
-                _t775 = _t776
-            _t774 = _t775
-        else:
-            _t774 = -1
-        prediction401 = _t774
-        if prediction401 == 3:
-            _t780 = self.parse_snapshot()
-            snapshot405 = _t780
-            _t781 = transactions_pb2.Write(snapshot=snapshot405)
-            _t779 = _t781
-        else:
-            if prediction401 == 2:
-                _t783 = self.parse_context()
-                context404 = _t783
-                _t784 = transactions_pb2.Write(context=context404)
-                _t782 = _t784
+                            _t798 = -1
+                        _t797 = _t798
+                    _t796 = _t797
+                _t795 = _t796
+            _t794 = _t795
+        else:
+            _t794 = -1
+        prediction411 = _t794
+        if prediction411 == 3:
+            _t800 = self.parse_snapshot()
+            snapshot415 = _t800
+            _t801 = transactions_pb2.Write(snapshot=snapshot415)
+            _t799 = _t801
+        else:
+            if prediction411 == 2:
+                _t803 = self.parse_context()
+                context414 = _t803
+                _t804 = transactions_pb2.Write(context=context414)
+                _t802 = _t804
             else:
-                if prediction401 == 1:
-                    _t786 = self.parse_undefine()
-                    undefine403 = _t786
-                    _t787 = transactions_pb2.Write(undefine=undefine403)
-                    _t785 = _t787
+                if prediction411 == 1:
+                    _t806 = self.parse_undefine()
+                    undefine413 = _t806
+                    _t807 = transactions_pb2.Write(undefine=undefine413)
+                    _t805 = _t807
                 else:
-                    if prediction401 == 0:
-                        _t789 = self.parse_define()
-                        define402 = _t789
-                        _t790 = transactions_pb2.Write(define=define402)
-                        _t788 = _t790
+                    if prediction411 == 0:
+                        _t809 = self.parse_define()
+                        define412 = _t809
+                        _t810 = transactions_pb2.Write(define=define412)
+                        _t808 = _t810
                     else:
                         raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                    _t785 = _t788
-                _t782 = _t785
-            _t779 = _t782
-        return _t779
+                    _t805 = _t808
+                _t802 = _t805
+            _t799 = _t802
+        return _t799
 
     def parse_define(self) -> transactions_pb2.Define:
         self.consume_literal("(")
         self.consume_literal("define")
-        _t791 = self.parse_fragment()
-        fragment406 = _t791
+        _t811 = self.parse_fragment()
+        fragment416 = _t811
         self.consume_literal(")")
-        _t792 = transactions_pb2.Define(fragment=fragment406)
-        return _t792
+        _t812 = transactions_pb2.Define(fragment=fragment416)
+        return _t812
 
     def parse_fragment(self) -> fragments_pb2.Fragment:
         self.consume_literal("(")
         self.consume_literal("fragment")
-        _t793 = self.parse_new_fragment_id()
-        new_fragment_id407 = _t793
-        xs408 = []
-        cond409 = self.match_lookahead_literal("(", 0)
-        while cond409:
-            _t794 = self.parse_declaration()
-            item410 = _t794
-            xs408.append(item410)
-            cond409 = self.match_lookahead_literal("(", 0)
-        declarations411 = xs408
-        self.consume_literal(")")
-        return self.construct_fragment(new_fragment_id407, declarations411)
+        _t813 = self.parse_new_fragment_id()
+        new_fragment_id417 = _t813
+        xs418 = []
+        cond419 = self.match_lookahead_literal("(", 0)
+        while cond419:
+            _t814 = self.parse_declaration()
+            item420 = _t814
+            xs418.append(item420)
+            cond419 = self.match_lookahead_literal("(", 0)
+        declarations421 = xs418
+        self.consume_literal(")")
+        return self.construct_fragment(new_fragment_id417, declarations421)
 
     def parse_new_fragment_id(self) -> fragments_pb2.FragmentId:
-        _t795 = self.parse_fragment_id()
-        fragment_id412 = _t795
-        self.start_fragment(fragment_id412)
-        return fragment_id412
+        _t815 = self.parse_fragment_id()
+        fragment_id422 = _t815
+        self.start_fragment(fragment_id422)
+        return fragment_id422
 
     def parse_declaration(self) -> logic_pb2.Declaration:
         if self.match_lookahead_literal("(", 0):
-            if self.match_lookahead_literal("rel_edb", 1):
-                _t797 = 3
+            if self.match_lookahead_literal("functional_dependency", 1):
+                _t817 = 2
             else:
-                if self.match_lookahead_literal("functional_dependency", 1):
-                    _t798 = 2
+                if self.match_lookahead_literal("edb", 1):
+                    _t818 = 3
                 else:
                     if self.match_lookahead_literal("def", 1):
-                        _t799 = 0
+                        _t819 = 0
                     else:
                         if self.match_lookahead_literal("csv_data", 1):
-                            _t800 = 3
+                            _t820 = 3
                         else:
                             if self.match_lookahead_literal("betree_relation", 1):
-                                _t801 = 3
+                                _t821 = 3
                             else:
                                 if self.match_lookahead_literal("algorithm", 1):
-                                    _t802 = 1
+                                    _t822 = 1
                                 else:
-                                    _t802 = -1
-                                _t801 = _t802
-                            _t800 = _t801
-                        _t799 = _t800
-                    _t798 = _t799
-                _t797 = _t798
-            _t796 = _t797
-        else:
-            _t796 = -1
-        prediction413 = _t796
-        if prediction413 == 3:
-            _t804 = self.parse_data()
-            data417 = _t804
-            _t805 = logic_pb2.Declaration(data=data417)
-            _t803 = _t805
-        else:
-            if prediction413 == 2:
-                _t807 = self.parse_constraint()
-                constraint416 = _t807
-                _t808 = logic_pb2.Declaration(constraint=constraint416)
-                _t806 = _t808
+                                    _t822 = -1
+                                _t821 = _t822
+                            _t820 = _t821
+                        _t819 = _t820
+                    _t818 = _t819
+                _t817 = _t818
+            _t816 = _t817
+        else:
+            _t816 = -1
+        prediction423 = _t816
+        if prediction423 == 3:
+            _t824 = self.parse_data()
+            data427 = _t824
+            _t825 = logic_pb2.Declaration(data=data427)
+            _t823 = _t825
+        else:
+            if prediction423 == 2:
+                _t827 = self.parse_constraint()
+                constraint426 = _t827
+                _t828 = logic_pb2.Declaration(constraint=constraint426)
+                _t826 = _t828
             else:
-                if prediction413 == 1:
-                    _t810 = self.parse_algorithm()
-                    algorithm415 = _t810
-                    _t811 = logic_pb2.Declaration(algorithm=algorithm415)
-                    _t809 = _t811
+                if prediction423 == 1:
+                    _t830 = self.parse_algorithm()
+                    algorithm425 = _t830
+                    _t831 = logic_pb2.Declaration(algorithm=algorithm425)
+                    _t829 = _t831
                 else:
-                    if prediction413 == 0:
-                        _t813 = self.parse_def()
-                        def414 = _t813
-                        _t814 = logic_pb2.Declaration()
-                        getattr(_t814, 'def').CopyFrom(def414)
-                        _t812 = _t814
+                    if prediction423 == 0:
+                        _t833 = self.parse_def()
+                        def424 = _t833
+                        _t834 = logic_pb2.Declaration()
+                        getattr(_t834, 'def').CopyFrom(def424)
+                        _t832 = _t834
                     else:
                         raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                    _t809 = _t812
-                _t806 = _t809
-            _t803 = _t806
-        return _t803
+                    _t829 = _t832
+                _t826 = _t829
+            _t823 = _t826
+        return _t823
 
     def parse_def(self) -> logic_pb2.Def:
         self.consume_literal("(")
         self.consume_literal("def")
-        _t815 = self.parse_relation_id()
-        relation_id418 = _t815
-        _t816 = self.parse_abstraction()
-        abstraction419 = _t816
+        _t835 = self.parse_relation_id()
+        relation_id428 = _t835
+        _t836 = self.parse_abstraction()
+        abstraction429 = _t836
         if self.match_lookahead_literal("(", 0):
-            _t818 = self.parse_attrs()
-            _t817 = _t818
+            _t838 = self.parse_attrs()
+            _t837 = _t838
         else:
-            _t817 = None
-        attrs420 = _t817
+            _t837 = None
+        attrs430 = _t837
         self.consume_literal(")")
-        _t819 = logic_pb2.Def(name=relation_id418, body=abstraction419, attrs=(attrs420 if attrs420 is not None else []))
-        return _t819
+        _t839 = logic_pb2.Def(name=relation_id428, body=abstraction429, attrs=(attrs430 if attrs430 is not None else []))
+        return _t839
 
     def parse_relation_id(self) -> logic_pb2.RelationId:
         if self.match_lookahead_literal(":", 0):
-            _t820 = 0
+            _t840 = 0
         else:
             if self.match_lookahead_terminal("UINT128", 0):
-                _t821 = 1
+                _t841 = 1
             else:
-                _t821 = -1
-            _t820 = _t821
-        prediction421 = _t820
-        if prediction421 == 1:
-            uint128423 = self.consume_terminal("UINT128")
-            _t822 = logic_pb2.RelationId(id_low=uint128423.low, id_high=uint128423.high)
-        else:
-            if prediction421 == 0:
+                _t841 = -1
+            _t840 = _t841
+        prediction431 = _t840
+        if prediction431 == 1:
+            uint128433 = self.consume_terminal("UINT128")
+            _t842 = logic_pb2.RelationId(id_low=uint128433.low, id_high=uint128433.high)
+        else:
+            if prediction431 == 0:
                 self.consume_literal(":")
-                symbol422 = self.consume_terminal("SYMBOL")
-                _t823 = self.relation_id_from_string(symbol422)
+                symbol432 = self.consume_terminal("SYMBOL")
+                _t843 = self.relation_id_from_string(symbol432)
             else:
                 raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-            _t822 = _t823
-        return _t822
+            _t842 = _t843
+        return _t842
 
     def parse_abstraction(self) -> logic_pb2.Abstraction:
         self.consume_literal("(")
-        _t824 = self.parse_bindings()
-        bindings424 = _t824
-        _t825 = self.parse_formula()
-        formula425 = _t825
+        _t844 = self.parse_bindings()
+        bindings434 = _t844
+        _t845 = self.parse_formula()
+        formula435 = _t845
         self.consume_literal(")")
-        _t826 = logic_pb2.Abstraction(vars=(list(bindings424[0]) + list(bindings424[1] if bindings424[1] is not None else [])), value=formula425)
-        return _t826
+        _t846 = logic_pb2.Abstraction(vars=(list(bindings434[0]) + list(bindings434[1] if bindings434[1] is not None else [])), value=formula435)
+        return _t846
 
     def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]:
         self.consume_literal("[")
-        xs426 = []
-        cond427 = self.match_lookahead_terminal("SYMBOL", 0)
-        while cond427:
-            _t827 = self.parse_binding()
-            item428 = _t827
-            xs426.append(item428)
-            cond427 = self.match_lookahead_terminal("SYMBOL", 0)
-        bindings429 = xs426
+        xs436 = []
+        cond437 = self.match_lookahead_terminal("SYMBOL", 0)
+        while cond437:
+            _t847 = self.parse_binding()
+            item438 = _t847
+            xs436.append(item438)
+            cond437 = self.match_lookahead_terminal("SYMBOL", 0)
+        bindings439 = xs436
         if self.match_lookahead_literal("|", 0):
-            _t829 = self.parse_value_bindings()
-            _t828 = _t829
+            _t849 = self.parse_value_bindings()
+            _t848 = _t849
         else:
-            _t828 = None
-        value_bindings430 = _t828
+            _t848 = None
+        value_bindings440 = _t848
         self.consume_literal("]")
-        return (bindings429, (value_bindings430 if value_bindings430 is not None else []),)
+        return (bindings439, (value_bindings440 if value_bindings440 is not None else []),)
 
     def parse_binding(self) -> logic_pb2.Binding:
-        symbol431 = self.consume_terminal("SYMBOL")
+        symbol441 = self.consume_terminal("SYMBOL")
         self.consume_literal("::")
-        _t830 = self.parse_type()
-        type432 = _t830
-        _t831 = logic_pb2.Var(name=symbol431)
-        _t832 = logic_pb2.Binding(var=_t831, type=type432)
-        return _t832
+        _t850 = self.parse_type()
+        type442 = _t850
+        _t851 = logic_pb2.Var(name=symbol441)
+        _t852 = logic_pb2.Binding(var=_t851, type=type442)
+        return _t852
 
     def parse_type(self) -> logic_pb2.Type:
         if self.match_lookahead_literal("UNKNOWN", 0):
-            _t833 = 0
+            _t853 = 0
         else:
             if self.match_lookahead_literal("UINT128", 0):
-                _t834 = 4
+                _t854 = 4
             else:
                 if self.match_lookahead_literal("STRING", 0):
-                    _t835 = 1
+                    _t855 = 1
                 else:
                     if self.match_lookahead_literal("MISSING", 0):
-                        _t836 = 8
+                        _t856 = 8
                     else:
                         if self.match_lookahead_literal("INT128", 0):
-                            _t837 = 5
+                            _t857 = 5
                         else:
                             if self.match_lookahead_literal("INT", 0):
-                                _t838 = 2
+                                _t858 = 2
                             else:
                                 if self.match_lookahead_literal("FLOAT", 0):
-                                    _t839 = 3
+                                    _t859 = 3
                                 else:
                                     if self.match_lookahead_literal("DATETIME", 0):
-                                        _t840 = 7
+                                        _t860 = 7
                                     else:
                                         if self.match_lookahead_literal("DATE", 0):
-                                            _t841 = 6
+                                            _t861 = 6
                                         else:
                                             if self.match_lookahead_literal("BOOLEAN", 0):
-                                                _t842 = 10
+                                                _t862 = 10
                                             else:
                                                 if self.match_lookahead_literal("(", 0):
-                                                    _t843 = 9
+                                                    _t863 = 9
                                                 else:
-                                                    _t843 = -1
-                                                _t842 = _t843
-                                            _t841 = _t842
-                                        _t840 = _t841
-                                    _t839 = _t840
-                                _t838 = _t839
-                            _t837 = _t838
-                        _t836 = _t837
-                    _t835 = _t836
-                _t834 = _t835
-            _t833 = _t834
-        prediction433 = _t833
-        if prediction433 == 10:
-            _t845 = self.parse_boolean_type()
-            boolean_type444 = _t845
-            _t846 = logic_pb2.Type(boolean_type=boolean_type444)
-            _t844 = _t846
-        else:
-            if prediction433 == 9:
-                _t848 = self.parse_decimal_type()
-                decimal_type443 = _t848
-                _t849 = logic_pb2.Type(decimal_type=decimal_type443)
-                _t847 = _t849
+                                                    _t863 = -1
+                                                _t862 = _t863
+                                            _t861 = _t862
+                                        _t860 = _t861
+                                    _t859 = _t860
+                                _t858 = _t859
+                            _t857 = _t858
+                        _t856 = _t857
+                    _t855 = _t856
+                _t854 = _t855
+            _t853 = _t854
+        prediction443 = _t853
+        if prediction443 == 10:
+            _t865 = self.parse_boolean_type()
+            boolean_type454 = _t865
+            _t866 = logic_pb2.Type(boolean_type=boolean_type454)
+            _t864 = _t866
+        else:
+            if prediction443 == 9:
+                _t868 = self.parse_decimal_type()
+                decimal_type453 = _t868
+                _t869 = logic_pb2.Type(decimal_type=decimal_type453)
+                _t867 = _t869
             else:
-                if prediction433 == 8:
-                    _t851 = self.parse_missing_type()
-                    missing_type442 = _t851
-                    _t852 = logic_pb2.Type(missing_type=missing_type442)
-                    _t850 = _t852
+                if prediction443 == 8:
+                    _t871 = self.parse_missing_type()
+                    missing_type452 = _t871
+                    _t872 = logic_pb2.Type(missing_type=missing_type452)
+                    _t870 = _t872
                 else:
-                    if prediction433 == 7:
-                        _t854 = self.parse_datetime_type()
-                        datetime_type441 = _t854
-                        _t855 = logic_pb2.Type(datetime_type=datetime_type441)
-                        _t853 = _t855
+                    if prediction443 == 7:
+                        _t874 = self.parse_datetime_type()
+                        datetime_type451 = _t874
+                        _t875 = logic_pb2.Type(datetime_type=datetime_type451)
+                        _t873 = _t875
                     else:
-                        if prediction433 == 6:
-                            _t857 = self.parse_date_type()
-                            date_type440 = _t857
-                            _t858 = logic_pb2.Type(date_type=date_type440)
-                            _t856 = _t858
+                        if prediction443 == 6:
+                            _t877 = self.parse_date_type()
+                            date_type450 = _t877
+                            _t878 = logic_pb2.Type(date_type=date_type450)
+                            _t876 = _t878
                         else:
-                            if prediction433 == 5:
-                                _t860 = self.parse_int128_type()
-                                int128_type439 = _t860
-                                _t861 = logic_pb2.Type(int128_type=int128_type439)
-                                _t859 = _t861
+                            if prediction443 == 5:
+                                _t880 = self.parse_int128_type()
+                                int128_type449 = _t880
+                                _t881 = logic_pb2.Type(int128_type=int128_type449)
+                                _t879 = _t881
                             else:
-                                if prediction433 == 4:
-                                    _t863 = self.parse_uint128_type()
-                                    uint128_type438 = _t863
-                                    _t864 = logic_pb2.Type(uint128_type=uint128_type438)
-                                    _t862 = _t864
+                                if prediction443 == 4:
+                                    _t883 = self.parse_uint128_type()
+                                    uint128_type448 = _t883
+                                    _t884 = logic_pb2.Type(uint128_type=uint128_type448)
+                                    _t882 = _t884
                                 else:
-                                    if prediction433 == 3:
-                                        _t866 = self.parse_float_type()
-                                        float_type437 = _t866
-                                        _t867 = logic_pb2.Type(float_type=float_type437)
-                                        _t865 = _t867
+                                    if prediction443 == 3:
+                                        _t886 = self.parse_float_type()
+                                        float_type447 = _t886
+                                        _t887 = logic_pb2.Type(float_type=float_type447)
+                                        _t885 = _t887
                                     else:
-                                        if prediction433 == 2:
-                                            _t869 = self.parse_int_type()
-                                            int_type436 = _t869
-                                            _t870 = logic_pb2.Type(int_type=int_type436)
-                                            _t868 = _t870
+                                        if prediction443 == 2:
+                                            _t889 = self.parse_int_type()
+                                            int_type446 = _t889
+                                            _t890 = logic_pb2.Type(int_type=int_type446)
+                                            _t888 = _t890
                                         else:
-                                            if prediction433 == 1:
-                                                _t872 = self.parse_string_type()
-                                                string_type435 = _t872
-                                                _t873 = logic_pb2.Type(string_type=string_type435)
-                                                _t871 = _t873
+                                            if prediction443 == 1:
+                                                _t892 = self.parse_string_type()
+                                                string_type445 = _t892
+                                                _t893 = logic_pb2.Type(string_type=string_type445)
+                                                _t891 = _t893
                                             else:
-                                                if prediction433 == 0:
-                                                    _t875 = self.parse_unspecified_type()
-                                                    unspecified_type434 = _t875
-                                                    _t876 = logic_pb2.Type(unspecified_type=unspecified_type434)
-                                                    _t874 = _t876
+                                                if prediction443 == 0:
+                                                    _t895 = self.parse_unspecified_type()
+                                                    unspecified_type444 = _t895
+                                                    _t896 = logic_pb2.Type(unspecified_type=unspecified_type444)
+                                                    _t894 = _t896
                                                 else:
                                                     raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                                                _t871 = _t874
-                                            _t868 = _t871
-                                        _t865 = _t868
-                                    _t862 = _t865
-                                _t859 = _t862
-                            _t856 = _t859
-                        _t853 = _t856
-                    _t850 = _t853
-                _t847 = _t850
-            _t844 = _t847
-        return _t844
+                                                _t891 = _t894
+                                            _t888 = _t891
+                                        _t885 = _t888
+                                    _t882 = _t885
+                                _t879 = _t882
+                            _t876 = _t879
+                        _t873 = _t876
+                    _t870 = _t873
+                _t867 = _t870
+            _t864 = _t867
+        return _t864
 
     def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType:
         self.consume_literal("UNKNOWN")
-        _t877 = logic_pb2.UnspecifiedType()
-        return _t877
+        _t897 = logic_pb2.UnspecifiedType()
+        return _t897
 
     def parse_string_type(self) -> logic_pb2.StringType:
         self.consume_literal("STRING")
-        _t878 = logic_pb2.StringType()
-        return _t878
+        _t898 = logic_pb2.StringType()
+        return _t898
 
     def parse_int_type(self) -> logic_pb2.IntType:
         self.consume_literal("INT")
-        _t879 = logic_pb2.IntType()
-        return _t879
+        _t899 = logic_pb2.IntType()
+        return _t899
 
     def parse_float_type(self) -> logic_pb2.FloatType:
         self.consume_literal("FLOAT")
-        _t880 = logic_pb2.FloatType()
-        return _t880
+        _t900 = logic_pb2.FloatType()
+        return _t900
 
     def parse_uint128_type(self) -> logic_pb2.UInt128Type:
         self.consume_literal("UINT128")
-        _t881 = logic_pb2.UInt128Type()
-        return _t881
+        _t901 = logic_pb2.UInt128Type()
+        return _t901
 
     def parse_int128_type(self) -> logic_pb2.Int128Type:
         self.consume_literal("INT128")
-        _t882 = logic_pb2.Int128Type()
-        return _t882
+        _t902 = logic_pb2.Int128Type()
+        return _t902
 
     def parse_date_type(self) -> logic_pb2.DateType:
         self.consume_literal("DATE")
-        _t883 = logic_pb2.DateType()
-        return _t883
+        _t903 = logic_pb2.DateType()
+        return _t903
 
     def parse_datetime_type(self) -> logic_pb2.DateTimeType:
         self.consume_literal("DATETIME")
-        _t884 = logic_pb2.DateTimeType()
-        return _t884
+        _t904 = logic_pb2.DateTimeType()
+        return _t904
 
     def parse_missing_type(self) -> logic_pb2.MissingType:
         self.consume_literal("MISSING")
-        _t885 = logic_pb2.MissingType()
-        return _t885
+        _t905 = logic_pb2.MissingType()
+        return _t905
 
     def parse_decimal_type(self) -> logic_pb2.DecimalType:
         self.consume_literal("(")
         self.consume_literal("DECIMAL")
-        int445 = self.consume_terminal("INT")
-        int_3446 = self.consume_terminal("INT")
+        int455 = self.consume_terminal("INT")
+        int_3456 = self.consume_terminal("INT")
         self.consume_literal(")")
-        _t886 = logic_pb2.DecimalType(precision=int(int445), scale=int(int_3446))
-        return _t886
+        _t906 = logic_pb2.DecimalType(precision=int(int455), scale=int(int_3456))
+        return _t906
 
     def parse_boolean_type(self) -> logic_pb2.BooleanType:
         self.consume_literal("BOOLEAN")
-        _t887 = logic_pb2.BooleanType()
-        return _t887
+        _t907 = logic_pb2.BooleanType()
+        return _t907
 
     def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]:
         self.consume_literal("|")
-        xs447 = []
-        cond448 = self.match_lookahead_terminal("SYMBOL", 0)
-        while cond448:
-            _t888 = self.parse_binding()
-            item449 = _t888
-            xs447.append(item449)
-            cond448 = self.match_lookahead_terminal("SYMBOL", 0)
-        bindings450 = xs447
-        return bindings450
+        xs457 = []
+        cond458 = self.match_lookahead_terminal("SYMBOL", 0)
+        while cond458:
+            _t908 = self.parse_binding()
+            item459 = _t908
+            xs457.append(item459)
+            cond458 = self.match_lookahead_terminal("SYMBOL", 0)
+        bindings460 = xs457
+        return bindings460
 
     def parse_formula(self) -> logic_pb2.Formula:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("true", 1):
-                _t890 = 0
+                _t910 = 0
             else:
                 if self.match_lookahead_literal("relatom", 1):
-                    _t891 = 11
+                    _t911 = 11
                 else:
                     if self.match_lookahead_literal("reduce", 1):
-                        _t892 = 3
+                        _t912 = 3
                     else:
                         if self.match_lookahead_literal("primitive", 1):
-                            _t893 = 10
+                            _t913 = 10
                         else:
                             if self.match_lookahead_literal("pragma", 1):
-                                _t894 = 9
+                                _t914 = 9
                             else:
                                 if self.match_lookahead_literal("or", 1):
-                                    _t895 = 5
+                                    _t915 = 5
                                 else:
                                     if self.match_lookahead_literal("not", 1):
-                                        _t896 = 6
+                                        _t916 = 6
                                     else:
                                         if self.match_lookahead_literal("ffi", 1):
-                                            _t897 = 7
+                                            _t917 = 7
                                         else:
                                             if self.match_lookahead_literal("false", 1):
-                                                _t898 = 1
+                                                _t918 = 1
                                             else:
                                                 if self.match_lookahead_literal("exists", 1):
-                                                    _t899 = 2
+                                                    _t919 = 2
                                                 else:
                                                     if self.match_lookahead_literal("cast", 1):
-                                                        _t900 = 12
+                                                        _t920 = 12
                                                     else:
                                                         if self.match_lookahead_literal("atom", 1):
-                                                            _t901 = 8
+                                                            _t921 = 8
                                                         else:
                                                             if self.match_lookahead_literal("and", 1):
-                                                                _t902 = 4
+                                                                _t922 = 4
                                                             else:
                                                                 if self.match_lookahead_literal(">=", 1):
-                                                                    _t903 = 10
+                                                                    _t923 = 10
                                                                 else:
                                                                     if self.match_lookahead_literal(">", 1):
-                                                                        _t904 = 10
+                                                                        _t924 = 10
                                                                     else:
                                                                         if self.match_lookahead_literal("=", 1):
-                                                                            _t905 = 10
+                                                                            _t925 = 10
                                                                         else:
                                                                             if self.match_lookahead_literal("<=", 1):
-                                                                                _t906 = 10
+                                                                                _t926 = 10
                                                                             else:
                                                                                 if self.match_lookahead_literal("<", 1):
-                                                                                    _t907 = 10
+                                                                                    _t927 = 10
                                                                                 else:
                                                                                     if self.match_lookahead_literal("/", 1):
-                                                                                        _t908 = 10
+                                                                                        _t928 = 10
                                                                                     else:
                                                                                         if self.match_lookahead_literal("-", 1):
-                                                                                            _t909 = 10
+                                                                                            _t929 = 10
                                                                                         else:
                                                                                             if self.match_lookahead_literal("+", 1):
-                                                                                                _t910 = 10
+                                                                                                _t930 = 10
                                                                                             else:
                                                                                                 if self.match_lookahead_literal("*", 1):
-                                                                                                    _t911 = 10
+                                                                                                    _t931 = 10
                                                                                                 else:
-                                                                                                    _t911 = -1
-                                                                                                _t910 = _t911
-                                                                                            _t909 = _t910
-                                                                                        _t908 = _t909
-                                                                                    _t907 = _t908
-                                                                                _t906 = _t907
-                                                                            _t905 = _t906
-                                                                        _t904 = _t905
-                                                                    _t903 = _t904
-                                                                _t902 = _t903
-                                                            _t901 = _t902
-                                                        _t900 = _t901
-                                                    _t899 = _t900
-                                                _t898 = _t899
-                                            _t897 = _t898
-                                        _t896 = _t897
-                                    _t895 = _t896
-                                _t894 = _t895
-                            _t893 = _t894
-                        _t892 = _t893
-                    _t891 = _t892
-                _t890 = _t891
-            _t889 = _t890
-        else:
-            _t889 = -1
-        prediction451 = _t889
-        if prediction451 == 12:
-            _t913 = self.parse_cast()
-            cast464 = _t913
-            _t914 = logic_pb2.Formula(cast=cast464)
-            _t912 = _t914
-        else:
-            if prediction451 == 11:
-                _t916 = self.parse_rel_atom()
-                rel_atom463 = _t916
-                _t917 = logic_pb2.Formula(rel_atom=rel_atom463)
-                _t915 = _t917
+                                                                                                    _t931 = -1
+                                                                                                _t930 = _t931
+                                                                                            _t929 = _t930
+                                                                                        _t928 = _t929
+                                                                                    _t927 = _t928
+                                                                                _t926 = _t927
+                                                                            _t925 = _t926
+                                                                        _t924 = _t925
+                                                                    _t923 = _t924
+                                                                _t922 = _t923
+                                                            _t921 = _t922
+                                                        _t920 = _t921
+                                                    _t919 = _t920
+                                                _t918 = _t919
+                                            _t917 = _t918
+                                        _t916 = _t917
+                                    _t915 = _t916
+                                _t914 = _t915
+                            _t913 = _t914
+                        _t912 = _t913
+                    _t911 = _t912
+                _t910 = _t911
+            _t909 = _t910
+        else:
+            _t909 = -1
+        prediction461 = _t909
+        if prediction461 == 12:
+            _t933 = self.parse_cast()
+            cast474 = _t933
+            _t934 = logic_pb2.Formula(cast=cast474)
+            _t932 = _t934
+        else:
+            if prediction461 == 11:
+                _t936 = self.parse_rel_atom()
+                rel_atom473 = _t936
+                _t937 = logic_pb2.Formula(rel_atom=rel_atom473)
+                _t935 = _t937
             else:
-                if prediction451 == 10:
-                    _t919 = self.parse_primitive()
-                    primitive462 = _t919
-                    _t920 = logic_pb2.Formula(primitive=primitive462)
-                    _t918 = _t920
+                if prediction461 == 10:
+                    _t939 = self.parse_primitive()
+                    primitive472 = _t939
+                    _t940 = logic_pb2.Formula(primitive=primitive472)
+                    _t938 = _t940
                 else:
-                    if prediction451 == 9:
-                        _t922 = self.parse_pragma()
-                        pragma461 = _t922
-                        _t923 = logic_pb2.Formula(pragma=pragma461)
-                        _t921 = _t923
+                    if prediction461 == 9:
+                        _t942 = self.parse_pragma()
+                        pragma471 = _t942
+                        _t943 = logic_pb2.Formula(pragma=pragma471)
+                        _t941 = _t943
                     else:
-                        if prediction451 == 8:
-                            _t925 = self.parse_atom()
-                            atom460 = _t925
-                            _t926 = logic_pb2.Formula(atom=atom460)
-                            _t924 = _t926
+                        if prediction461 == 8:
+                            _t945 = self.parse_atom()
+                            atom470 = _t945
+                            _t946 = logic_pb2.Formula(atom=atom470)
+                            _t944 = _t946
                         else:
-                            if prediction451 == 7:
-                                _t928 = self.parse_ffi()
-                                ffi459 = _t928
-                                _t929 = logic_pb2.Formula(ffi=ffi459)
-                                _t927 = _t929
+                            if prediction461 == 7:
+                                _t948 = self.parse_ffi()
+                                ffi469 = _t948
+                                _t949 = logic_pb2.Formula(ffi=ffi469)
+                                _t947 = _t949
                             else:
-                                if prediction451 == 6:
-                                    _t931 = self.parse_not()
-                                    not458 = _t931
-                                    _t932 = logic_pb2.Formula()
-                                    getattr(_t932, 'not').CopyFrom(not458)
-                                    _t930 = _t932
+                                if prediction461 == 6:
+                                    _t951 = self.parse_not()
+                                    not468 = _t951
+                                    _t952 = logic_pb2.Formula()
+                                    getattr(_t952, 'not').CopyFrom(not468)
+                                    _t950 = _t952
                                 else:
-                                    if prediction451 == 5:
-                                        _t934 = self.parse_disjunction()
-                                        disjunction457 = _t934
-                                        _t935 = logic_pb2.Formula(disjunction=disjunction457)
-                                        _t933 = _t935
+                                    if prediction461 == 5:
+                                        _t954 = self.parse_disjunction()
+                                        disjunction467 = _t954
+                                        _t955 = logic_pb2.Formula(disjunction=disjunction467)
+                                        _t953 = _t955
                                     else:
-                                        if prediction451 == 4:
-                                            _t937 = self.parse_conjunction()
-                                            conjunction456 = _t937
-                                            _t938 = logic_pb2.Formula(conjunction=conjunction456)
-                                            _t936 = _t938
+                                        if prediction461 == 4:
+                                            _t957 = self.parse_conjunction()
+                                            conjunction466 = _t957
+                                            _t958 = logic_pb2.Formula(conjunction=conjunction466)
+                                            _t956 = _t958
                                         else:
-                                            if prediction451 == 3:
-                                                _t940 = self.parse_reduce()
-                                                reduce455 = _t940
-                                                _t941 = logic_pb2.Formula(reduce=reduce455)
-                                                _t939 = _t941
+                                            if prediction461 == 3:
+                                                _t960 = self.parse_reduce()
+                                                reduce465 = _t960
+                                                _t961 = logic_pb2.Formula(reduce=reduce465)
+                                                _t959 = _t961
                                             else:
-                                                if prediction451 == 2:
-                                                    _t943 = self.parse_exists()
-                                                    exists454 = _t943
-                                                    _t944 = logic_pb2.Formula(exists=exists454)
-                                                    _t942 = _t944
+                                                if prediction461 == 2:
+                                                    _t963 = self.parse_exists()
+                                                    exists464 = _t963
+                                                    _t964 = logic_pb2.Formula(exists=exists464)
+                                                    _t962 = _t964
                                                 else:
-                                                    if prediction451 == 1:
-                                                        _t946 = self.parse_false()
-                                                        false453 = _t946
-                                                        _t947 = logic_pb2.Formula(disjunction=false453)
-                                                        _t945 = _t947
+                                                    if prediction461 == 1:
+                                                        _t966 = self.parse_false()
+                                                        false463 = _t966
+                                                        _t967 = logic_pb2.Formula(disjunction=false463)
+                                                        _t965 = _t967
                                                     else:
-                                                        if prediction451 == 0:
-                                                            _t949 = self.parse_true()
-                                                            true452 = _t949
-                                                            _t950 = logic_pb2.Formula(conjunction=true452)
-                                                            _t948 = _t950
+                                                        if prediction461 == 0:
+                                                            _t969 = self.parse_true()
+                                                            true462 = _t969
+                                                            _t970 = logic_pb2.Formula(conjunction=true462)
+                                                            _t968 = _t970
                                                         else:
                                                             raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                                                        _t945 = _t948
-                                                    _t942 = _t945
-                                                _t939 = _t942
-                                            _t936 = _t939
-                                        _t933 = _t936
-                                    _t930 = _t933
-                                _t927 = _t930
-                            _t924 = _t927
-                        _t921 = _t924
-                    _t918 = _t921
-                _t915 = _t918
-            _t912 = _t915
-        return _t912
+                                                        _t965 = _t968
+                                                    _t962 = _t965
+                                                _t959 = _t962
+                                            _t956 = _t959
+                                        _t953 = _t956
+                                    _t950 = _t953
+                                _t947 = _t950
+                            _t944 = _t947
+                        _t941 = _t944
+                    _t938 = _t941
+                _t935 = _t938
+            _t932 = _t935
+        return _t932
 
     def parse_true(self) -> logic_pb2.Conjunction:
         self.consume_literal("(")
         self.consume_literal("true")
         self.consume_literal(")")
-        _t951 = logic_pb2.Conjunction(args=[])
-        return _t951
+        _t971 = logic_pb2.Conjunction(args=[])
+        return _t971
 
     def parse_false(self) -> logic_pb2.Disjunction:
         self.consume_literal("(")
         self.consume_literal("false")
         self.consume_literal(")")
-        _t952 = logic_pb2.Disjunction(args=[])
-        return _t952
+        _t972 = logic_pb2.Disjunction(args=[])
+        return _t972
 
     def parse_exists(self) -> logic_pb2.Exists:
         self.consume_literal("(")
         self.consume_literal("exists")
-        _t953 = self.parse_bindings()
-        bindings465 = _t953
-        _t954 = self.parse_formula()
-        formula466 = _t954
+        _t973 = self.parse_bindings()
+        bindings475 = _t973
+        _t974 = self.parse_formula()
+        formula476 = _t974
         self.consume_literal(")")
-        _t955 = logic_pb2.Abstraction(vars=(list(bindings465[0]) + list(bindings465[1] if bindings465[1] is not None else [])), value=formula466)
-        _t956 = logic_pb2.Exists(body=_t955)
-        return _t956
+        _t975 = logic_pb2.Abstraction(vars=(list(bindings475[0]) + list(bindings475[1] if bindings475[1] is not None else [])), value=formula476)
+        _t976 = logic_pb2.Exists(body=_t975)
+        return _t976
 
     def parse_reduce(self) -> logic_pb2.Reduce:
         self.consume_literal("(")
         self.consume_literal("reduce")
-        _t957 = self.parse_abstraction()
-        abstraction467 = _t957
-        _t958 = self.parse_abstraction()
-        abstraction_3468 = _t958
-        _t959 = self.parse_terms()
-        terms469 = _t959
+        _t977 = self.parse_abstraction()
+        abstraction477 = _t977
+        _t978 = self.parse_abstraction()
+        abstraction_3478 = _t978
+        _t979 = self.parse_terms()
+        terms479 = _t979
         self.consume_literal(")")
-        _t960 = logic_pb2.Reduce(op=abstraction467, body=abstraction_3468, terms=terms469)
-        return _t960
+        _t980 = logic_pb2.Reduce(op=abstraction477, body=abstraction_3478, terms=terms479)
+        return _t980
 
     def parse_terms(self) -> Sequence[logic_pb2.Term]:
         self.consume_literal("(")
         self.consume_literal("terms")
-        xs470 = []
-        cond471 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        while cond471:
-            _t961 = self.parse_term()
-            item472 = _t961
-            xs470.append(item472)
-            cond471 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        terms473 = xs470
+        xs480 = []
+        cond481 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        while cond481:
+            _t981 = self.parse_term()
+            item482 = _t981
+            xs480.append(item482)
+            cond481 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        terms483 = xs480
         self.consume_literal(")")
-        return terms473
+        return terms483
 
     def parse_term(self) -> logic_pb2.Term:
         if self.match_lookahead_literal("true", 0):
-            _t962 = 1
+            _t982 = 1
         else:
             if self.match_lookahead_literal("missing", 0):
-                _t963 = 1
+                _t983 = 1
             else:
                 if self.match_lookahead_literal("false", 0):
-                    _t964 = 1
+                    _t984 = 1
                 else:
                     if self.match_lookahead_literal("(", 0):
-                        _t965 = 1
+                        _t985 = 1
                     else:
                         if self.match_lookahead_terminal("UINT128", 0):
-                            _t966 = 1
+                            _t986 = 1
                         else:
                             if self.match_lookahead_terminal("SYMBOL", 0):
-                                _t967 = 0
+                                _t987 = 0
                             else:
                                 if self.match_lookahead_terminal("STRING", 0):
-                                    _t968 = 1
+                                    _t988 = 1
                                 else:
                                     if self.match_lookahead_terminal("INT128", 0):
-                                        _t969 = 1
+                                        _t989 = 1
                                     else:
                                         if self.match_lookahead_terminal("INT", 0):
-                                            _t970 = 1
+                                            _t990 = 1
                                         else:
                                             if self.match_lookahead_terminal("FLOAT", 0):
-                                                _t971 = 1
+                                                _t991 = 1
                                             else:
                                                 if self.match_lookahead_terminal("DECIMAL", 0):
-                                                    _t972 = 1
+                                                    _t992 = 1
                                                 else:
-                                                    _t972 = -1
-                                                _t971 = _t972
-                                            _t970 = _t971
-                                        _t969 = _t970
-                                    _t968 = _t969
-                                _t967 = _t968
-                            _t966 = _t967
-                        _t965 = _t966
-                    _t964 = _t965
-                _t963 = _t964
-            _t962 = _t963
-        prediction474 = _t962
-        if prediction474 == 1:
-            _t974 = self.parse_constant()
-            constant476 = _t974
-            _t975 = logic_pb2.Term(constant=constant476)
-            _t973 = _t975
-        else:
-            if prediction474 == 0:
-                _t977 = self.parse_var()
-                var475 = _t977
-                _t978 = logic_pb2.Term(var=var475)
-                _t976 = _t978
+                                                    _t992 = -1
+                                                _t991 = _t992
+                                            _t990 = _t991
+                                        _t989 = _t990
+                                    _t988 = _t989
+                                _t987 = _t988
+                            _t986 = _t987
+                        _t985 = _t986
+                    _t984 = _t985
+                _t983 = _t984
+            _t982 = _t983
+        prediction484 = _t982
+        if prediction484 == 1:
+            _t994 = self.parse_constant()
+            constant486 = _t994
+            _t995 = logic_pb2.Term(constant=constant486)
+            _t993 = _t995
+        else:
+            if prediction484 == 0:
+                _t997 = self.parse_var()
+                var485 = _t997
+                _t998 = logic_pb2.Term(var=var485)
+                _t996 = _t998
             else:
                 raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-            _t973 = _t976
-        return _t973
+            _t993 = _t996
+        return _t993
 
     def parse_var(self) -> logic_pb2.Var:
-        symbol477 = self.consume_terminal("SYMBOL")
-        _t979 = logic_pb2.Var(name=symbol477)
-        return _t979
+        symbol487 = self.consume_terminal("SYMBOL")
+        _t999 = logic_pb2.Var(name=symbol487)
+        return _t999
 
     def parse_constant(self) -> logic_pb2.Value:
-        _t980 = self.parse_value()
-        value478 = _t980
-        return value478
+        _t1000 = self.parse_value()
+        value488 = _t1000
+        return value488
 
     def parse_conjunction(self) -> logic_pb2.Conjunction:
         self.consume_literal("(")
         self.consume_literal("and")
-        xs479 = []
-        cond480 = self.match_lookahead_literal("(", 0)
-        while cond480:
-            _t981 = self.parse_formula()
-            item481 = _t981
-            xs479.append(item481)
-            cond480 = self.match_lookahead_literal("(", 0)
-        formulas482 = xs479
-        self.consume_literal(")")
-        _t982 = logic_pb2.Conjunction(args=formulas482)
-        return _t982
+        xs489 = []
+        cond490 = self.match_lookahead_literal("(", 0)
+        while cond490:
+            _t1001 = self.parse_formula()
+            item491 = _t1001
+            xs489.append(item491)
+            cond490 = self.match_lookahead_literal("(", 0)
+        formulas492 = xs489
+        self.consume_literal(")")
+        _t1002 = logic_pb2.Conjunction(args=formulas492)
+        return _t1002
 
     def parse_disjunction(self) -> logic_pb2.Disjunction:
         self.consume_literal("(")
         self.consume_literal("or")
-        xs483 = []
-        cond484 = self.match_lookahead_literal("(", 0)
-        while cond484:
-            _t983 = self.parse_formula()
-            item485 = _t983
-            xs483.append(item485)
-            cond484 = self.match_lookahead_literal("(", 0)
-        formulas486 = xs483
-        self.consume_literal(")")
-        _t984 = logic_pb2.Disjunction(args=formulas486)
-        return _t984
+        xs493 = []
+        cond494 = self.match_lookahead_literal("(", 0)
+        while cond494:
+            _t1003 = self.parse_formula()
+            item495 = _t1003
+            xs493.append(item495)
+            cond494 = self.match_lookahead_literal("(", 0)
+        formulas496 = xs493
+        self.consume_literal(")")
+        _t1004 = logic_pb2.Disjunction(args=formulas496)
+        return _t1004
 
     def parse_not(self) -> logic_pb2.Not:
         self.consume_literal("(")
         self.consume_literal("not")
-        _t985 = self.parse_formula()
-        formula487 = _t985
+        _t1005 = self.parse_formula()
+        formula497 = _t1005
         self.consume_literal(")")
-        _t986 = logic_pb2.Not(arg=formula487)
-        return _t986
+        _t1006 = logic_pb2.Not(arg=formula497)
+        return _t1006
 
     def parse_ffi(self) -> logic_pb2.FFI:
         self.consume_literal("(")
         self.consume_literal("ffi")
-        _t987 = self.parse_name()
-        name488 = _t987
-        _t988 = self.parse_ffi_args()
-        ffi_args489 = _t988
-        _t989 = self.parse_terms()
-        terms490 = _t989
+        _t1007 = self.parse_name()
+        name498 = _t1007
+        _t1008 = self.parse_ffi_args()
+        ffi_args499 = _t1008
+        _t1009 = self.parse_terms()
+        terms500 = _t1009
         self.consume_literal(")")
-        _t990 = logic_pb2.FFI(name=name488, args=ffi_args489, terms=terms490)
-        return _t990
+        _t1010 = logic_pb2.FFI(name=name498, args=ffi_args499, terms=terms500)
+        return _t1010
 
     def parse_name(self) -> str:
         self.consume_literal(":")
-        symbol491 = self.consume_terminal("SYMBOL")
-        return symbol491
+        symbol501 = self.consume_terminal("SYMBOL")
+        return symbol501
 
     def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]:
         self.consume_literal("(")
         self.consume_literal("args")
-        xs492 = []
-        cond493 = self.match_lookahead_literal("(", 0)
-        while cond493:
-            _t991 = self.parse_abstraction()
-            item494 = _t991
-            xs492.append(item494)
-            cond493 = self.match_lookahead_literal("(", 0)
-        abstractions495 = xs492
+        xs502 = []
+        cond503 = self.match_lookahead_literal("(", 0)
+        while cond503:
+            _t1011 = self.parse_abstraction()
+            item504 = _t1011
+            xs502.append(item504)
+            cond503 = self.match_lookahead_literal("(", 0)
+        abstractions505 = xs502
         self.consume_literal(")")
-        return abstractions495
+        return abstractions505
 
     def parse_atom(self) -> logic_pb2.Atom:
         self.consume_literal("(")
         self.consume_literal("atom")
-        _t992 = self.parse_relation_id()
-        relation_id496 = _t992
-        xs497 = []
-        cond498 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        while cond498:
-            _t993 = self.parse_term()
-            item499 = _t993
-            xs497.append(item499)
-            cond498 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        terms500 = xs497
-        self.consume_literal(")")
-        _t994 = logic_pb2.Atom(name=relation_id496, terms=terms500)
-        return _t994
+        _t1012 = self.parse_relation_id()
+        relation_id506 = _t1012
+        xs507 = []
+        cond508 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        while cond508:
+            _t1013 = self.parse_term()
+            item509 = _t1013
+            xs507.append(item509)
+            cond508 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        terms510 = xs507
+        self.consume_literal(")")
+        _t1014 = logic_pb2.Atom(name=relation_id506, terms=terms510)
+        return _t1014
 
     def parse_pragma(self) -> logic_pb2.Pragma:
         self.consume_literal("(")
         self.consume_literal("pragma")
-        _t995 = self.parse_name()
-        name501 = _t995
-        xs502 = []
-        cond503 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        while cond503:
-            _t996 = self.parse_term()
-            item504 = _t996
-            xs502.append(item504)
-            cond503 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        terms505 = xs502
-        self.consume_literal(")")
-        _t997 = logic_pb2.Pragma(name=name501, terms=terms505)
-        return _t997
+        _t1015 = self.parse_name()
+        name511 = _t1015
+        xs512 = []
+        cond513 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        while cond513:
+            _t1016 = self.parse_term()
+            item514 = _t1016
+            xs512.append(item514)
+            cond513 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        terms515 = xs512
+        self.consume_literal(")")
+        _t1017 = logic_pb2.Pragma(name=name511, terms=terms515)
+        return _t1017
 
     def parse_primitive(self) -> logic_pb2.Primitive:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("primitive", 1):
-                _t999 = 9
+                _t1019 = 9
             else:
                 if self.match_lookahead_literal(">=", 1):
-                    _t1000 = 4
+                    _t1020 = 4
                 else:
                     if self.match_lookahead_literal(">", 1):
-                        _t1001 = 3
+                        _t1021 = 3
                     else:
                         if self.match_lookahead_literal("=", 1):
-                            _t1002 = 0
+                            _t1022 = 0
                         else:
                             if self.match_lookahead_literal("<=", 1):
-                                _t1003 = 2
+                                _t1023 = 2
                             else:
                                 if self.match_lookahead_literal("<", 1):
-                                    _t1004 = 1
+                                    _t1024 = 1
                                 else:
                                     if self.match_lookahead_literal("/", 1):
-                                        _t1005 = 8
+                                        _t1025 = 8
                                     else:
                                         if self.match_lookahead_literal("-", 1):
-                                            _t1006 = 6
+                                            _t1026 = 6
                                         else:
                                             if self.match_lookahead_literal("+", 1):
-                                                _t1007 = 5
+                                                _t1027 = 5
                                             else:
                                                 if self.match_lookahead_literal("*", 1):
-                                                    _t1008 = 7
+                                                    _t1028 = 7
                                                 else:
-                                                    _t1008 = -1
-                                                _t1007 = _t1008
-                                            _t1006 = _t1007
-                                        _t1005 = _t1006
-                                    _t1004 = _t1005
-                                _t1003 = _t1004
-                            _t1002 = _t1003
-                        _t1001 = _t1002
-                    _t1000 = _t1001
-                _t999 = _t1000
-            _t998 = _t999
-        else:
-            _t998 = -1
-        prediction506 = _t998
-        if prediction506 == 9:
+                                                    _t1028 = -1
+                                                _t1027 = _t1028
+                                            _t1026 = _t1027
+                                        _t1025 = _t1026
+                                    _t1024 = _t1025
+                                _t1023 = _t1024
+                            _t1022 = _t1023
+                        _t1021 = _t1022
+                    _t1020 = _t1021
+                _t1019 = _t1020
+            _t1018 = _t1019
+        else:
+            _t1018 = -1
+        prediction516 = _t1018
+        if prediction516 == 9:
             self.consume_literal("(")
             self.consume_literal("primitive")
-            _t1010 = self.parse_name()
-            name516 = _t1010
-            xs517 = []
-            cond518 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-            while cond518:
-                _t1011 = self.parse_rel_term()
-                item519 = _t1011
-                xs517.append(item519)
-                cond518 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-            rel_terms520 = xs517
+            _t1030 = self.parse_name()
+            name526 = _t1030
+            xs527 = []
+            cond528 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+            while cond528:
+                _t1031 = self.parse_rel_term()
+                item529 = _t1031
+                xs527.append(item529)
+                cond528 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+            rel_terms530 = xs527
             self.consume_literal(")")
-            _t1012 = logic_pb2.Primitive(name=name516, terms=rel_terms520)
-            _t1009 = _t1012
+            _t1032 = logic_pb2.Primitive(name=name526, terms=rel_terms530)
+            _t1029 = _t1032
         else:
-            if prediction506 == 8:
-                _t1014 = self.parse_divide()
-                divide515 = _t1014
-                _t1013 = divide515
+            if prediction516 == 8:
+                _t1034 = self.parse_divide()
+                divide525 = _t1034
+                _t1033 = divide525
             else:
-                if prediction506 == 7:
-                    _t1016 = self.parse_multiply()
-                    multiply514 = _t1016
-                    _t1015 = multiply514
+                if prediction516 == 7:
+                    _t1036 = self.parse_multiply()
+                    multiply524 = _t1036
+                    _t1035 = multiply524
                 else:
-                    if prediction506 == 6:
-                        _t1018 = self.parse_minus()
-                        minus513 = _t1018
-                        _t1017 = minus513
+                    if prediction516 == 6:
+                        _t1038 = self.parse_minus()
+                        minus523 = _t1038
+                        _t1037 = minus523
                     else:
-                        if prediction506 == 5:
-                            _t1020 = self.parse_add()
-                            add512 = _t1020
-                            _t1019 = add512
+                        if prediction516 == 5:
+                            _t1040 = self.parse_add()
+                            add522 = _t1040
+                            _t1039 = add522
                         else:
-                            if prediction506 == 4:
-                                _t1022 = self.parse_gt_eq()
-                                gt_eq511 = _t1022
-                                _t1021 = gt_eq511
+                            if prediction516 == 4:
+                                _t1042 = self.parse_gt_eq()
+                                gt_eq521 = _t1042
+                                _t1041 = gt_eq521
                             else:
-                                if prediction506 == 3:
-                                    _t1024 = self.parse_gt()
-                                    gt510 = _t1024
-                                    _t1023 = gt510
+                                if prediction516 == 3:
+                                    _t1044 = self.parse_gt()
+                                    gt520 = _t1044
+                                    _t1043 = gt520
                                 else:
-                                    if prediction506 == 2:
-                                        _t1026 = self.parse_lt_eq()
-                                        lt_eq509 = _t1026
-                                        _t1025 = lt_eq509
+                                    if prediction516 == 2:
+                                        _t1046 = self.parse_lt_eq()
+                                        lt_eq519 = _t1046
+                                        _t1045 = lt_eq519
                                     else:
-                                        if prediction506 == 1:
-                                            _t1028 = self.parse_lt()
-                                            lt508 = _t1028
-                                            _t1027 = lt508
+                                        if prediction516 == 1:
+                                            _t1048 = self.parse_lt()
+                                            lt518 = _t1048
+                                            _t1047 = lt518
                                         else:
-                                            if prediction506 == 0:
-                                                _t1030 = self.parse_eq()
-                                                eq507 = _t1030
-                                                _t1029 = eq507
+                                            if prediction516 == 0:
+                                                _t1050 = self.parse_eq()
+                                                eq517 = _t1050
+                                                _t1049 = eq517
                                             else:
                                                 raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                                            _t1027 = _t1029
-                                        _t1025 = _t1027
-                                    _t1023 = _t1025
-                                _t1021 = _t1023
-                            _t1019 = _t1021
-                        _t1017 = _t1019
-                    _t1015 = _t1017
-                _t1013 = _t1015
-            _t1009 = _t1013
-        return _t1009
+                                            _t1047 = _t1049
+                                        _t1045 = _t1047
+                                    _t1043 = _t1045
+                                _t1041 = _t1043
+                            _t1039 = _t1041
+                        _t1037 = _t1039
+                    _t1035 = _t1037
+                _t1033 = _t1035
+            _t1029 = _t1033
+        return _t1029
 
     def parse_eq(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("=")
-        _t1031 = self.parse_term()
-        term521 = _t1031
-        _t1032 = self.parse_term()
-        term_3522 = _t1032
+        _t1051 = self.parse_term()
+        term531 = _t1051
+        _t1052 = self.parse_term()
+        term_3532 = _t1052
         self.consume_literal(")")
-        _t1033 = logic_pb2.RelTerm(term=term521)
-        _t1034 = logic_pb2.RelTerm(term=term_3522)
-        _t1035 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1033, _t1034])
-        return _t1035
+        _t1053 = logic_pb2.RelTerm(term=term531)
+        _t1054 = logic_pb2.RelTerm(term=term_3532)
+        _t1055 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1053, _t1054])
+        return _t1055
 
     def parse_lt(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("<")
-        _t1036 = self.parse_term()
-        term523 = _t1036
-        _t1037 = self.parse_term()
-        term_3524 = _t1037
+        _t1056 = self.parse_term()
+        term533 = _t1056
+        _t1057 = self.parse_term()
+        term_3534 = _t1057
         self.consume_literal(")")
-        _t1038 = logic_pb2.RelTerm(term=term523)
-        _t1039 = logic_pb2.RelTerm(term=term_3524)
-        _t1040 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1038, _t1039])
-        return _t1040
+        _t1058 = logic_pb2.RelTerm(term=term533)
+        _t1059 = logic_pb2.RelTerm(term=term_3534)
+        _t1060 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1058, _t1059])
+        return _t1060
 
     def parse_lt_eq(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("<=")
-        _t1041 = self.parse_term()
-        term525 = _t1041
-        _t1042 = self.parse_term()
-        term_3526 = _t1042
+        _t1061 = self.parse_term()
+        term535 = _t1061
+        _t1062 = self.parse_term()
+        term_3536 = _t1062
         self.consume_literal(")")
-        _t1043 = logic_pb2.RelTerm(term=term525)
-        _t1044 = logic_pb2.RelTerm(term=term_3526)
-        _t1045 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1043, _t1044])
-        return _t1045
+        _t1063 = logic_pb2.RelTerm(term=term535)
+        _t1064 = logic_pb2.RelTerm(term=term_3536)
+        _t1065 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1063, _t1064])
+        return _t1065
 
     def parse_gt(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal(">")
-        _t1046 = self.parse_term()
-        term527 = _t1046
-        _t1047 = self.parse_term()
-        term_3528 = _t1047
+        _t1066 = self.parse_term()
+        term537 = _t1066
+        _t1067 = self.parse_term()
+        term_3538 = _t1067
         self.consume_literal(")")
-        _t1048 = logic_pb2.RelTerm(term=term527)
-        _t1049 = logic_pb2.RelTerm(term=term_3528)
-        _t1050 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1048, _t1049])
-        return _t1050
+        _t1068 = logic_pb2.RelTerm(term=term537)
+        _t1069 = logic_pb2.RelTerm(term=term_3538)
+        _t1070 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1068, _t1069])
+        return _t1070
 
     def parse_gt_eq(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal(">=")
-        _t1051 = self.parse_term()
-        term529 = _t1051
-        _t1052 = self.parse_term()
-        term_3530 = _t1052
+        _t1071 = self.parse_term()
+        term539 = _t1071
+        _t1072 = self.parse_term()
+        term_3540 = _t1072
         self.consume_literal(")")
-        _t1053 = logic_pb2.RelTerm(term=term529)
-        _t1054 = logic_pb2.RelTerm(term=term_3530)
-        _t1055 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1053, _t1054])
-        return _t1055
+        _t1073 = logic_pb2.RelTerm(term=term539)
+        _t1074 = logic_pb2.RelTerm(term=term_3540)
+        _t1075 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1073, _t1074])
+        return _t1075
 
     def parse_add(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("+")
-        _t1056 = self.parse_term()
-        term531 = _t1056
-        _t1057 = self.parse_term()
-        term_3532 = _t1057
-        _t1058 = self.parse_term()
-        term_4533 = _t1058
+        _t1076 = self.parse_term()
+        term541 = _t1076
+        _t1077 = self.parse_term()
+        term_3542 = _t1077
+        _t1078 = self.parse_term()
+        term_4543 = _t1078
         self.consume_literal(")")
-        _t1059 = logic_pb2.RelTerm(term=term531)
-        _t1060 = logic_pb2.RelTerm(term=term_3532)
-        _t1061 = logic_pb2.RelTerm(term=term_4533)
-        _t1062 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1059, _t1060, _t1061])
-        return _t1062
+        _t1079 = logic_pb2.RelTerm(term=term541)
+        _t1080 = logic_pb2.RelTerm(term=term_3542)
+        _t1081 = logic_pb2.RelTerm(term=term_4543)
+        _t1082 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1079, _t1080, _t1081])
+        return _t1082
 
     def parse_minus(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("-")
-        _t1063 = self.parse_term()
-        term534 = _t1063
-        _t1064 = self.parse_term()
-        term_3535 = _t1064
-        _t1065 = self.parse_term()
-        term_4536 = _t1065
-        self.consume_literal(")")
-        _t1066 = logic_pb2.RelTerm(term=term534)
-        _t1067 = logic_pb2.RelTerm(term=term_3535)
-        _t1068 = logic_pb2.RelTerm(term=term_4536)
-        _t1069 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1066, _t1067, _t1068])
-        return _t1069
+        _t1083 = self.parse_term()
+        term544 = _t1083
+        _t1084 = self.parse_term()
+        term_3545 = _t1084
+        _t1085 = self.parse_term()
+        term_4546 = _t1085
+        self.consume_literal(")")
+        _t1086 = logic_pb2.RelTerm(term=term544)
+        _t1087 = logic_pb2.RelTerm(term=term_3545)
+        _t1088 = logic_pb2.RelTerm(term=term_4546)
+        _t1089 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1086, _t1087, _t1088])
+        return _t1089
 
     def parse_multiply(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("*")
-        _t1070 = self.parse_term()
-        term537 = _t1070
-        _t1071 = self.parse_term()
-        term_3538 = _t1071
-        _t1072 = self.parse_term()
-        term_4539 = _t1072
-        self.consume_literal(")")
-        _t1073 = logic_pb2.RelTerm(term=term537)
-        _t1074 = logic_pb2.RelTerm(term=term_3538)
-        _t1075 = logic_pb2.RelTerm(term=term_4539)
-        _t1076 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1073, _t1074, _t1075])
-        return _t1076
+        _t1090 = self.parse_term()
+        term547 = _t1090
+        _t1091 = self.parse_term()
+        term_3548 = _t1091
+        _t1092 = self.parse_term()
+        term_4549 = _t1092
+        self.consume_literal(")")
+        _t1093 = logic_pb2.RelTerm(term=term547)
+        _t1094 = logic_pb2.RelTerm(term=term_3548)
+        _t1095 = logic_pb2.RelTerm(term=term_4549)
+        _t1096 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1093, _t1094, _t1095])
+        return _t1096
 
     def parse_divide(self) -> logic_pb2.Primitive:
         self.consume_literal("(")
         self.consume_literal("/")
-        _t1077 = self.parse_term()
-        term540 = _t1077
-        _t1078 = self.parse_term()
-        term_3541 = _t1078
-        _t1079 = self.parse_term()
-        term_4542 = _t1079
-        self.consume_literal(")")
-        _t1080 = logic_pb2.RelTerm(term=term540)
-        _t1081 = logic_pb2.RelTerm(term=term_3541)
-        _t1082 = logic_pb2.RelTerm(term=term_4542)
-        _t1083 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1080, _t1081, _t1082])
-        return _t1083
+        _t1097 = self.parse_term()
+        term550 = _t1097
+        _t1098 = self.parse_term()
+        term_3551 = _t1098
+        _t1099 = self.parse_term()
+        term_4552 = _t1099
+        self.consume_literal(")")
+        _t1100 = logic_pb2.RelTerm(term=term550)
+        _t1101 = logic_pb2.RelTerm(term=term_3551)
+        _t1102 = logic_pb2.RelTerm(term=term_4552)
+        _t1103 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1100, _t1101, _t1102])
+        return _t1103
 
     def parse_rel_term(self) -> logic_pb2.RelTerm:
         if self.match_lookahead_literal("true", 0):
-            _t1084 = 1
+            _t1104 = 1
         else:
             if self.match_lookahead_literal("missing", 0):
-                _t1085 = 1
+                _t1105 = 1
             else:
                 if self.match_lookahead_literal("false", 0):
-                    _t1086 = 1
+                    _t1106 = 1
                 else:
                     if self.match_lookahead_literal("(", 0):
-                        _t1087 = 1
+                        _t1107 = 1
                     else:
                         if self.match_lookahead_literal("#", 0):
-                            _t1088 = 0
+                            _t1108 = 0
                         else:
                             if self.match_lookahead_terminal("UINT128", 0):
-                                _t1089 = 1
+                                _t1109 = 1
                             else:
                                 if self.match_lookahead_terminal("SYMBOL", 0):
-                                    _t1090 = 1
+                                    _t1110 = 1
                                 else:
                                     if self.match_lookahead_terminal("STRING", 0):
-                                        _t1091 = 1
+                                        _t1111 = 1
                                     else:
                                         if self.match_lookahead_terminal("INT128", 0):
-                                            _t1092 = 1
+                                            _t1112 = 1
                                         else:
                                             if self.match_lookahead_terminal("INT", 0):
-                                                _t1093 = 1
+                                                _t1113 = 1
                                             else:
                                                 if self.match_lookahead_terminal("FLOAT", 0):
-                                                    _t1094 = 1
+                                                    _t1114 = 1
                                                 else:
                                                     if self.match_lookahead_terminal("DECIMAL", 0):
-                                                        _t1095 = 1
+                                                        _t1115 = 1
                                                     else:
-                                                        _t1095 = -1
-                                                    _t1094 = _t1095
-                                                _t1093 = _t1094
-                                            _t1092 = _t1093
-                                        _t1091 = _t1092
-                                    _t1090 = _t1091
-                                _t1089 = _t1090
-                            _t1088 = _t1089
-                        _t1087 = _t1088
-                    _t1086 = _t1087
-                _t1085 = _t1086
-            _t1084 = _t1085
-        prediction543 = _t1084
-        if prediction543 == 1:
-            _t1097 = self.parse_term()
-            term545 = _t1097
-            _t1098 = logic_pb2.RelTerm(term=term545)
-            _t1096 = _t1098
-        else:
-            if prediction543 == 0:
-                _t1100 = self.parse_specialized_value()
-                specialized_value544 = _t1100
-                _t1101 = logic_pb2.RelTerm(specialized_value=specialized_value544)
-                _t1099 = _t1101
+                                                        _t1115 = -1
+                                                    _t1114 = _t1115
+                                                _t1113 = _t1114
+                                            _t1112 = _t1113
+                                        _t1111 = _t1112
+                                    _t1110 = _t1111
+                                _t1109 = _t1110
+                            _t1108 = _t1109
+                        _t1107 = _t1108
+                    _t1106 = _t1107
+                _t1105 = _t1106
+            _t1104 = _t1105
+        prediction553 = _t1104
+        if prediction553 == 1:
+            _t1117 = self.parse_term()
+            term555 = _t1117
+            _t1118 = logic_pb2.RelTerm(term=term555)
+            _t1116 = _t1118
+        else:
+            if prediction553 == 0:
+                _t1120 = self.parse_specialized_value()
+                specialized_value554 = _t1120
+                _t1121 = logic_pb2.RelTerm(specialized_value=specialized_value554)
+                _t1119 = _t1121
             else:
                 raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-            _t1096 = _t1099
-        return _t1096
+            _t1116 = _t1119
+        return _t1116
 
     def parse_specialized_value(self) -> logic_pb2.Value:
         self.consume_literal("#")
-        _t1102 = self.parse_value()
-        value546 = _t1102
-        return value546
+        _t1122 = self.parse_value()
+        value556 = _t1122
+        return value556
 
     def parse_rel_atom(self) -> logic_pb2.RelAtom:
         self.consume_literal("(")
         self.consume_literal("relatom")
-        _t1103 = self.parse_name()
-        name547 = _t1103
-        xs548 = []
-        cond549 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        while cond549:
-            _t1104 = self.parse_rel_term()
-            item550 = _t1104
-            xs548.append(item550)
-            cond549 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        rel_terms551 = xs548
-        self.consume_literal(")")
-        _t1105 = logic_pb2.RelAtom(name=name547, terms=rel_terms551)
-        return _t1105
+        _t1123 = self.parse_name()
+        name557 = _t1123
+        xs558 = []
+        cond559 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        while cond559:
+            _t1124 = self.parse_rel_term()
+            item560 = _t1124
+            xs558.append(item560)
+            cond559 = (((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        rel_terms561 = xs558
+        self.consume_literal(")")
+        _t1125 = logic_pb2.RelAtom(name=name557, terms=rel_terms561)
+        return _t1125
 
     def parse_cast(self) -> logic_pb2.Cast:
         self.consume_literal("(")
         self.consume_literal("cast")
-        _t1106 = self.parse_term()
-        term552 = _t1106
-        _t1107 = self.parse_term()
-        term_3553 = _t1107
+        _t1126 = self.parse_term()
+        term562 = _t1126
+        _t1127 = self.parse_term()
+        term_3563 = _t1127
         self.consume_literal(")")
-        _t1108 = logic_pb2.Cast(input=term552, result=term_3553)
-        return _t1108
+        _t1128 = logic_pb2.Cast(input=term562, result=term_3563)
+        return _t1128
 
     def parse_attrs(self) -> Sequence[logic_pb2.Attribute]:
         self.consume_literal("(")
         self.consume_literal("attrs")
-        xs554 = []
-        cond555 = self.match_lookahead_literal("(", 0)
-        while cond555:
-            _t1109 = self.parse_attribute()
-            item556 = _t1109
-            xs554.append(item556)
-            cond555 = self.match_lookahead_literal("(", 0)
-        attributes557 = xs554
+        xs564 = []
+        cond565 = self.match_lookahead_literal("(", 0)
+        while cond565:
+            _t1129 = self.parse_attribute()
+            item566 = _t1129
+            xs564.append(item566)
+            cond565 = self.match_lookahead_literal("(", 0)
+        attributes567 = xs564
         self.consume_literal(")")
-        return attributes557
+        return attributes567
 
     def parse_attribute(self) -> logic_pb2.Attribute:
         self.consume_literal("(")
         self.consume_literal("attribute")
-        _t1110 = self.parse_name()
-        name558 = _t1110
-        xs559 = []
-        cond560 = (((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        while cond560:
-            _t1111 = self.parse_value()
-            item561 = _t1111
-            xs559.append(item561)
-            cond560 = (((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0))
-        values562 = xs559
-        self.consume_literal(")")
-        _t1112 = logic_pb2.Attribute(name=name558, args=values562)
-        return _t1112
+        _t1130 = self.parse_name()
+        name568 = _t1130
+        xs569 = []
+        cond570 = (((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        while cond570:
+            _t1131 = self.parse_value()
+            item571 = _t1131
+            xs569.append(item571)
+            cond570 = (((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0))
+        values572 = xs569
+        self.consume_literal(")")
+        _t1132 = logic_pb2.Attribute(name=name568, args=values572)
+        return _t1132
 
     def parse_algorithm(self) -> logic_pb2.Algorithm:
         self.consume_literal("(")
         self.consume_literal("algorithm")
-        xs563 = []
-        cond564 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
-        while cond564:
-            _t1113 = self.parse_relation_id()
-            item565 = _t1113
-            xs563.append(item565)
-            cond564 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
-        relation_ids566 = xs563
-        _t1114 = self.parse_script()
-        script567 = _t1114
-        self.consume_literal(")")
-        _t1115 = logic_pb2.Algorithm(body=script567)
-        getattr(_t1115, 'global').extend(relation_ids566)
-        return _t1115
+        xs573 = []
+        cond574 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
+        while cond574:
+            _t1133 = self.parse_relation_id()
+            item575 = _t1133
+            xs573.append(item575)
+            cond574 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
+        relation_ids576 = xs573
+        _t1134 = self.parse_script()
+        script577 = _t1134
+        self.consume_literal(")")
+        _t1135 = logic_pb2.Algorithm(body=script577)
+        getattr(_t1135, 'global').extend(relation_ids576)
+        return _t1135
 
     def parse_script(self) -> logic_pb2.Script:
         self.consume_literal("(")
         self.consume_literal("script")
-        xs568 = []
-        cond569 = self.match_lookahead_literal("(", 0)
-        while cond569:
-            _t1116 = self.parse_construct()
-            item570 = _t1116
-            xs568.append(item570)
-            cond569 = self.match_lookahead_literal("(", 0)
-        constructs571 = xs568
-        self.consume_literal(")")
-        _t1117 = logic_pb2.Script(constructs=constructs571)
-        return _t1117
+        xs578 = []
+        cond579 = self.match_lookahead_literal("(", 0)
+        while cond579:
+            _t1136 = self.parse_construct()
+            item580 = _t1136
+            xs578.append(item580)
+            cond579 = self.match_lookahead_literal("(", 0)
+        constructs581 = xs578
+        self.consume_literal(")")
+        _t1137 = logic_pb2.Script(constructs=constructs581)
+        return _t1137
 
     def parse_construct(self) -> logic_pb2.Construct:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("upsert", 1):
-                _t1119 = 1
+                _t1139 = 1
             else:
                 if self.match_lookahead_literal("monus", 1):
-                    _t1120 = 1
+                    _t1140 = 1
                 else:
                     if self.match_lookahead_literal("monoid", 1):
-                        _t1121 = 1
+                        _t1141 = 1
                     else:
                         if self.match_lookahead_literal("loop", 1):
-                            _t1122 = 0
+                            _t1142 = 0
                         else:
                             if self.match_lookahead_literal("break", 1):
-                                _t1123 = 1
+                                _t1143 = 1
                             else:
                                 if self.match_lookahead_literal("assign", 1):
-                                    _t1124 = 1
+                                    _t1144 = 1
                                 else:
-                                    _t1124 = -1
-                                _t1123 = _t1124
-                            _t1122 = _t1123
-                        _t1121 = _t1122
-                    _t1120 = _t1121
-                _t1119 = _t1120
-            _t1118 = _t1119
-        else:
-            _t1118 = -1
-        prediction572 = _t1118
-        if prediction572 == 1:
-            _t1126 = self.parse_instruction()
-            instruction574 = _t1126
-            _t1127 = logic_pb2.Construct(instruction=instruction574)
-            _t1125 = _t1127
-        else:
-            if prediction572 == 0:
-                _t1129 = self.parse_loop()
-                loop573 = _t1129
-                _t1130 = logic_pb2.Construct(loop=loop573)
-                _t1128 = _t1130
+                                    _t1144 = -1
+                                _t1143 = _t1144
+                            _t1142 = _t1143
+                        _t1141 = _t1142
+                    _t1140 = _t1141
+                _t1139 = _t1140
+            _t1138 = _t1139
+        else:
+            _t1138 = -1
+        prediction582 = _t1138
+        if prediction582 == 1:
+            _t1146 = self.parse_instruction()
+            instruction584 = _t1146
+            _t1147 = logic_pb2.Construct(instruction=instruction584)
+            _t1145 = _t1147
+        else:
+            if prediction582 == 0:
+                _t1149 = self.parse_loop()
+                loop583 = _t1149
+                _t1150 = logic_pb2.Construct(loop=loop583)
+                _t1148 = _t1150
             else:
                 raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-            _t1125 = _t1128
-        return _t1125
+            _t1145 = _t1148
+        return _t1145
 
     def parse_loop(self) -> logic_pb2.Loop:
         self.consume_literal("(")
         self.consume_literal("loop")
-        _t1131 = self.parse_init()
-        init575 = _t1131
-        _t1132 = self.parse_script()
-        script576 = _t1132
+        _t1151 = self.parse_init()
+        init585 = _t1151
+        _t1152 = self.parse_script()
+        script586 = _t1152
         self.consume_literal(")")
-        _t1133 = logic_pb2.Loop(init=init575, body=script576)
-        return _t1133
+        _t1153 = logic_pb2.Loop(init=init585, body=script586)
+        return _t1153
 
     def parse_init(self) -> Sequence[logic_pb2.Instruction]:
         self.consume_literal("(")
         self.consume_literal("init")
-        xs577 = []
-        cond578 = self.match_lookahead_literal("(", 0)
-        while cond578:
-            _t1134 = self.parse_instruction()
-            item579 = _t1134
-            xs577.append(item579)
-            cond578 = self.match_lookahead_literal("(", 0)
-        instructions580 = xs577
+        xs587 = []
+        cond588 = self.match_lookahead_literal("(", 0)
+        while cond588:
+            _t1154 = self.parse_instruction()
+            item589 = _t1154
+            xs587.append(item589)
+            cond588 = self.match_lookahead_literal("(", 0)
+        instructions590 = xs587
         self.consume_literal(")")
-        return instructions580
+        return instructions590
 
     def parse_instruction(self) -> logic_pb2.Instruction:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("upsert", 1):
-                _t1136 = 1
+                _t1156 = 1
             else:
                 if self.match_lookahead_literal("monus", 1):
-                    _t1137 = 4
+                    _t1157 = 4
                 else:
                     if self.match_lookahead_literal("monoid", 1):
-                        _t1138 = 3
+                        _t1158 = 3
                     else:
                         if self.match_lookahead_literal("break", 1):
-                            _t1139 = 2
+                            _t1159 = 2
                         else:
                             if self.match_lookahead_literal("assign", 1):
-                                _t1140 = 0
+                                _t1160 = 0
                             else:
-                                _t1140 = -1
-                            _t1139 = _t1140
-                        _t1138 = _t1139
-                    _t1137 = _t1138
-                _t1136 = _t1137
-            _t1135 = _t1136
-        else:
-            _t1135 = -1
-        prediction581 = _t1135
-        if prediction581 == 4:
-            _t1142 = self.parse_monus_def()
-            monus_def586 = _t1142
-            _t1143 = logic_pb2.Instruction(monus_def=monus_def586)
-            _t1141 = _t1143
-        else:
-            if prediction581 == 3:
-                _t1145 = self.parse_monoid_def()
-                monoid_def585 = _t1145
-                _t1146 = logic_pb2.Instruction(monoid_def=monoid_def585)
-                _t1144 = _t1146
+                                _t1160 = -1
+                            _t1159 = _t1160
+                        _t1158 = _t1159
+                    _t1157 = _t1158
+                _t1156 = _t1157
+            _t1155 = _t1156
+        else:
+            _t1155 = -1
+        prediction591 = _t1155
+        if prediction591 == 4:
+            _t1162 = self.parse_monus_def()
+            monus_def596 = _t1162
+            _t1163 = logic_pb2.Instruction(monus_def=monus_def596)
+            _t1161 = _t1163
+        else:
+            if prediction591 == 3:
+                _t1165 = self.parse_monoid_def()
+                monoid_def595 = _t1165
+                _t1166 = logic_pb2.Instruction(monoid_def=monoid_def595)
+                _t1164 = _t1166
             else:
-                if prediction581 == 2:
-                    _t1148 = self.parse_break()
-                    break584 = _t1148
-                    _t1149 = logic_pb2.Instruction()
-                    getattr(_t1149, 'break').CopyFrom(break584)
-                    _t1147 = _t1149
+                if prediction591 == 2:
+                    _t1168 = self.parse_break()
+                    break594 = _t1168
+                    _t1169 = logic_pb2.Instruction()
+                    getattr(_t1169, 'break').CopyFrom(break594)
+                    _t1167 = _t1169
                 else:
-                    if prediction581 == 1:
-                        _t1151 = self.parse_upsert()
-                        upsert583 = _t1151
-                        _t1152 = logic_pb2.Instruction(upsert=upsert583)
-                        _t1150 = _t1152
+                    if prediction591 == 1:
+                        _t1171 = self.parse_upsert()
+                        upsert593 = _t1171
+                        _t1172 = logic_pb2.Instruction(upsert=upsert593)
+                        _t1170 = _t1172
                     else:
-                        if prediction581 == 0:
-                            _t1154 = self.parse_assign()
-                            assign582 = _t1154
-                            _t1155 = logic_pb2.Instruction(assign=assign582)
-                            _t1153 = _t1155
+                        if prediction591 == 0:
+                            _t1174 = self.parse_assign()
+                            assign592 = _t1174
+                            _t1175 = logic_pb2.Instruction(assign=assign592)
+                            _t1173 = _t1175
                         else:
                             raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                        _t1150 = _t1153
-                    _t1147 = _t1150
-                _t1144 = _t1147
-            _t1141 = _t1144
-        return _t1141
+                        _t1170 = _t1173
+                    _t1167 = _t1170
+                _t1164 = _t1167
+            _t1161 = _t1164
+        return _t1161
 
     def parse_assign(self) -> logic_pb2.Assign:
         self.consume_literal("(")
         self.consume_literal("assign")
-        _t1156 = self.parse_relation_id()
-        relation_id587 = _t1156
-        _t1157 = self.parse_abstraction()
-        abstraction588 = _t1157
+        _t1176 = self.parse_relation_id()
+        relation_id597 = _t1176
+        _t1177 = self.parse_abstraction()
+        abstraction598 = _t1177
         if self.match_lookahead_literal("(", 0):
-            _t1159 = self.parse_attrs()
-            _t1158 = _t1159
+            _t1179 = self.parse_attrs()
+            _t1178 = _t1179
         else:
-            _t1158 = None
-        attrs589 = _t1158
+            _t1178 = None
+        attrs599 = _t1178
         self.consume_literal(")")
-        _t1160 = logic_pb2.Assign(name=relation_id587, body=abstraction588, attrs=(attrs589 if attrs589 is not None else []))
-        return _t1160
+        _t1180 = logic_pb2.Assign(name=relation_id597, body=abstraction598, attrs=(attrs599 if attrs599 is not None else []))
+        return _t1180
 
     def parse_upsert(self) -> logic_pb2.Upsert:
         self.consume_literal("(")
         self.consume_literal("upsert")
-        _t1161 = self.parse_relation_id()
-        relation_id590 = _t1161
-        _t1162 = self.parse_abstraction_with_arity()
-        abstraction_with_arity591 = _t1162
+        _t1181 = self.parse_relation_id()
+        relation_id600 = _t1181
+        _t1182 = self.parse_abstraction_with_arity()
+        abstraction_with_arity601 = _t1182
         if self.match_lookahead_literal("(", 0):
-            _t1164 = self.parse_attrs()
-            _t1163 = _t1164
+            _t1184 = self.parse_attrs()
+            _t1183 = _t1184
         else:
-            _t1163 = None
-        attrs592 = _t1163
+            _t1183 = None
+        attrs602 = _t1183
         self.consume_literal(")")
-        _t1165 = logic_pb2.Upsert(name=relation_id590, body=abstraction_with_arity591[0], attrs=(attrs592 if attrs592 is not None else []), value_arity=abstraction_with_arity591[1])
-        return _t1165
+        _t1185 = logic_pb2.Upsert(name=relation_id600, body=abstraction_with_arity601[0], attrs=(attrs602 if attrs602 is not None else []), value_arity=abstraction_with_arity601[1])
+        return _t1185
 
     def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]:
         self.consume_literal("(")
-        _t1166 = self.parse_bindings()
-        bindings593 = _t1166
-        _t1167 = self.parse_formula()
-        formula594 = _t1167
+        _t1186 = self.parse_bindings()
+        bindings603 = _t1186
+        _t1187 = self.parse_formula()
+        formula604 = _t1187
         self.consume_literal(")")
-        _t1168 = logic_pb2.Abstraction(vars=(list(bindings593[0]) + list(bindings593[1] if bindings593[1] is not None else [])), value=formula594)
-        return (_t1168, len(bindings593[1]),)
+        _t1188 = logic_pb2.Abstraction(vars=(list(bindings603[0]) + list(bindings603[1] if bindings603[1] is not None else [])), value=formula604)
+        return (_t1188, len(bindings603[1]),)
 
     def parse_break(self) -> logic_pb2.Break:
         self.consume_literal("(")
         self.consume_literal("break")
-        _t1169 = self.parse_relation_id()
-        relation_id595 = _t1169
-        _t1170 = self.parse_abstraction()
-        abstraction596 = _t1170
+        _t1189 = self.parse_relation_id()
+        relation_id605 = _t1189
+        _t1190 = self.parse_abstraction()
+        abstraction606 = _t1190
         if self.match_lookahead_literal("(", 0):
-            _t1172 = self.parse_attrs()
-            _t1171 = _t1172
+            _t1192 = self.parse_attrs()
+            _t1191 = _t1192
         else:
-            _t1171 = None
-        attrs597 = _t1171
+            _t1191 = None
+        attrs607 = _t1191
         self.consume_literal(")")
-        _t1173 = logic_pb2.Break(name=relation_id595, body=abstraction596, attrs=(attrs597 if attrs597 is not None else []))
-        return _t1173
+        _t1193 = logic_pb2.Break(name=relation_id605, body=abstraction606, attrs=(attrs607 if attrs607 is not None else []))
+        return _t1193
 
     def parse_monoid_def(self) -> logic_pb2.MonoidDef:
         self.consume_literal("(")
         self.consume_literal("monoid")
-        _t1174 = self.parse_monoid()
-        monoid598 = _t1174
-        _t1175 = self.parse_relation_id()
-        relation_id599 = _t1175
-        _t1176 = self.parse_abstraction_with_arity()
-        abstraction_with_arity600 = _t1176
+        _t1194 = self.parse_monoid()
+        monoid608 = _t1194
+        _t1195 = self.parse_relation_id()
+        relation_id609 = _t1195
+        _t1196 = self.parse_abstraction_with_arity()
+        abstraction_with_arity610 = _t1196
         if self.match_lookahead_literal("(", 0):
-            _t1178 = self.parse_attrs()
-            _t1177 = _t1178
+            _t1198 = self.parse_attrs()
+            _t1197 = _t1198
         else:
-            _t1177 = None
-        attrs601 = _t1177
+            _t1197 = None
+        attrs611 = _t1197
         self.consume_literal(")")
-        _t1179 = logic_pb2.MonoidDef(monoid=monoid598, name=relation_id599, body=abstraction_with_arity600[0], attrs=(attrs601 if attrs601 is not None else []), value_arity=abstraction_with_arity600[1])
-        return _t1179
+        _t1199 = logic_pb2.MonoidDef(monoid=monoid608, name=relation_id609, body=abstraction_with_arity610[0], attrs=(attrs611 if attrs611 is not None else []), value_arity=abstraction_with_arity610[1])
+        return _t1199
 
     def parse_monoid(self) -> logic_pb2.Monoid:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("sum", 1):
-                _t1181 = 3
+                _t1201 = 3
             else:
                 if self.match_lookahead_literal("or", 1):
-                    _t1182 = 0
+                    _t1202 = 0
                 else:
                     if self.match_lookahead_literal("min", 1):
-                        _t1183 = 1
+                        _t1203 = 1
                     else:
                         if self.match_lookahead_literal("max", 1):
-                            _t1184 = 2
+                            _t1204 = 2
                         else:
-                            _t1184 = -1
-                        _t1183 = _t1184
-                    _t1182 = _t1183
-                _t1181 = _t1182
-            _t1180 = _t1181
-        else:
-            _t1180 = -1
-        prediction602 = _t1180
-        if prediction602 == 3:
-            _t1186 = self.parse_sum_monoid()
-            sum_monoid606 = _t1186
-            _t1187 = logic_pb2.Monoid(sum_monoid=sum_monoid606)
-            _t1185 = _t1187
-        else:
-            if prediction602 == 2:
-                _t1189 = self.parse_max_monoid()
-                max_monoid605 = _t1189
-                _t1190 = logic_pb2.Monoid(max_monoid=max_monoid605)
-                _t1188 = _t1190
+                            _t1204 = -1
+                        _t1203 = _t1204
+                    _t1202 = _t1203
+                _t1201 = _t1202
+            _t1200 = _t1201
+        else:
+            _t1200 = -1
+        prediction612 = _t1200
+        if prediction612 == 3:
+            _t1206 = self.parse_sum_monoid()
+            sum_monoid616 = _t1206
+            _t1207 = logic_pb2.Monoid(sum_monoid=sum_monoid616)
+            _t1205 = _t1207
+        else:
+            if prediction612 == 2:
+                _t1209 = self.parse_max_monoid()
+                max_monoid615 = _t1209
+                _t1210 = logic_pb2.Monoid(max_monoid=max_monoid615)
+                _t1208 = _t1210
             else:
-                if prediction602 == 1:
-                    _t1192 = self.parse_min_monoid()
-                    min_monoid604 = _t1192
-                    _t1193 = logic_pb2.Monoid(min_monoid=min_monoid604)
-                    _t1191 = _t1193
+                if prediction612 == 1:
+                    _t1212 = self.parse_min_monoid()
+                    min_monoid614 = _t1212
+                    _t1213 = logic_pb2.Monoid(min_monoid=min_monoid614)
+                    _t1211 = _t1213
                 else:
-                    if prediction602 == 0:
-                        _t1195 = self.parse_or_monoid()
-                        or_monoid603 = _t1195
-                        _t1196 = logic_pb2.Monoid(or_monoid=or_monoid603)
-                        _t1194 = _t1196
+                    if prediction612 == 0:
+                        _t1215 = self.parse_or_monoid()
+                        or_monoid613 = _t1215
+                        _t1216 = logic_pb2.Monoid(or_monoid=or_monoid613)
+                        _t1214 = _t1216
                     else:
                         raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                    _t1191 = _t1194
-                _t1188 = _t1191
-            _t1185 = _t1188
-        return _t1185
+                    _t1211 = _t1214
+                _t1208 = _t1211
+            _t1205 = _t1208
+        return _t1205
 
     def parse_or_monoid(self) -> logic_pb2.OrMonoid:
         self.consume_literal("(")
         self.consume_literal("or")
         self.consume_literal(")")
-        _t1197 = logic_pb2.OrMonoid()
-        return _t1197
+        _t1217 = logic_pb2.OrMonoid()
+        return _t1217
 
     def parse_min_monoid(self) -> logic_pb2.MinMonoid:
         self.consume_literal("(")
         self.consume_literal("min")
-        _t1198 = self.parse_type()
-        type607 = _t1198
+        _t1218 = self.parse_type()
+        type617 = _t1218
         self.consume_literal(")")
-        _t1199 = logic_pb2.MinMonoid(type=type607)
-        return _t1199
+        _t1219 = logic_pb2.MinMonoid(type=type617)
+        return _t1219
 
     def parse_max_monoid(self) -> logic_pb2.MaxMonoid:
         self.consume_literal("(")
         self.consume_literal("max")
-        _t1200 = self.parse_type()
-        type608 = _t1200
+        _t1220 = self.parse_type()
+        type618 = _t1220
         self.consume_literal(")")
-        _t1201 = logic_pb2.MaxMonoid(type=type608)
-        return _t1201
+        _t1221 = logic_pb2.MaxMonoid(type=type618)
+        return _t1221
 
     def parse_sum_monoid(self) -> logic_pb2.SumMonoid:
         self.consume_literal("(")
         self.consume_literal("sum")
-        _t1202 = self.parse_type()
-        type609 = _t1202
+        _t1222 = self.parse_type()
+        type619 = _t1222
         self.consume_literal(")")
-        _t1203 = logic_pb2.SumMonoid(type=type609)
-        return _t1203
+        _t1223 = logic_pb2.SumMonoid(type=type619)
+        return _t1223
 
     def parse_monus_def(self) -> logic_pb2.MonusDef:
         self.consume_literal("(")
         self.consume_literal("monus")
-        _t1204 = self.parse_monoid()
-        monoid610 = _t1204
-        _t1205 = self.parse_relation_id()
-        relation_id611 = _t1205
-        _t1206 = self.parse_abstraction_with_arity()
-        abstraction_with_arity612 = _t1206
+        _t1224 = self.parse_monoid()
+        monoid620 = _t1224
+        _t1225 = self.parse_relation_id()
+        relation_id621 = _t1225
+        _t1226 = self.parse_abstraction_with_arity()
+        abstraction_with_arity622 = _t1226
         if self.match_lookahead_literal("(", 0):
-            _t1208 = self.parse_attrs()
-            _t1207 = _t1208
+            _t1228 = self.parse_attrs()
+            _t1227 = _t1228
         else:
-            _t1207 = None
-        attrs613 = _t1207
+            _t1227 = None
+        attrs623 = _t1227
         self.consume_literal(")")
-        _t1209 = logic_pb2.MonusDef(monoid=monoid610, name=relation_id611, body=abstraction_with_arity612[0], attrs=(attrs613 if attrs613 is not None else []), value_arity=abstraction_with_arity612[1])
-        return _t1209
+        _t1229 = logic_pb2.MonusDef(monoid=monoid620, name=relation_id621, body=abstraction_with_arity622[0], attrs=(attrs623 if attrs623 is not None else []), value_arity=abstraction_with_arity622[1])
+        return _t1229
 
     def parse_constraint(self) -> logic_pb2.Constraint:
         self.consume_literal("(")
         self.consume_literal("functional_dependency")
-        _t1210 = self.parse_relation_id()
-        relation_id614 = _t1210
-        _t1211 = self.parse_abstraction()
-        abstraction615 = _t1211
-        _t1212 = self.parse_functional_dependency_keys()
-        functional_dependency_keys616 = _t1212
-        _t1213 = self.parse_functional_dependency_values()
-        functional_dependency_values617 = _t1213
-        self.consume_literal(")")
-        _t1214 = logic_pb2.FunctionalDependency(guard=abstraction615, keys=functional_dependency_keys616, values=functional_dependency_values617)
-        _t1215 = logic_pb2.Constraint(name=relation_id614, functional_dependency=_t1214)
-        return _t1215
+        _t1230 = self.parse_relation_id()
+        relation_id624 = _t1230
+        _t1231 = self.parse_abstraction()
+        abstraction625 = _t1231
+        _t1232 = self.parse_functional_dependency_keys()
+        functional_dependency_keys626 = _t1232
+        _t1233 = self.parse_functional_dependency_values()
+        functional_dependency_values627 = _t1233
+        self.consume_literal(")")
+        _t1234 = logic_pb2.FunctionalDependency(guard=abstraction625, keys=functional_dependency_keys626, values=functional_dependency_values627)
+        _t1235 = logic_pb2.Constraint(name=relation_id624, functional_dependency=_t1234)
+        return _t1235
 
     def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]:
         self.consume_literal("(")
         self.consume_literal("keys")
-        xs618 = []
-        cond619 = self.match_lookahead_terminal("SYMBOL", 0)
-        while cond619:
-            _t1216 = self.parse_var()
-            item620 = _t1216
-            xs618.append(item620)
-            cond619 = self.match_lookahead_terminal("SYMBOL", 0)
-        vars621 = xs618
+        xs628 = []
+        cond629 = self.match_lookahead_terminal("SYMBOL", 0)
+        while cond629:
+            _t1236 = self.parse_var()
+            item630 = _t1236
+            xs628.append(item630)
+            cond629 = self.match_lookahead_terminal("SYMBOL", 0)
+        vars631 = xs628
         self.consume_literal(")")
-        return vars621
+        return vars631
 
     def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]:
         self.consume_literal("(")
         self.consume_literal("values")
-        xs622 = []
-        cond623 = self.match_lookahead_terminal("SYMBOL", 0)
-        while cond623:
-            _t1217 = self.parse_var()
-            item624 = _t1217
-            xs622.append(item624)
-            cond623 = self.match_lookahead_terminal("SYMBOL", 0)
-        vars625 = xs622
+        xs632 = []
+        cond633 = self.match_lookahead_terminal("SYMBOL", 0)
+        while cond633:
+            _t1237 = self.parse_var()
+            item634 = _t1237
+            xs632.append(item634)
+            cond633 = self.match_lookahead_terminal("SYMBOL", 0)
+        vars635 = xs632
         self.consume_literal(")")
-        return vars625
+        return vars635
 
     def parse_data(self) -> logic_pb2.Data:
         if self.match_lookahead_literal("(", 0):
-            if self.match_lookahead_literal("rel_edb", 1):
-                _t1219 = 0
+            if self.match_lookahead_literal("edb", 1):
+                _t1239 = 0
             else:
                 if self.match_lookahead_literal("csv_data", 1):
-                    _t1220 = 2
+                    _t1240 = 2
                 else:
                     if self.match_lookahead_literal("betree_relation", 1):
-                        _t1221 = 1
+                        _t1241 = 1
                     else:
-                        _t1221 = -1
-                    _t1220 = _t1221
-                _t1219 = _t1220
-            _t1218 = _t1219
-        else:
-            _t1218 = -1
-        prediction626 = _t1218
-        if prediction626 == 2:
-            _t1223 = self.parse_csv_data()
-            csv_data629 = _t1223
-            _t1224 = logic_pb2.Data(csv_data=csv_data629)
-            _t1222 = _t1224
-        else:
-            if prediction626 == 1:
-                _t1226 = self.parse_betree_relation()
-                betree_relation628 = _t1226
-                _t1227 = logic_pb2.Data(betree_relation=betree_relation628)
-                _t1225 = _t1227
+                        _t1241 = -1
+                    _t1240 = _t1241
+                _t1239 = _t1240
+            _t1238 = _t1239
+        else:
+            _t1238 = -1
+        prediction636 = _t1238
+        if prediction636 == 2:
+            _t1243 = self.parse_csv_data()
+            csv_data639 = _t1243
+            _t1244 = logic_pb2.Data(csv_data=csv_data639)
+            _t1242 = _t1244
+        else:
+            if prediction636 == 1:
+                _t1246 = self.parse_betree_relation()
+                betree_relation638 = _t1246
+                _t1247 = logic_pb2.Data(betree_relation=betree_relation638)
+                _t1245 = _t1247
             else:
-                if prediction626 == 0:
-                    _t1229 = self.parse_rel_edb()
-                    rel_edb627 = _t1229
-                    _t1230 = logic_pb2.Data(rel_edb=rel_edb627)
-                    _t1228 = _t1230
+                if prediction636 == 0:
+                    _t1249 = self.parse_edb()
+                    edb637 = _t1249
+                    _t1250 = logic_pb2.Data(edb=edb637)
+                    _t1248 = _t1250
                 else:
                     raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                _t1225 = _t1228
-            _t1222 = _t1225
-        return _t1222
+                _t1245 = _t1248
+            _t1242 = _t1245
+        return _t1242
 
-    def parse_rel_edb(self) -> logic_pb2.RelEDB:
+    def parse_edb(self) -> logic_pb2.EDB:
         self.consume_literal("(")
-        self.consume_literal("rel_edb")
-        _t1231 = self.parse_relation_id()
-        relation_id630 = _t1231
-        _t1232 = self.parse_rel_edb_path()
-        rel_edb_path631 = _t1232
-        _t1233 = self.parse_rel_edb_types()
-        rel_edb_types632 = _t1233
+        self.consume_literal("edb")
+        _t1251 = self.parse_relation_id()
+        relation_id640 = _t1251
+        _t1252 = self.parse_edb_path()
+        edb_path641 = _t1252
+        _t1253 = self.parse_edb_types()
+        edb_types642 = _t1253
         self.consume_literal(")")
-        _t1234 = logic_pb2.RelEDB(target_id=relation_id630, path=rel_edb_path631, types=rel_edb_types632)
-        return _t1234
+        _t1254 = logic_pb2.EDB(target_id=relation_id640, path=edb_path641, types=edb_types642)
+        return _t1254
 
-    def parse_rel_edb_path(self) -> Sequence[str]:
+    def parse_edb_path(self) -> Sequence[str]:
         self.consume_literal("[")
-        xs633 = []
-        cond634 = self.match_lookahead_terminal("STRING", 0)
-        while cond634:
-            item635 = self.consume_terminal("STRING")
-            xs633.append(item635)
-            cond634 = self.match_lookahead_terminal("STRING", 0)
-        strings636 = xs633
+        xs643 = []
+        cond644 = self.match_lookahead_terminal("STRING", 0)
+        while cond644:
+            item645 = self.consume_terminal("STRING")
+            xs643.append(item645)
+            cond644 = self.match_lookahead_terminal("STRING", 0)
+        strings646 = xs643
         self.consume_literal("]")
-        return strings636
+        return strings646
 
-    def parse_rel_edb_types(self) -> Sequence[logic_pb2.Type]:
+    def parse_edb_types(self) -> Sequence[logic_pb2.Type]:
         self.consume_literal("[")
-        xs637 = []
-        cond638 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        while cond638:
-            _t1235 = self.parse_type()
-            item639 = _t1235
-            xs637.append(item639)
-            cond638 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        types640 = xs637
+        xs647 = []
+        cond648 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        while cond648:
+            _t1255 = self.parse_type()
+            item649 = _t1255
+            xs647.append(item649)
+            cond648 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        types650 = xs647
         self.consume_literal("]")
-        return types640
+        return types650
 
     def parse_betree_relation(self) -> logic_pb2.BeTreeRelation:
         self.consume_literal("(")
         self.consume_literal("betree_relation")
-        _t1236 = self.parse_relation_id()
-        relation_id641 = _t1236
-        _t1237 = self.parse_betree_info()
-        betree_info642 = _t1237
+        _t1256 = self.parse_relation_id()
+        relation_id651 = _t1256
+        _t1257 = self.parse_betree_info()
+        betree_info652 = _t1257
         self.consume_literal(")")
-        _t1238 = logic_pb2.BeTreeRelation(name=relation_id641, relation_info=betree_info642)
-        return _t1238
+        _t1258 = logic_pb2.BeTreeRelation(name=relation_id651, relation_info=betree_info652)
+        return _t1258
 
     def parse_betree_info(self) -> logic_pb2.BeTreeInfo:
         self.consume_literal("(")
         self.consume_literal("betree_info")
-        _t1239 = self.parse_betree_info_key_types()
-        betree_info_key_types643 = _t1239
-        _t1240 = self.parse_betree_info_value_types()
-        betree_info_value_types644 = _t1240
-        _t1241 = self.parse_config_dict()
-        config_dict645 = _t1241
-        self.consume_literal(")")
-        _t1242 = self.construct_betree_info(betree_info_key_types643, betree_info_value_types644, config_dict645)
-        return _t1242
+        _t1259 = self.parse_betree_info_key_types()
+        betree_info_key_types653 = _t1259
+        _t1260 = self.parse_betree_info_value_types()
+        betree_info_value_types654 = _t1260
+        _t1261 = self.parse_config_dict()
+        config_dict655 = _t1261
+        self.consume_literal(")")
+        _t1262 = self.construct_betree_info(betree_info_key_types653, betree_info_value_types654, config_dict655)
+        return _t1262
 
     def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]:
         self.consume_literal("(")
         self.consume_literal("key_types")
-        xs646 = []
-        cond647 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        while cond647:
-            _t1243 = self.parse_type()
-            item648 = _t1243
-            xs646.append(item648)
-            cond647 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        types649 = xs646
+        xs656 = []
+        cond657 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        while cond657:
+            _t1263 = self.parse_type()
+            item658 = _t1263
+            xs656.append(item658)
+            cond657 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        types659 = xs656
         self.consume_literal(")")
-        return types649
+        return types659
 
     def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]:
         self.consume_literal("(")
         self.consume_literal("value_types")
-        xs650 = []
-        cond651 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        while cond651:
-            _t1244 = self.parse_type()
-            item652 = _t1244
-            xs650.append(item652)
-            cond651 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        types653 = xs650
+        xs660 = []
+        cond661 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        while cond661:
+            _t1264 = self.parse_type()
+            item662 = _t1264
+            xs660.append(item662)
+            cond661 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        types663 = xs660
         self.consume_literal(")")
-        return types653
+        return types663
 
     def parse_csv_data(self) -> logic_pb2.CSVData:
         self.consume_literal("(")
         self.consume_literal("csv_data")
-        _t1245 = self.parse_csvlocator()
-        csvlocator654 = _t1245
-        _t1246 = self.parse_csv_config()
-        csv_config655 = _t1246
-        _t1247 = self.parse_csv_columns()
-        csv_columns656 = _t1247
-        _t1248 = self.parse_csv_asof()
-        csv_asof657 = _t1248
-        self.consume_literal(")")
-        _t1249 = logic_pb2.CSVData(locator=csvlocator654, config=csv_config655, columns=csv_columns656, asof=csv_asof657)
-        return _t1249
+        _t1265 = self.parse_csvlocator()
+        csvlocator664 = _t1265
+        _t1266 = self.parse_csv_config()
+        csv_config665 = _t1266
+        _t1267 = self.parse_gnf_columns()
+        gnf_columns666 = _t1267
+        _t1268 = self.parse_csv_asof()
+        csv_asof667 = _t1268
+        self.consume_literal(")")
+        _t1269 = logic_pb2.CSVData(locator=csvlocator664, config=csv_config665, columns=gnf_columns666, asof=csv_asof667)
+        return _t1269
 
     def parse_csvlocator(self) -> logic_pb2.CSVLocator:
         self.consume_literal("(")
         self.consume_literal("csv_locator")
         if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)):
-            _t1251 = self.parse_csv_locator_paths()
-            _t1250 = _t1251
+            _t1271 = self.parse_csv_locator_paths()
+            _t1270 = _t1271
         else:
-            _t1250 = None
-        csv_locator_paths658 = _t1250
+            _t1270 = None
+        csv_locator_paths668 = _t1270
         if self.match_lookahead_literal("(", 0):
-            _t1253 = self.parse_csv_locator_inline_data()
-            _t1252 = _t1253
+            _t1273 = self.parse_csv_locator_inline_data()
+            _t1272 = _t1273
         else:
-            _t1252 = None
-        csv_locator_inline_data659 = _t1252
+            _t1272 = None
+        csv_locator_inline_data669 = _t1272
         self.consume_literal(")")
-        _t1254 = logic_pb2.CSVLocator(paths=(csv_locator_paths658 if csv_locator_paths658 is not None else []), inline_data=(csv_locator_inline_data659 if csv_locator_inline_data659 is not None else "").encode())
-        return _t1254
+        _t1274 = logic_pb2.CSVLocator(paths=(csv_locator_paths668 if csv_locator_paths668 is not None else []), inline_data=(csv_locator_inline_data669 if csv_locator_inline_data669 is not None else "").encode())
+        return _t1274
 
     def parse_csv_locator_paths(self) -> Sequence[str]:
         self.consume_literal("(")
         self.consume_literal("paths")
-        xs660 = []
-        cond661 = self.match_lookahead_terminal("STRING", 0)
-        while cond661:
-            item662 = self.consume_terminal("STRING")
-            xs660.append(item662)
-            cond661 = self.match_lookahead_terminal("STRING", 0)
-        strings663 = xs660
+        xs670 = []
+        cond671 = self.match_lookahead_terminal("STRING", 0)
+        while cond671:
+            item672 = self.consume_terminal("STRING")
+            xs670.append(item672)
+            cond671 = self.match_lookahead_terminal("STRING", 0)
+        strings673 = xs670
         self.consume_literal(")")
-        return strings663
+        return strings673
 
     def parse_csv_locator_inline_data(self) -> str:
         self.consume_literal("(")
         self.consume_literal("inline_data")
-        string664 = self.consume_terminal("STRING")
+        string674 = self.consume_terminal("STRING")
         self.consume_literal(")")
-        return string664
+        return string674
 
     def parse_csv_config(self) -> logic_pb2.CSVConfig:
         self.consume_literal("(")
         self.consume_literal("csv_config")
-        _t1255 = self.parse_config_dict()
-        config_dict665 = _t1255
+        _t1275 = self.parse_config_dict()
+        config_dict675 = _t1275
         self.consume_literal(")")
-        _t1256 = self.construct_csv_config(config_dict665)
-        return _t1256
+        _t1276 = self.construct_csv_config(config_dict675)
+        return _t1276
 
-    def parse_csv_columns(self) -> Sequence[logic_pb2.CSVColumn]:
+    def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]:
         self.consume_literal("(")
         self.consume_literal("columns")
-        xs666 = []
-        cond667 = self.match_lookahead_literal("(", 0)
-        while cond667:
-            _t1257 = self.parse_csv_column()
-            item668 = _t1257
-            xs666.append(item668)
-            cond667 = self.match_lookahead_literal("(", 0)
-        csv_columns669 = xs666
+        xs676 = []
+        cond677 = self.match_lookahead_literal("(", 0)
+        while cond677:
+            _t1277 = self.parse_gnf_column()
+            item678 = _t1277
+            xs676.append(item678)
+            cond677 = self.match_lookahead_literal("(", 0)
+        gnf_columns679 = xs676
         self.consume_literal(")")
-        return csv_columns669
+        return gnf_columns679
 
-    def parse_csv_column(self) -> logic_pb2.CSVColumn:
+    def parse_gnf_column(self) -> logic_pb2.GNFColumn:
         self.consume_literal("(")
         self.consume_literal("column")
-        string670 = self.consume_terminal("STRING")
-        _t1258 = self.parse_relation_id()
-        relation_id671 = _t1258
+        _t1278 = self.parse_gnf_column_path()
+        gnf_column_path680 = _t1278
+        if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)):
+            _t1280 = self.parse_relation_id()
+            _t1279 = _t1280
+        else:
+            _t1279 = None
+        relation_id681 = _t1279
         self.consume_literal("[")
-        xs672 = []
-        cond673 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        while cond673:
-            _t1259 = self.parse_type()
-            item674 = _t1259
-            xs672.append(item674)
-            cond673 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
-        types675 = xs672
+        xs682 = []
+        cond683 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        while cond683:
+            _t1281 = self.parse_type()
+            item684 = _t1281
+            xs682.append(item684)
+            cond683 = ((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UNKNOWN", 0))
+        types685 = xs682
         self.consume_literal("]")
         self.consume_literal(")")
-        _t1260 = logic_pb2.CSVColumn(column_name=string670, target_id=relation_id671, types=types675)
-        return _t1260
+        _t1282 = logic_pb2.GNFColumn(column_path=gnf_column_path680, target_id=relation_id681, types=types685)
+        return _t1282
+
+    def parse_gnf_column_path(self) -> Sequence[str]:
+        if self.match_lookahead_literal("[", 0):
+            _t1283 = 1
+        else:
+            if self.match_lookahead_terminal("STRING", 0):
+                _t1284 = 0
+            else:
+                _t1284 = -1
+            _t1283 = _t1284
+        prediction686 = _t1283
+        if prediction686 == 1:
+            self.consume_literal("[")
+            xs688 = []
+            cond689 = self.match_lookahead_terminal("STRING", 0)
+            while cond689:
+                item690 = self.consume_terminal("STRING")
+                xs688.append(item690)
+                cond689 = self.match_lookahead_terminal("STRING", 0)
+            strings691 = xs688
+            self.consume_literal("]")
+            _t1285 = strings691
+        else:
+            if prediction686 == 0:
+                string687 = self.consume_terminal("STRING")
+                _t1286 = [string687]
+            else:
+                raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
+            _t1285 = _t1286
+        return _t1285
 
     def parse_csv_asof(self) -> str:
         self.consume_literal("(")
         self.consume_literal("asof")
-        string676 = self.consume_terminal("STRING")
+        string692 = self.consume_terminal("STRING")
         self.consume_literal(")")
-        return string676
+        return string692
 
     def parse_undefine(self) -> transactions_pb2.Undefine:
         self.consume_literal("(")
         self.consume_literal("undefine")
-        _t1261 = self.parse_fragment_id()
-        fragment_id677 = _t1261
+        _t1287 = self.parse_fragment_id()
+        fragment_id693 = _t1287
         self.consume_literal(")")
-        _t1262 = transactions_pb2.Undefine(fragment_id=fragment_id677)
-        return _t1262
+        _t1288 = transactions_pb2.Undefine(fragment_id=fragment_id693)
+        return _t1288
 
     def parse_context(self) -> transactions_pb2.Context:
         self.consume_literal("(")
         self.consume_literal("context")
-        xs678 = []
-        cond679 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
-        while cond679:
-            _t1263 = self.parse_relation_id()
-            item680 = _t1263
-            xs678.append(item680)
-            cond679 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
-        relation_ids681 = xs678
-        self.consume_literal(")")
-        _t1264 = transactions_pb2.Context(relations=relation_ids681)
-        return _t1264
+        xs694 = []
+        cond695 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
+        while cond695:
+            _t1289 = self.parse_relation_id()
+            item696 = _t1289
+            xs694.append(item696)
+            cond695 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0))
+        relation_ids697 = xs694
+        self.consume_literal(")")
+        _t1290 = transactions_pb2.Context(relations=relation_ids697)
+        return _t1290
 
     def parse_snapshot(self) -> transactions_pb2.Snapshot:
         self.consume_literal("(")
         self.consume_literal("snapshot")
-        _t1265 = self.parse_rel_edb_path()
-        rel_edb_path682 = _t1265
-        _t1266 = self.parse_relation_id()
-        relation_id683 = _t1266
-        self.consume_literal(")")
-        _t1267 = transactions_pb2.Snapshot(destination_path=rel_edb_path682, source_relation=relation_id683)
-        return _t1267
+        xs698 = []
+        cond699 = self.match_lookahead_literal("[", 0)
+        while cond699:
+            _t1291 = self.parse_snapshot_mapping()
+            item700 = _t1291
+            xs698.append(item700)
+            cond699 = self.match_lookahead_literal("[", 0)
+        snapshot_mappings701 = xs698
+        self.consume_literal(")")
+        _t1292 = transactions_pb2.Snapshot(mappings=snapshot_mappings701)
+        return _t1292
+
+    def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping:
+        _t1293 = self.parse_edb_path()
+        edb_path702 = _t1293
+        _t1294 = self.parse_relation_id()
+        relation_id703 = _t1294
+        _t1295 = transactions_pb2.SnapshotMapping(destination_path=edb_path702, source_relation=relation_id703)
+        return _t1295
 
     def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]:
         self.consume_literal("(")
         self.consume_literal("reads")
-        xs684 = []
-        cond685 = self.match_lookahead_literal("(", 0)
-        while cond685:
-            _t1268 = self.parse_read()
-            item686 = _t1268
-            xs684.append(item686)
-            cond685 = self.match_lookahead_literal("(", 0)
-        reads687 = xs684
+        xs704 = []
+        cond705 = self.match_lookahead_literal("(", 0)
+        while cond705:
+            _t1296 = self.parse_read()
+            item706 = _t1296
+            xs704.append(item706)
+            cond705 = self.match_lookahead_literal("(", 0)
+        reads707 = xs704
         self.consume_literal(")")
-        return reads687
+        return reads707
 
     def parse_read(self) -> transactions_pb2.Read:
         if self.match_lookahead_literal("(", 0):
             if self.match_lookahead_literal("what_if", 1):
-                _t1270 = 2
+                _t1298 = 2
             else:
                 if self.match_lookahead_literal("output", 1):
-                    _t1271 = 1
+                    _t1299 = 1
                 else:
                     if self.match_lookahead_literal("export", 1):
-                        _t1272 = 4
+                        _t1300 = 4
                     else:
                         if self.match_lookahead_literal("demand", 1):
-                            _t1273 = 0
+                            _t1301 = 0
                         else:
                             if self.match_lookahead_literal("abort", 1):
-                                _t1274 = 3
+                                _t1302 = 3
                             else:
-                                _t1274 = -1
-                            _t1273 = _t1274
-                        _t1272 = _t1273
-                    _t1271 = _t1272
-                _t1270 = _t1271
-            _t1269 = _t1270
-        else:
-            _t1269 = -1
-        prediction688 = _t1269
-        if prediction688 == 4:
-            _t1276 = self.parse_export()
-            export693 = _t1276
-            _t1277 = transactions_pb2.Read(export=export693)
-            _t1275 = _t1277
-        else:
-            if prediction688 == 3:
-                _t1279 = self.parse_abort()
-                abort692 = _t1279
-                _t1280 = transactions_pb2.Read(abort=abort692)
-                _t1278 = _t1280
+                                _t1302 = -1
+                            _t1301 = _t1302
+                        _t1300 = _t1301
+                    _t1299 = _t1300
+                _t1298 = _t1299
+            _t1297 = _t1298
+        else:
+            _t1297 = -1
+        prediction708 = _t1297
+        if prediction708 == 4:
+            _t1304 = self.parse_export()
+            export713 = _t1304
+            _t1305 = transactions_pb2.Read(export=export713)
+            _t1303 = _t1305
+        else:
+            if prediction708 == 3:
+                _t1307 = self.parse_abort()
+                abort712 = _t1307
+                _t1308 = transactions_pb2.Read(abort=abort712)
+                _t1306 = _t1308
             else:
-                if prediction688 == 2:
-                    _t1282 = self.parse_what_if()
-                    what_if691 = _t1282
-                    _t1283 = transactions_pb2.Read(what_if=what_if691)
-                    _t1281 = _t1283
+                if prediction708 == 2:
+                    _t1310 = self.parse_what_if()
+                    what_if711 = _t1310
+                    _t1311 = transactions_pb2.Read(what_if=what_if711)
+                    _t1309 = _t1311
                 else:
-                    if prediction688 == 1:
-                        _t1285 = self.parse_output()
-                        output690 = _t1285
-                        _t1286 = transactions_pb2.Read(output=output690)
-                        _t1284 = _t1286
+                    if prediction708 == 1:
+                        _t1313 = self.parse_output()
+                        output710 = _t1313
+                        _t1314 = transactions_pb2.Read(output=output710)
+                        _t1312 = _t1314
                     else:
-                        if prediction688 == 0:
-                            _t1288 = self.parse_demand()
-                            demand689 = _t1288
-                            _t1289 = transactions_pb2.Read(demand=demand689)
-                            _t1287 = _t1289
+                        if prediction708 == 0:
+                            _t1316 = self.parse_demand()
+                            demand709 = _t1316
+                            _t1317 = transactions_pb2.Read(demand=demand709)
+                            _t1315 = _t1317
                         else:
                             raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`")
-                        _t1284 = _t1287
-                    _t1281 = _t1284
-                _t1278 = _t1281
-            _t1275 = _t1278
-        return _t1275
+                        _t1312 = _t1315
+                    _t1309 = _t1312
+                _t1306 = _t1309
+            _t1303 = _t1306
+        return _t1303
 
     def parse_demand(self) -> transactions_pb2.Demand:
         self.consume_literal("(")
         self.consume_literal("demand")
-        _t1290 = self.parse_relation_id()
-        relation_id694 = _t1290
+        _t1318 = self.parse_relation_id()
+        relation_id714 = _t1318
         self.consume_literal(")")
-        _t1291 = transactions_pb2.Demand(relation_id=relation_id694)
-        return _t1291
+        _t1319 = transactions_pb2.Demand(relation_id=relation_id714)
+        return _t1319
 
     def parse_output(self) -> transactions_pb2.Output:
         self.consume_literal("(")
         self.consume_literal("output")
-        _t1292 = self.parse_name()
-        name695 = _t1292
-        _t1293 = self.parse_relation_id()
-        relation_id696 = _t1293
+        _t1320 = self.parse_name()
+        name715 = _t1320
+        _t1321 = self.parse_relation_id()
+        relation_id716 = _t1321
         self.consume_literal(")")
-        _t1294 = transactions_pb2.Output(name=name695, relation_id=relation_id696)
-        return _t1294
+        _t1322 = transactions_pb2.Output(name=name715, relation_id=relation_id716)
+        return _t1322
 
     def parse_what_if(self) -> transactions_pb2.WhatIf:
         self.consume_literal("(")
         self.consume_literal("what_if")
-        _t1295 = self.parse_name()
-        name697 = _t1295
-        _t1296 = self.parse_epoch()
-        epoch698 = _t1296
+        _t1323 = self.parse_name()
+        name717 = _t1323
+        _t1324 = self.parse_epoch()
+        epoch718 = _t1324
         self.consume_literal(")")
-        _t1297 = transactions_pb2.WhatIf(branch=name697, epoch=epoch698)
-        return _t1297
+        _t1325 = transactions_pb2.WhatIf(branch=name717, epoch=epoch718)
+        return _t1325
 
     def parse_abort(self) -> transactions_pb2.Abort:
         self.consume_literal("(")
         self.consume_literal("abort")
         if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)):
-            _t1299 = self.parse_name()
-            _t1298 = _t1299
+            _t1327 = self.parse_name()
+            _t1326 = _t1327
         else:
-            _t1298 = None
-        name699 = _t1298
-        _t1300 = self.parse_relation_id()
-        relation_id700 = _t1300
+            _t1326 = None
+        name719 = _t1326
+        _t1328 = self.parse_relation_id()
+        relation_id720 = _t1328
         self.consume_literal(")")
-        _t1301 = transactions_pb2.Abort(name=(name699 if name699 is not None else "abort"), relation_id=relation_id700)
-        return _t1301
+        _t1329 = transactions_pb2.Abort(name=(name719 if name719 is not None else "abort"), relation_id=relation_id720)
+        return _t1329
 
     def parse_export(self) -> transactions_pb2.Export:
         self.consume_literal("(")
         self.consume_literal("export")
-        _t1302 = self.parse_export_csv_config()
-        export_csv_config701 = _t1302
+        _t1330 = self.parse_export_csv_config()
+        export_csv_config721 = _t1330
         self.consume_literal(")")
-        _t1303 = transactions_pb2.Export(csv_config=export_csv_config701)
-        return _t1303
+        _t1331 = transactions_pb2.Export(csv_config=export_csv_config721)
+        return _t1331
 
     def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig:
         self.consume_literal("(")
         self.consume_literal("export_csv_config")
-        _t1304 = self.parse_export_csv_path()
-        export_csv_path702 = _t1304
-        _t1305 = self.parse_export_csv_columns()
-        export_csv_columns703 = _t1305
-        _t1306 = self.parse_config_dict()
-        config_dict704 = _t1306
+        _t1332 = self.parse_export_csv_path()
+        export_csv_path722 = _t1332
+        _t1333 = self.parse_export_csv_columns()
+        export_csv_columns723 = _t1333
+        _t1334 = self.parse_config_dict()
+        config_dict724 = _t1334
         self.consume_literal(")")
-        _t1307 = self.export_csv_config(export_csv_path702, export_csv_columns703, config_dict704)
-        return _t1307
+        _t1335 = self.export_csv_config(export_csv_path722, export_csv_columns723, config_dict724)
+        return _t1335
 
     def parse_export_csv_path(self) -> str:
         self.consume_literal("(")
         self.consume_literal("path")
-        string705 = self.consume_terminal("STRING")
+        string725 = self.consume_terminal("STRING")
         self.consume_literal(")")
-        return string705
+        return string725
 
     def parse_export_csv_columns(self) -> Sequence[transactions_pb2.ExportCSVColumn]:
         self.consume_literal("(")
         self.consume_literal("columns")
-        xs706 = []
-        cond707 = self.match_lookahead_literal("(", 0)
-        while cond707:
-            _t1308 = self.parse_export_csv_column()
-            item708 = _t1308
-            xs706.append(item708)
-            cond707 = self.match_lookahead_literal("(", 0)
-        export_csv_columns709 = xs706
+        xs726 = []
+        cond727 = self.match_lookahead_literal("(", 0)
+        while cond727:
+            _t1336 = self.parse_export_csv_column()
+            item728 = _t1336
+            xs726.append(item728)
+            cond727 = self.match_lookahead_literal("(", 0)
+        export_csv_columns729 = xs726
         self.consume_literal(")")
-        return export_csv_columns709
+        return export_csv_columns729
 
     def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn:
         self.consume_literal("(")
         self.consume_literal("column")
-        string710 = self.consume_terminal("STRING")
-        _t1309 = self.parse_relation_id()
-        relation_id711 = _t1309
+        string730 = self.consume_terminal("STRING")
+        _t1337 = self.parse_relation_id()
+        relation_id731 = _t1337
         self.consume_literal(")")
-        _t1310 = transactions_pb2.ExportCSVColumn(column_name=string710, column_data=relation_id711)
-        return _t1310
+        _t1338 = transactions_pb2.ExportCSVColumn(column_name=string730, column_data=relation_id731)
+        return _t1338
 
 
 def parse(input_str: str) -> Any:
diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py
index 2c66f504..dae71207 100644
--- a/sdks/python/src/lqp/gen/pretty.py
+++ b/sdks/python/src/lqp/gen/pretty.py
@@ -193,131 +193,131 @@ def write_debug_info(self) -> None:
     # --- Helper functions ---
 
     def _make_value_int32(self, v: int) -> logic_pb2.Value:
-        _t1366 = logic_pb2.Value(int_value=int(v))
-        return _t1366
+        _t1395 = logic_pb2.Value(int_value=int(v))
+        return _t1395
 
     def _make_value_int64(self, v: int) -> logic_pb2.Value:
-        _t1367 = logic_pb2.Value(int_value=v)
-        return _t1367
+        _t1396 = logic_pb2.Value(int_value=v)
+        return _t1396
 
     def _make_value_float64(self, v: float) -> logic_pb2.Value:
-        _t1368 = logic_pb2.Value(float_value=v)
-        return _t1368
+        _t1397 = logic_pb2.Value(float_value=v)
+        return _t1397
 
     def _make_value_string(self, v: str) -> logic_pb2.Value:
-        _t1369 = logic_pb2.Value(string_value=v)
-        return _t1369
+        _t1398 = logic_pb2.Value(string_value=v)
+        return _t1398
 
     def _make_value_boolean(self, v: bool) -> logic_pb2.Value:
-        _t1370 = logic_pb2.Value(boolean_value=v)
-        return _t1370
+        _t1399 = logic_pb2.Value(boolean_value=v)
+        return _t1399
 
     def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value:
-        _t1371 = logic_pb2.Value(uint128_value=v)
-        return _t1371
+        _t1400 = logic_pb2.Value(uint128_value=v)
+        return _t1400
 
     def deconstruct_configure(self, msg: transactions_pb2.Configure) -> list[tuple[str, logic_pb2.Value]]:
         result = []
         if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO:
-            _t1372 = self._make_value_string("auto")
-            result.append(("ivm.maintenance_level", _t1372,))
+            _t1401 = self._make_value_string("auto")
+            result.append(("ivm.maintenance_level", _t1401,))
         else:
             if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL:
-                _t1373 = self._make_value_string("all")
-                result.append(("ivm.maintenance_level", _t1373,))
+                _t1402 = self._make_value_string("all")
+                result.append(("ivm.maintenance_level", _t1402,))
             else:
                 if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF:
-                    _t1374 = self._make_value_string("off")
-                    result.append(("ivm.maintenance_level", _t1374,))
-        _t1375 = self._make_value_int64(msg.semantics_version)
-        result.append(("semantics_version", _t1375,))
+                    _t1403 = self._make_value_string("off")
+                    result.append(("ivm.maintenance_level", _t1403,))
+        _t1404 = self._make_value_int64(msg.semantics_version)
+        result.append(("semantics_version", _t1404,))
         return sorted(result)
 
     def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]:
         result = []
-        _t1376 = self._make_value_int32(msg.header_row)
-        result.append(("csv_header_row", _t1376,))
-        _t1377 = self._make_value_int64(msg.skip)
-        result.append(("csv_skip", _t1377,))
+        _t1405 = self._make_value_int32(msg.header_row)
+        result.append(("csv_header_row", _t1405,))
+        _t1406 = self._make_value_int64(msg.skip)
+        result.append(("csv_skip", _t1406,))
         if msg.new_line != "":
-            _t1378 = self._make_value_string(msg.new_line)
-            result.append(("csv_new_line", _t1378,))
-        _t1379 = self._make_value_string(msg.delimiter)
-        result.append(("csv_delimiter", _t1379,))
-        _t1380 = self._make_value_string(msg.quotechar)
-        result.append(("csv_quotechar", _t1380,))
-        _t1381 = self._make_value_string(msg.escapechar)
-        result.append(("csv_escapechar", _t1381,))
+            _t1407 = self._make_value_string(msg.new_line)
+            result.append(("csv_new_line", _t1407,))
+        _t1408 = self._make_value_string(msg.delimiter)
+        result.append(("csv_delimiter", _t1408,))
+        _t1409 = self._make_value_string(msg.quotechar)
+        result.append(("csv_quotechar", _t1409,))
+        _t1410 = self._make_value_string(msg.escapechar)
+        result.append(("csv_escapechar", _t1410,))
         if msg.comment != "":
-            _t1382 = self._make_value_string(msg.comment)
-            result.append(("csv_comment", _t1382,))
+            _t1411 = self._make_value_string(msg.comment)
+            result.append(("csv_comment", _t1411,))
         for missing_string in msg.missing_strings:
-            _t1383 = self._make_value_string(missing_string)
-            result.append(("csv_missing_strings", _t1383,))
-        _t1384 = self._make_value_string(msg.decimal_separator)
-        result.append(("csv_decimal_separator", _t1384,))
-        _t1385 = self._make_value_string(msg.encoding)
-        result.append(("csv_encoding", _t1385,))
-        _t1386 = self._make_value_string(msg.compression)
-        result.append(("csv_compression", _t1386,))
+            _t1412 = self._make_value_string(missing_string)
+            result.append(("csv_missing_strings", _t1412,))
+        _t1413 = self._make_value_string(msg.decimal_separator)
+        result.append(("csv_decimal_separator", _t1413,))
+        _t1414 = self._make_value_string(msg.encoding)
+        result.append(("csv_encoding", _t1414,))
+        _t1415 = self._make_value_string(msg.compression)
+        result.append(("csv_compression", _t1415,))
         return sorted(result)
 
     def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]:
         result = []
-        _t1387 = self._make_value_float64(msg.storage_config.epsilon)
-        result.append(("betree_config_epsilon", _t1387,))
-        _t1388 = self._make_value_int64(msg.storage_config.max_pivots)
-        result.append(("betree_config_max_pivots", _t1388,))
-        _t1389 = self._make_value_int64(msg.storage_config.max_deltas)
-        result.append(("betree_config_max_deltas", _t1389,))
-        _t1390 = self._make_value_int64(msg.storage_config.max_leaf)
-        result.append(("betree_config_max_leaf", _t1390,))
+        _t1416 = self._make_value_float64(msg.storage_config.epsilon)
+        result.append(("betree_config_epsilon", _t1416,))
+        _t1417 = self._make_value_int64(msg.storage_config.max_pivots)
+        result.append(("betree_config_max_pivots", _t1417,))
+        _t1418 = self._make_value_int64(msg.storage_config.max_deltas)
+        result.append(("betree_config_max_deltas", _t1418,))
+        _t1419 = self._make_value_int64(msg.storage_config.max_leaf)
+        result.append(("betree_config_max_leaf", _t1419,))
         if msg.relation_locator.HasField("root_pageid"):
             if msg.relation_locator.root_pageid is not None:
                 assert msg.relation_locator.root_pageid is not None
-                _t1391 = self._make_value_uint128(msg.relation_locator.root_pageid)
-                result.append(("betree_locator_root_pageid", _t1391,))
+                _t1420 = self._make_value_uint128(msg.relation_locator.root_pageid)
+                result.append(("betree_locator_root_pageid", _t1420,))
         if msg.relation_locator.HasField("inline_data"):
             if msg.relation_locator.inline_data is not None:
                 assert msg.relation_locator.inline_data is not None
-                _t1392 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8'))
-                result.append(("betree_locator_inline_data", _t1392,))
-        _t1393 = self._make_value_int64(msg.relation_locator.element_count)
-        result.append(("betree_locator_element_count", _t1393,))
-        _t1394 = self._make_value_int64(msg.relation_locator.tree_height)
-        result.append(("betree_locator_tree_height", _t1394,))
+                _t1421 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8'))
+                result.append(("betree_locator_inline_data", _t1421,))
+        _t1422 = self._make_value_int64(msg.relation_locator.element_count)
+        result.append(("betree_locator_element_count", _t1422,))
+        _t1423 = self._make_value_int64(msg.relation_locator.tree_height)
+        result.append(("betree_locator_tree_height", _t1423,))
         return sorted(result)
 
     def deconstruct_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig) -> list[tuple[str, logic_pb2.Value]]:
         result = []
         if msg.partition_size is not None:
             assert msg.partition_size is not None
-            _t1395 = self._make_value_int64(msg.partition_size)
-            result.append(("partition_size", _t1395,))
+            _t1424 = self._make_value_int64(msg.partition_size)
+            result.append(("partition_size", _t1424,))
         if msg.compression is not None:
             assert msg.compression is not None
-            _t1396 = self._make_value_string(msg.compression)
-            result.append(("compression", _t1396,))
+            _t1425 = self._make_value_string(msg.compression)
+            result.append(("compression", _t1425,))
         if msg.syntax_header_row is not None:
             assert msg.syntax_header_row is not None
-            _t1397 = self._make_value_boolean(msg.syntax_header_row)
-            result.append(("syntax_header_row", _t1397,))
+            _t1426 = self._make_value_boolean(msg.syntax_header_row)
+            result.append(("syntax_header_row", _t1426,))
         if msg.syntax_missing_string is not None:
             assert msg.syntax_missing_string is not None
-            _t1398 = self._make_value_string(msg.syntax_missing_string)
-            result.append(("syntax_missing_string", _t1398,))
+            _t1427 = self._make_value_string(msg.syntax_missing_string)
+            result.append(("syntax_missing_string", _t1427,))
         if msg.syntax_delim is not None:
             assert msg.syntax_delim is not None
-            _t1399 = self._make_value_string(msg.syntax_delim)
-            result.append(("syntax_delim", _t1399,))
+            _t1428 = self._make_value_string(msg.syntax_delim)
+            result.append(("syntax_delim", _t1428,))
         if msg.syntax_quotechar is not None:
             assert msg.syntax_quotechar is not None
-            _t1400 = self._make_value_string(msg.syntax_quotechar)
-            result.append(("syntax_quotechar", _t1400,))
+            _t1429 = self._make_value_string(msg.syntax_quotechar)
+            result.append(("syntax_quotechar", _t1429,))
         if msg.syntax_escapechar is not None:
             assert msg.syntax_escapechar is not None
-            _t1401 = self._make_value_string(msg.syntax_escapechar)
-            result.append(("syntax_escapechar", _t1401,))
+            _t1430 = self._make_value_string(msg.syntax_escapechar)
+            result.append(("syntax_escapechar", _t1430,))
         return sorted(result)
 
     def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str:
@@ -330,7 +330,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> Optional
         if name is None:
             return self.relation_id_to_uint128(msg)
         else:
-            _t1402 = None
+            _t1431 = None
         return None
 
     def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]:
@@ -345,3083 +345,3145 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit
     # --- Pretty-print methods ---
 
     def pretty_transaction(self, msg: transactions_pb2.Transaction):
-        flat638 = self._try_flat(msg, self.pretty_transaction)
-        if flat638 is not None:
-            assert flat638 is not None
-            self.write(flat638)
+        flat651 = self._try_flat(msg, self.pretty_transaction)
+        if flat651 is not None:
+            assert flat651 is not None
+            self.write(flat651)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("configure"):
-                _t1258 = _dollar_dollar.configure
+                _t1284 = _dollar_dollar.configure
             else:
-                _t1258 = None
+                _t1284 = None
             if _dollar_dollar.HasField("sync"):
-                _t1259 = _dollar_dollar.sync
+                _t1285 = _dollar_dollar.sync
             else:
-                _t1259 = None
-            fields629 = (_t1258, _t1259, _dollar_dollar.epochs,)
-            assert fields629 is not None
-            unwrapped_fields630 = fields629
+                _t1285 = None
+            fields642 = (_t1284, _t1285, _dollar_dollar.epochs,)
+            assert fields642 is not None
+            unwrapped_fields643 = fields642
             self.write("(transaction")
             self.indent_sexp()
-            field631 = unwrapped_fields630[0]
-            if field631 is not None:
+            field644 = unwrapped_fields643[0]
+            if field644 is not None:
                 self.newline()
-                assert field631 is not None
-                opt_val632 = field631
-                self.pretty_configure(opt_val632)
-            field633 = unwrapped_fields630[1]
-            if field633 is not None:
+                assert field644 is not None
+                opt_val645 = field644
+                self.pretty_configure(opt_val645)
+            field646 = unwrapped_fields643[1]
+            if field646 is not None:
                 self.newline()
-                assert field633 is not None
-                opt_val634 = field633
-                self.pretty_sync(opt_val634)
-            field635 = unwrapped_fields630[2]
-            if not len(field635) == 0:
+                assert field646 is not None
+                opt_val647 = field646
+                self.pretty_sync(opt_val647)
+            field648 = unwrapped_fields643[2]
+            if not len(field648) == 0:
                 self.newline()
-                for i637, elem636 in enumerate(field635):
-                    if (i637 > 0):
+                for i650, elem649 in enumerate(field648):
+                    if (i650 > 0):
                         self.newline()
-                    self.pretty_epoch(elem636)
+                    self.pretty_epoch(elem649)
             self.dedent()
             self.write(")")
 
     def pretty_configure(self, msg: transactions_pb2.Configure):
-        flat641 = self._try_flat(msg, self.pretty_configure)
-        if flat641 is not None:
-            assert flat641 is not None
-            self.write(flat641)
+        flat654 = self._try_flat(msg, self.pretty_configure)
+        if flat654 is not None:
+            assert flat654 is not None
+            self.write(flat654)
             return None
         else:
             _dollar_dollar = msg
-            _t1260 = self.deconstruct_configure(_dollar_dollar)
-            fields639 = _t1260
-            assert fields639 is not None
-            unwrapped_fields640 = fields639
+            _t1286 = self.deconstruct_configure(_dollar_dollar)
+            fields652 = _t1286
+            assert fields652 is not None
+            unwrapped_fields653 = fields652
             self.write("(configure")
             self.indent_sexp()
             self.newline()
-            self.pretty_config_dict(unwrapped_fields640)
+            self.pretty_config_dict(unwrapped_fields653)
             self.dedent()
             self.write(")")
 
     def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]):
-        flat645 = self._try_flat(msg, self.pretty_config_dict)
-        if flat645 is not None:
-            assert flat645 is not None
-            self.write(flat645)
+        flat658 = self._try_flat(msg, self.pretty_config_dict)
+        if flat658 is not None:
+            assert flat658 is not None
+            self.write(flat658)
             return None
         else:
-            fields642 = msg
+            fields655 = msg
             self.write("{")
             self.indent()
-            if not len(fields642) == 0:
+            if not len(fields655) == 0:
                 self.newline()
-                for i644, elem643 in enumerate(fields642):
-                    if (i644 > 0):
+                for i657, elem656 in enumerate(fields655):
+                    if (i657 > 0):
                         self.newline()
-                    self.pretty_config_key_value(elem643)
+                    self.pretty_config_key_value(elem656)
             self.dedent()
             self.write("}")
 
     def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]):
-        flat650 = self._try_flat(msg, self.pretty_config_key_value)
-        if flat650 is not None:
-            assert flat650 is not None
-            self.write(flat650)
+        flat663 = self._try_flat(msg, self.pretty_config_key_value)
+        if flat663 is not None:
+            assert flat663 is not None
+            self.write(flat663)
             return None
         else:
             _dollar_dollar = msg
-            fields646 = (_dollar_dollar[0], _dollar_dollar[1],)
-            assert fields646 is not None
-            unwrapped_fields647 = fields646
+            fields659 = (_dollar_dollar[0], _dollar_dollar[1],)
+            assert fields659 is not None
+            unwrapped_fields660 = fields659
             self.write(":")
-            field648 = unwrapped_fields647[0]
-            self.write(field648)
+            field661 = unwrapped_fields660[0]
+            self.write(field661)
             self.write(" ")
-            field649 = unwrapped_fields647[1]
-            self.pretty_value(field649)
+            field662 = unwrapped_fields660[1]
+            self.pretty_value(field662)
 
     def pretty_value(self, msg: logic_pb2.Value):
-        flat670 = self._try_flat(msg, self.pretty_value)
-        if flat670 is not None:
-            assert flat670 is not None
-            self.write(flat670)
+        flat683 = self._try_flat(msg, self.pretty_value)
+        if flat683 is not None:
+            assert flat683 is not None
+            self.write(flat683)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("date_value"):
-                _t1261 = _dollar_dollar.date_value
+                _t1287 = _dollar_dollar.date_value
             else:
-                _t1261 = None
-            deconstruct_result668 = _t1261
-            if deconstruct_result668 is not None:
-                assert deconstruct_result668 is not None
-                unwrapped669 = deconstruct_result668
-                self.pretty_date(unwrapped669)
+                _t1287 = None
+            deconstruct_result681 = _t1287
+            if deconstruct_result681 is not None:
+                assert deconstruct_result681 is not None
+                unwrapped682 = deconstruct_result681
+                self.pretty_date(unwrapped682)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("datetime_value"):
-                    _t1262 = _dollar_dollar.datetime_value
+                    _t1288 = _dollar_dollar.datetime_value
                 else:
-                    _t1262 = None
-                deconstruct_result666 = _t1262
-                if deconstruct_result666 is not None:
-                    assert deconstruct_result666 is not None
-                    unwrapped667 = deconstruct_result666
-                    self.pretty_datetime(unwrapped667)
+                    _t1288 = None
+                deconstruct_result679 = _t1288
+                if deconstruct_result679 is not None:
+                    assert deconstruct_result679 is not None
+                    unwrapped680 = deconstruct_result679
+                    self.pretty_datetime(unwrapped680)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("string_value"):
-                        _t1263 = _dollar_dollar.string_value
+                        _t1289 = _dollar_dollar.string_value
                     else:
-                        _t1263 = None
-                    deconstruct_result664 = _t1263
-                    if deconstruct_result664 is not None:
-                        assert deconstruct_result664 is not None
-                        unwrapped665 = deconstruct_result664
-                        self.write(self.format_string_value(unwrapped665))
+                        _t1289 = None
+                    deconstruct_result677 = _t1289
+                    if deconstruct_result677 is not None:
+                        assert deconstruct_result677 is not None
+                        unwrapped678 = deconstruct_result677
+                        self.write(self.format_string_value(unwrapped678))
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("int_value"):
-                            _t1264 = _dollar_dollar.int_value
+                            _t1290 = _dollar_dollar.int_value
                         else:
-                            _t1264 = None
-                        deconstruct_result662 = _t1264
-                        if deconstruct_result662 is not None:
-                            assert deconstruct_result662 is not None
-                            unwrapped663 = deconstruct_result662
-                            self.write(str(unwrapped663))
+                            _t1290 = None
+                        deconstruct_result675 = _t1290
+                        if deconstruct_result675 is not None:
+                            assert deconstruct_result675 is not None
+                            unwrapped676 = deconstruct_result675
+                            self.write(str(unwrapped676))
                         else:
                             _dollar_dollar = msg
                             if _dollar_dollar.HasField("float_value"):
-                                _t1265 = _dollar_dollar.float_value
+                                _t1291 = _dollar_dollar.float_value
                             else:
-                                _t1265 = None
-                            deconstruct_result660 = _t1265
-                            if deconstruct_result660 is not None:
-                                assert deconstruct_result660 is not None
-                                unwrapped661 = deconstruct_result660
-                                self.write(str(unwrapped661))
+                                _t1291 = None
+                            deconstruct_result673 = _t1291
+                            if deconstruct_result673 is not None:
+                                assert deconstruct_result673 is not None
+                                unwrapped674 = deconstruct_result673
+                                self.write(str(unwrapped674))
                             else:
                                 _dollar_dollar = msg
                                 if _dollar_dollar.HasField("uint128_value"):
-                                    _t1266 = _dollar_dollar.uint128_value
+                                    _t1292 = _dollar_dollar.uint128_value
                                 else:
-                                    _t1266 = None
-                                deconstruct_result658 = _t1266
-                                if deconstruct_result658 is not None:
-                                    assert deconstruct_result658 is not None
-                                    unwrapped659 = deconstruct_result658
-                                    self.write(self.format_uint128(unwrapped659))
+                                    _t1292 = None
+                                deconstruct_result671 = _t1292
+                                if deconstruct_result671 is not None:
+                                    assert deconstruct_result671 is not None
+                                    unwrapped672 = deconstruct_result671
+                                    self.write(self.format_uint128(unwrapped672))
                                 else:
                                     _dollar_dollar = msg
                                     if _dollar_dollar.HasField("int128_value"):
-                                        _t1267 = _dollar_dollar.int128_value
+                                        _t1293 = _dollar_dollar.int128_value
                                     else:
-                                        _t1267 = None
-                                    deconstruct_result656 = _t1267
-                                    if deconstruct_result656 is not None:
-                                        assert deconstruct_result656 is not None
-                                        unwrapped657 = deconstruct_result656
-                                        self.write(self.format_int128(unwrapped657))
+                                        _t1293 = None
+                                    deconstruct_result669 = _t1293
+                                    if deconstruct_result669 is not None:
+                                        assert deconstruct_result669 is not None
+                                        unwrapped670 = deconstruct_result669
+                                        self.write(self.format_int128(unwrapped670))
                                     else:
                                         _dollar_dollar = msg
                                         if _dollar_dollar.HasField("decimal_value"):
-                                            _t1268 = _dollar_dollar.decimal_value
+                                            _t1294 = _dollar_dollar.decimal_value
                                         else:
-                                            _t1268 = None
-                                        deconstruct_result654 = _t1268
-                                        if deconstruct_result654 is not None:
-                                            assert deconstruct_result654 is not None
-                                            unwrapped655 = deconstruct_result654
-                                            self.write(self.format_decimal(unwrapped655))
+                                            _t1294 = None
+                                        deconstruct_result667 = _t1294
+                                        if deconstruct_result667 is not None:
+                                            assert deconstruct_result667 is not None
+                                            unwrapped668 = deconstruct_result667
+                                            self.write(self.format_decimal(unwrapped668))
                                         else:
                                             _dollar_dollar = msg
                                             if _dollar_dollar.HasField("boolean_value"):
-                                                _t1269 = _dollar_dollar.boolean_value
+                                                _t1295 = _dollar_dollar.boolean_value
                                             else:
-                                                _t1269 = None
-                                            deconstruct_result652 = _t1269
-                                            if deconstruct_result652 is not None:
-                                                assert deconstruct_result652 is not None
-                                                unwrapped653 = deconstruct_result652
-                                                self.pretty_boolean_value(unwrapped653)
+                                                _t1295 = None
+                                            deconstruct_result665 = _t1295
+                                            if deconstruct_result665 is not None:
+                                                assert deconstruct_result665 is not None
+                                                unwrapped666 = deconstruct_result665
+                                                self.pretty_boolean_value(unwrapped666)
                                             else:
-                                                fields651 = msg
+                                                fields664 = msg
                                                 self.write("missing")
 
     def pretty_date(self, msg: logic_pb2.DateValue):
-        flat676 = self._try_flat(msg, self.pretty_date)
-        if flat676 is not None:
-            assert flat676 is not None
-            self.write(flat676)
+        flat689 = self._try_flat(msg, self.pretty_date)
+        if flat689 is not None:
+            assert flat689 is not None
+            self.write(flat689)
             return None
         else:
             _dollar_dollar = msg
-            fields671 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),)
-            assert fields671 is not None
-            unwrapped_fields672 = fields671
+            fields684 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),)
+            assert fields684 is not None
+            unwrapped_fields685 = fields684
             self.write("(date")
             self.indent_sexp()
             self.newline()
-            field673 = unwrapped_fields672[0]
-            self.write(str(field673))
+            field686 = unwrapped_fields685[0]
+            self.write(str(field686))
             self.newline()
-            field674 = unwrapped_fields672[1]
-            self.write(str(field674))
+            field687 = unwrapped_fields685[1]
+            self.write(str(field687))
             self.newline()
-            field675 = unwrapped_fields672[2]
-            self.write(str(field675))
+            field688 = unwrapped_fields685[2]
+            self.write(str(field688))
             self.dedent()
             self.write(")")
 
     def pretty_datetime(self, msg: logic_pb2.DateTimeValue):
-        flat687 = self._try_flat(msg, self.pretty_datetime)
-        if flat687 is not None:
-            assert flat687 is not None
-            self.write(flat687)
+        flat700 = self._try_flat(msg, self.pretty_datetime)
+        if flat700 is not None:
+            assert flat700 is not None
+            self.write(flat700)
             return None
         else:
             _dollar_dollar = msg
-            fields677 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),)
-            assert fields677 is not None
-            unwrapped_fields678 = fields677
+            fields690 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),)
+            assert fields690 is not None
+            unwrapped_fields691 = fields690
             self.write("(datetime")
             self.indent_sexp()
             self.newline()
-            field679 = unwrapped_fields678[0]
-            self.write(str(field679))
+            field692 = unwrapped_fields691[0]
+            self.write(str(field692))
             self.newline()
-            field680 = unwrapped_fields678[1]
-            self.write(str(field680))
+            field693 = unwrapped_fields691[1]
+            self.write(str(field693))
             self.newline()
-            field681 = unwrapped_fields678[2]
-            self.write(str(field681))
+            field694 = unwrapped_fields691[2]
+            self.write(str(field694))
             self.newline()
-            field682 = unwrapped_fields678[3]
-            self.write(str(field682))
+            field695 = unwrapped_fields691[3]
+            self.write(str(field695))
             self.newline()
-            field683 = unwrapped_fields678[4]
-            self.write(str(field683))
+            field696 = unwrapped_fields691[4]
+            self.write(str(field696))
             self.newline()
-            field684 = unwrapped_fields678[5]
-            self.write(str(field684))
-            field685 = unwrapped_fields678[6]
-            if field685 is not None:
+            field697 = unwrapped_fields691[5]
+            self.write(str(field697))
+            field698 = unwrapped_fields691[6]
+            if field698 is not None:
                 self.newline()
-                assert field685 is not None
-                opt_val686 = field685
-                self.write(str(opt_val686))
+                assert field698 is not None
+                opt_val699 = field698
+                self.write(str(opt_val699))
             self.dedent()
             self.write(")")
 
     def pretty_boolean_value(self, msg: bool):
         _dollar_dollar = msg
         if _dollar_dollar:
-            _t1270 = ()
+            _t1296 = ()
         else:
-            _t1270 = None
-        deconstruct_result690 = _t1270
-        if deconstruct_result690 is not None:
-            assert deconstruct_result690 is not None
-            unwrapped691 = deconstruct_result690
+            _t1296 = None
+        deconstruct_result703 = _t1296
+        if deconstruct_result703 is not None:
+            assert deconstruct_result703 is not None
+            unwrapped704 = deconstruct_result703
             self.write("true")
         else:
             _dollar_dollar = msg
             if not _dollar_dollar:
-                _t1271 = ()
+                _t1297 = ()
             else:
-                _t1271 = None
-            deconstruct_result688 = _t1271
-            if deconstruct_result688 is not None:
-                assert deconstruct_result688 is not None
-                unwrapped689 = deconstruct_result688
+                _t1297 = None
+            deconstruct_result701 = _t1297
+            if deconstruct_result701 is not None:
+                assert deconstruct_result701 is not None
+                unwrapped702 = deconstruct_result701
                 self.write("false")
             else:
                 raise ParseError("No matching rule for boolean_value")
 
     def pretty_sync(self, msg: transactions_pb2.Sync):
-        flat696 = self._try_flat(msg, self.pretty_sync)
-        if flat696 is not None:
-            assert flat696 is not None
-            self.write(flat696)
+        flat709 = self._try_flat(msg, self.pretty_sync)
+        if flat709 is not None:
+            assert flat709 is not None
+            self.write(flat709)
             return None
         else:
             _dollar_dollar = msg
-            fields692 = _dollar_dollar.fragments
-            assert fields692 is not None
-            unwrapped_fields693 = fields692
+            fields705 = _dollar_dollar.fragments
+            assert fields705 is not None
+            unwrapped_fields706 = fields705
             self.write("(sync")
             self.indent_sexp()
-            if not len(unwrapped_fields693) == 0:
+            if not len(unwrapped_fields706) == 0:
                 self.newline()
-                for i695, elem694 in enumerate(unwrapped_fields693):
-                    if (i695 > 0):
+                for i708, elem707 in enumerate(unwrapped_fields706):
+                    if (i708 > 0):
                         self.newline()
-                    self.pretty_fragment_id(elem694)
+                    self.pretty_fragment_id(elem707)
             self.dedent()
             self.write(")")
 
     def pretty_fragment_id(self, msg: fragments_pb2.FragmentId):
-        flat699 = self._try_flat(msg, self.pretty_fragment_id)
-        if flat699 is not None:
-            assert flat699 is not None
-            self.write(flat699)
+        flat712 = self._try_flat(msg, self.pretty_fragment_id)
+        if flat712 is not None:
+            assert flat712 is not None
+            self.write(flat712)
             return None
         else:
             _dollar_dollar = msg
-            fields697 = self.fragment_id_to_string(_dollar_dollar)
-            assert fields697 is not None
-            unwrapped_fields698 = fields697
+            fields710 = self.fragment_id_to_string(_dollar_dollar)
+            assert fields710 is not None
+            unwrapped_fields711 = fields710
             self.write(":")
-            self.write(unwrapped_fields698)
+            self.write(unwrapped_fields711)
 
     def pretty_epoch(self, msg: transactions_pb2.Epoch):
-        flat706 = self._try_flat(msg, self.pretty_epoch)
-        if flat706 is not None:
-            assert flat706 is not None
-            self.write(flat706)
+        flat719 = self._try_flat(msg, self.pretty_epoch)
+        if flat719 is not None:
+            assert flat719 is not None
+            self.write(flat719)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.writes) == 0:
-                _t1272 = _dollar_dollar.writes
+                _t1298 = _dollar_dollar.writes
             else:
-                _t1272 = None
+                _t1298 = None
             if not len(_dollar_dollar.reads) == 0:
-                _t1273 = _dollar_dollar.reads
+                _t1299 = _dollar_dollar.reads
             else:
-                _t1273 = None
-            fields700 = (_t1272, _t1273,)
-            assert fields700 is not None
-            unwrapped_fields701 = fields700
+                _t1299 = None
+            fields713 = (_t1298, _t1299,)
+            assert fields713 is not None
+            unwrapped_fields714 = fields713
             self.write("(epoch")
             self.indent_sexp()
-            field702 = unwrapped_fields701[0]
-            if field702 is not None:
+            field715 = unwrapped_fields714[0]
+            if field715 is not None:
                 self.newline()
-                assert field702 is not None
-                opt_val703 = field702
-                self.pretty_epoch_writes(opt_val703)
-            field704 = unwrapped_fields701[1]
-            if field704 is not None:
+                assert field715 is not None
+                opt_val716 = field715
+                self.pretty_epoch_writes(opt_val716)
+            field717 = unwrapped_fields714[1]
+            if field717 is not None:
                 self.newline()
-                assert field704 is not None
-                opt_val705 = field704
-                self.pretty_epoch_reads(opt_val705)
+                assert field717 is not None
+                opt_val718 = field717
+                self.pretty_epoch_reads(opt_val718)
             self.dedent()
             self.write(")")
 
     def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]):
-        flat710 = self._try_flat(msg, self.pretty_epoch_writes)
-        if flat710 is not None:
-            assert flat710 is not None
-            self.write(flat710)
+        flat723 = self._try_flat(msg, self.pretty_epoch_writes)
+        if flat723 is not None:
+            assert flat723 is not None
+            self.write(flat723)
             return None
         else:
-            fields707 = msg
+            fields720 = msg
             self.write("(writes")
             self.indent_sexp()
-            if not len(fields707) == 0:
+            if not len(fields720) == 0:
                 self.newline()
-                for i709, elem708 in enumerate(fields707):
-                    if (i709 > 0):
+                for i722, elem721 in enumerate(fields720):
+                    if (i722 > 0):
                         self.newline()
-                    self.pretty_write(elem708)
+                    self.pretty_write(elem721)
             self.dedent()
             self.write(")")
 
     def pretty_write(self, msg: transactions_pb2.Write):
-        flat719 = self._try_flat(msg, self.pretty_write)
-        if flat719 is not None:
-            assert flat719 is not None
-            self.write(flat719)
+        flat732 = self._try_flat(msg, self.pretty_write)
+        if flat732 is not None:
+            assert flat732 is not None
+            self.write(flat732)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("define"):
-                _t1274 = _dollar_dollar.define
+                _t1300 = _dollar_dollar.define
             else:
-                _t1274 = None
-            deconstruct_result717 = _t1274
-            if deconstruct_result717 is not None:
-                assert deconstruct_result717 is not None
-                unwrapped718 = deconstruct_result717
-                self.pretty_define(unwrapped718)
+                _t1300 = None
+            deconstruct_result730 = _t1300
+            if deconstruct_result730 is not None:
+                assert deconstruct_result730 is not None
+                unwrapped731 = deconstruct_result730
+                self.pretty_define(unwrapped731)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("undefine"):
-                    _t1275 = _dollar_dollar.undefine
+                    _t1301 = _dollar_dollar.undefine
                 else:
-                    _t1275 = None
-                deconstruct_result715 = _t1275
-                if deconstruct_result715 is not None:
-                    assert deconstruct_result715 is not None
-                    unwrapped716 = deconstruct_result715
-                    self.pretty_undefine(unwrapped716)
+                    _t1301 = None
+                deconstruct_result728 = _t1301
+                if deconstruct_result728 is not None:
+                    assert deconstruct_result728 is not None
+                    unwrapped729 = deconstruct_result728
+                    self.pretty_undefine(unwrapped729)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("context"):
-                        _t1276 = _dollar_dollar.context
+                        _t1302 = _dollar_dollar.context
                     else:
-                        _t1276 = None
-                    deconstruct_result713 = _t1276
-                    if deconstruct_result713 is not None:
-                        assert deconstruct_result713 is not None
-                        unwrapped714 = deconstruct_result713
-                        self.pretty_context(unwrapped714)
+                        _t1302 = None
+                    deconstruct_result726 = _t1302
+                    if deconstruct_result726 is not None:
+                        assert deconstruct_result726 is not None
+                        unwrapped727 = deconstruct_result726
+                        self.pretty_context(unwrapped727)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("snapshot"):
-                            _t1277 = _dollar_dollar.snapshot
+                            _t1303 = _dollar_dollar.snapshot
                         else:
-                            _t1277 = None
-                        deconstruct_result711 = _t1277
-                        if deconstruct_result711 is not None:
-                            assert deconstruct_result711 is not None
-                            unwrapped712 = deconstruct_result711
-                            self.pretty_snapshot(unwrapped712)
+                            _t1303 = None
+                        deconstruct_result724 = _t1303
+                        if deconstruct_result724 is not None:
+                            assert deconstruct_result724 is not None
+                            unwrapped725 = deconstruct_result724
+                            self.pretty_snapshot(unwrapped725)
                         else:
                             raise ParseError("No matching rule for write")
 
     def pretty_define(self, msg: transactions_pb2.Define):
-        flat722 = self._try_flat(msg, self.pretty_define)
-        if flat722 is not None:
-            assert flat722 is not None
-            self.write(flat722)
+        flat735 = self._try_flat(msg, self.pretty_define)
+        if flat735 is not None:
+            assert flat735 is not None
+            self.write(flat735)
             return None
         else:
             _dollar_dollar = msg
-            fields720 = _dollar_dollar.fragment
-            assert fields720 is not None
-            unwrapped_fields721 = fields720
+            fields733 = _dollar_dollar.fragment
+            assert fields733 is not None
+            unwrapped_fields734 = fields733
             self.write("(define")
             self.indent_sexp()
             self.newline()
-            self.pretty_fragment(unwrapped_fields721)
+            self.pretty_fragment(unwrapped_fields734)
             self.dedent()
             self.write(")")
 
     def pretty_fragment(self, msg: fragments_pb2.Fragment):
-        flat729 = self._try_flat(msg, self.pretty_fragment)
-        if flat729 is not None:
-            assert flat729 is not None
-            self.write(flat729)
+        flat742 = self._try_flat(msg, self.pretty_fragment)
+        if flat742 is not None:
+            assert flat742 is not None
+            self.write(flat742)
             return None
         else:
             _dollar_dollar = msg
             self.start_pretty_fragment(_dollar_dollar)
-            fields723 = (_dollar_dollar.id, _dollar_dollar.declarations,)
-            assert fields723 is not None
-            unwrapped_fields724 = fields723
+            fields736 = (_dollar_dollar.id, _dollar_dollar.declarations,)
+            assert fields736 is not None
+            unwrapped_fields737 = fields736
             self.write("(fragment")
             self.indent_sexp()
             self.newline()
-            field725 = unwrapped_fields724[0]
-            self.pretty_new_fragment_id(field725)
-            field726 = unwrapped_fields724[1]
-            if not len(field726) == 0:
+            field738 = unwrapped_fields737[0]
+            self.pretty_new_fragment_id(field738)
+            field739 = unwrapped_fields737[1]
+            if not len(field739) == 0:
                 self.newline()
-                for i728, elem727 in enumerate(field726):
-                    if (i728 > 0):
+                for i741, elem740 in enumerate(field739):
+                    if (i741 > 0):
                         self.newline()
-                    self.pretty_declaration(elem727)
+                    self.pretty_declaration(elem740)
             self.dedent()
             self.write(")")
 
     def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId):
-        flat731 = self._try_flat(msg, self.pretty_new_fragment_id)
-        if flat731 is not None:
-            assert flat731 is not None
-            self.write(flat731)
+        flat744 = self._try_flat(msg, self.pretty_new_fragment_id)
+        if flat744 is not None:
+            assert flat744 is not None
+            self.write(flat744)
             return None
         else:
-            fields730 = msg
-            self.pretty_fragment_id(fields730)
+            fields743 = msg
+            self.pretty_fragment_id(fields743)
 
     def pretty_declaration(self, msg: logic_pb2.Declaration):
-        flat740 = self._try_flat(msg, self.pretty_declaration)
-        if flat740 is not None:
-            assert flat740 is not None
-            self.write(flat740)
+        flat753 = self._try_flat(msg, self.pretty_declaration)
+        if flat753 is not None:
+            assert flat753 is not None
+            self.write(flat753)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("def"):
-                _t1278 = getattr(_dollar_dollar, 'def')
+                _t1304 = getattr(_dollar_dollar, 'def')
             else:
-                _t1278 = None
-            deconstruct_result738 = _t1278
-            if deconstruct_result738 is not None:
-                assert deconstruct_result738 is not None
-                unwrapped739 = deconstruct_result738
-                self.pretty_def(unwrapped739)
+                _t1304 = None
+            deconstruct_result751 = _t1304
+            if deconstruct_result751 is not None:
+                assert deconstruct_result751 is not None
+                unwrapped752 = deconstruct_result751
+                self.pretty_def(unwrapped752)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("algorithm"):
-                    _t1279 = _dollar_dollar.algorithm
+                    _t1305 = _dollar_dollar.algorithm
                 else:
-                    _t1279 = None
-                deconstruct_result736 = _t1279
-                if deconstruct_result736 is not None:
-                    assert deconstruct_result736 is not None
-                    unwrapped737 = deconstruct_result736
-                    self.pretty_algorithm(unwrapped737)
+                    _t1305 = None
+                deconstruct_result749 = _t1305
+                if deconstruct_result749 is not None:
+                    assert deconstruct_result749 is not None
+                    unwrapped750 = deconstruct_result749
+                    self.pretty_algorithm(unwrapped750)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("constraint"):
-                        _t1280 = _dollar_dollar.constraint
+                        _t1306 = _dollar_dollar.constraint
                     else:
-                        _t1280 = None
-                    deconstruct_result734 = _t1280
-                    if deconstruct_result734 is not None:
-                        assert deconstruct_result734 is not None
-                        unwrapped735 = deconstruct_result734
-                        self.pretty_constraint(unwrapped735)
+                        _t1306 = None
+                    deconstruct_result747 = _t1306
+                    if deconstruct_result747 is not None:
+                        assert deconstruct_result747 is not None
+                        unwrapped748 = deconstruct_result747
+                        self.pretty_constraint(unwrapped748)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("data"):
-                            _t1281 = _dollar_dollar.data
+                            _t1307 = _dollar_dollar.data
                         else:
-                            _t1281 = None
-                        deconstruct_result732 = _t1281
-                        if deconstruct_result732 is not None:
-                            assert deconstruct_result732 is not None
-                            unwrapped733 = deconstruct_result732
-                            self.pretty_data(unwrapped733)
+                            _t1307 = None
+                        deconstruct_result745 = _t1307
+                        if deconstruct_result745 is not None:
+                            assert deconstruct_result745 is not None
+                            unwrapped746 = deconstruct_result745
+                            self.pretty_data(unwrapped746)
                         else:
                             raise ParseError("No matching rule for declaration")
 
     def pretty_def(self, msg: logic_pb2.Def):
-        flat747 = self._try_flat(msg, self.pretty_def)
-        if flat747 is not None:
-            assert flat747 is not None
-            self.write(flat747)
+        flat760 = self._try_flat(msg, self.pretty_def)
+        if flat760 is not None:
+            assert flat760 is not None
+            self.write(flat760)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1282 = _dollar_dollar.attrs
+                _t1308 = _dollar_dollar.attrs
             else:
-                _t1282 = None
-            fields741 = (_dollar_dollar.name, _dollar_dollar.body, _t1282,)
-            assert fields741 is not None
-            unwrapped_fields742 = fields741
+                _t1308 = None
+            fields754 = (_dollar_dollar.name, _dollar_dollar.body, _t1308,)
+            assert fields754 is not None
+            unwrapped_fields755 = fields754
             self.write("(def")
             self.indent_sexp()
             self.newline()
-            field743 = unwrapped_fields742[0]
-            self.pretty_relation_id(field743)
+            field756 = unwrapped_fields755[0]
+            self.pretty_relation_id(field756)
             self.newline()
-            field744 = unwrapped_fields742[1]
-            self.pretty_abstraction(field744)
-            field745 = unwrapped_fields742[2]
-            if field745 is not None:
+            field757 = unwrapped_fields755[1]
+            self.pretty_abstraction(field757)
+            field758 = unwrapped_fields755[2]
+            if field758 is not None:
                 self.newline()
-                assert field745 is not None
-                opt_val746 = field745
-                self.pretty_attrs(opt_val746)
+                assert field758 is not None
+                opt_val759 = field758
+                self.pretty_attrs(opt_val759)
             self.dedent()
             self.write(")")
 
     def pretty_relation_id(self, msg: logic_pb2.RelationId):
-        flat752 = self._try_flat(msg, self.pretty_relation_id)
-        if flat752 is not None:
-            assert flat752 is not None
-            self.write(flat752)
+        flat765 = self._try_flat(msg, self.pretty_relation_id)
+        if flat765 is not None:
+            assert flat765 is not None
+            self.write(flat765)
             return None
         else:
             _dollar_dollar = msg
             if self.relation_id_to_string(_dollar_dollar) is not None:
-                _t1284 = self.deconstruct_relation_id_string(_dollar_dollar)
-                _t1283 = _t1284
+                _t1310 = self.deconstruct_relation_id_string(_dollar_dollar)
+                _t1309 = _t1310
             else:
-                _t1283 = None
-            deconstruct_result750 = _t1283
-            if deconstruct_result750 is not None:
-                assert deconstruct_result750 is not None
-                unwrapped751 = deconstruct_result750
+                _t1309 = None
+            deconstruct_result763 = _t1309
+            if deconstruct_result763 is not None:
+                assert deconstruct_result763 is not None
+                unwrapped764 = deconstruct_result763
                 self.write(":")
-                self.write(unwrapped751)
+                self.write(unwrapped764)
             else:
                 _dollar_dollar = msg
-                _t1285 = self.deconstruct_relation_id_uint128(_dollar_dollar)
-                deconstruct_result748 = _t1285
-                if deconstruct_result748 is not None:
-                    assert deconstruct_result748 is not None
-                    unwrapped749 = deconstruct_result748
-                    self.write(self.format_uint128(unwrapped749))
+                _t1311 = self.deconstruct_relation_id_uint128(_dollar_dollar)
+                deconstruct_result761 = _t1311
+                if deconstruct_result761 is not None:
+                    assert deconstruct_result761 is not None
+                    unwrapped762 = deconstruct_result761
+                    self.write(self.format_uint128(unwrapped762))
                 else:
                     raise ParseError("No matching rule for relation_id")
 
     def pretty_abstraction(self, msg: logic_pb2.Abstraction):
-        flat757 = self._try_flat(msg, self.pretty_abstraction)
-        if flat757 is not None:
-            assert flat757 is not None
-            self.write(flat757)
+        flat770 = self._try_flat(msg, self.pretty_abstraction)
+        if flat770 is not None:
+            assert flat770 is not None
+            self.write(flat770)
             return None
         else:
             _dollar_dollar = msg
-            _t1286 = self.deconstruct_bindings(_dollar_dollar)
-            fields753 = (_t1286, _dollar_dollar.value,)
-            assert fields753 is not None
-            unwrapped_fields754 = fields753
+            _t1312 = self.deconstruct_bindings(_dollar_dollar)
+            fields766 = (_t1312, _dollar_dollar.value,)
+            assert fields766 is not None
+            unwrapped_fields767 = fields766
             self.write("(")
             self.indent()
-            field755 = unwrapped_fields754[0]
-            self.pretty_bindings(field755)
+            field768 = unwrapped_fields767[0]
+            self.pretty_bindings(field768)
             self.newline()
-            field756 = unwrapped_fields754[1]
-            self.pretty_formula(field756)
+            field769 = unwrapped_fields767[1]
+            self.pretty_formula(field769)
             self.dedent()
             self.write(")")
 
     def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]):
-        flat765 = self._try_flat(msg, self.pretty_bindings)
-        if flat765 is not None:
-            assert flat765 is not None
-            self.write(flat765)
+        flat778 = self._try_flat(msg, self.pretty_bindings)
+        if flat778 is not None:
+            assert flat778 is not None
+            self.write(flat778)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar[1]) == 0:
-                _t1287 = _dollar_dollar[1]
+                _t1313 = _dollar_dollar[1]
             else:
-                _t1287 = None
-            fields758 = (_dollar_dollar[0], _t1287,)
-            assert fields758 is not None
-            unwrapped_fields759 = fields758
+                _t1313 = None
+            fields771 = (_dollar_dollar[0], _t1313,)
+            assert fields771 is not None
+            unwrapped_fields772 = fields771
             self.write("[")
             self.indent()
-            field760 = unwrapped_fields759[0]
-            for i762, elem761 in enumerate(field760):
-                if (i762 > 0):
+            field773 = unwrapped_fields772[0]
+            for i775, elem774 in enumerate(field773):
+                if (i775 > 0):
                     self.newline()
-                self.pretty_binding(elem761)
-            field763 = unwrapped_fields759[1]
-            if field763 is not None:
+                self.pretty_binding(elem774)
+            field776 = unwrapped_fields772[1]
+            if field776 is not None:
                 self.newline()
-                assert field763 is not None
-                opt_val764 = field763
-                self.pretty_value_bindings(opt_val764)
+                assert field776 is not None
+                opt_val777 = field776
+                self.pretty_value_bindings(opt_val777)
             self.dedent()
             self.write("]")
 
     def pretty_binding(self, msg: logic_pb2.Binding):
-        flat770 = self._try_flat(msg, self.pretty_binding)
-        if flat770 is not None:
-            assert flat770 is not None
-            self.write(flat770)
+        flat783 = self._try_flat(msg, self.pretty_binding)
+        if flat783 is not None:
+            assert flat783 is not None
+            self.write(flat783)
             return None
         else:
             _dollar_dollar = msg
-            fields766 = (_dollar_dollar.var.name, _dollar_dollar.type,)
-            assert fields766 is not None
-            unwrapped_fields767 = fields766
-            field768 = unwrapped_fields767[0]
-            self.write(field768)
+            fields779 = (_dollar_dollar.var.name, _dollar_dollar.type,)
+            assert fields779 is not None
+            unwrapped_fields780 = fields779
+            field781 = unwrapped_fields780[0]
+            self.write(field781)
             self.write("::")
-            field769 = unwrapped_fields767[1]
-            self.pretty_type(field769)
+            field782 = unwrapped_fields780[1]
+            self.pretty_type(field782)
 
     def pretty_type(self, msg: logic_pb2.Type):
-        flat793 = self._try_flat(msg, self.pretty_type)
-        if flat793 is not None:
-            assert flat793 is not None
-            self.write(flat793)
+        flat806 = self._try_flat(msg, self.pretty_type)
+        if flat806 is not None:
+            assert flat806 is not None
+            self.write(flat806)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("unspecified_type"):
-                _t1288 = _dollar_dollar.unspecified_type
+                _t1314 = _dollar_dollar.unspecified_type
             else:
-                _t1288 = None
-            deconstruct_result791 = _t1288
-            if deconstruct_result791 is not None:
-                assert deconstruct_result791 is not None
-                unwrapped792 = deconstruct_result791
-                self.pretty_unspecified_type(unwrapped792)
+                _t1314 = None
+            deconstruct_result804 = _t1314
+            if deconstruct_result804 is not None:
+                assert deconstruct_result804 is not None
+                unwrapped805 = deconstruct_result804
+                self.pretty_unspecified_type(unwrapped805)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("string_type"):
-                    _t1289 = _dollar_dollar.string_type
+                    _t1315 = _dollar_dollar.string_type
                 else:
-                    _t1289 = None
-                deconstruct_result789 = _t1289
-                if deconstruct_result789 is not None:
-                    assert deconstruct_result789 is not None
-                    unwrapped790 = deconstruct_result789
-                    self.pretty_string_type(unwrapped790)
+                    _t1315 = None
+                deconstruct_result802 = _t1315
+                if deconstruct_result802 is not None:
+                    assert deconstruct_result802 is not None
+                    unwrapped803 = deconstruct_result802
+                    self.pretty_string_type(unwrapped803)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("int_type"):
-                        _t1290 = _dollar_dollar.int_type
+                        _t1316 = _dollar_dollar.int_type
                     else:
-                        _t1290 = None
-                    deconstruct_result787 = _t1290
-                    if deconstruct_result787 is not None:
-                        assert deconstruct_result787 is not None
-                        unwrapped788 = deconstruct_result787
-                        self.pretty_int_type(unwrapped788)
+                        _t1316 = None
+                    deconstruct_result800 = _t1316
+                    if deconstruct_result800 is not None:
+                        assert deconstruct_result800 is not None
+                        unwrapped801 = deconstruct_result800
+                        self.pretty_int_type(unwrapped801)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("float_type"):
-                            _t1291 = _dollar_dollar.float_type
+                            _t1317 = _dollar_dollar.float_type
                         else:
-                            _t1291 = None
-                        deconstruct_result785 = _t1291
-                        if deconstruct_result785 is not None:
-                            assert deconstruct_result785 is not None
-                            unwrapped786 = deconstruct_result785
-                            self.pretty_float_type(unwrapped786)
+                            _t1317 = None
+                        deconstruct_result798 = _t1317
+                        if deconstruct_result798 is not None:
+                            assert deconstruct_result798 is not None
+                            unwrapped799 = deconstruct_result798
+                            self.pretty_float_type(unwrapped799)
                         else:
                             _dollar_dollar = msg
                             if _dollar_dollar.HasField("uint128_type"):
-                                _t1292 = _dollar_dollar.uint128_type
+                                _t1318 = _dollar_dollar.uint128_type
                             else:
-                                _t1292 = None
-                            deconstruct_result783 = _t1292
-                            if deconstruct_result783 is not None:
-                                assert deconstruct_result783 is not None
-                                unwrapped784 = deconstruct_result783
-                                self.pretty_uint128_type(unwrapped784)
+                                _t1318 = None
+                            deconstruct_result796 = _t1318
+                            if deconstruct_result796 is not None:
+                                assert deconstruct_result796 is not None
+                                unwrapped797 = deconstruct_result796
+                                self.pretty_uint128_type(unwrapped797)
                             else:
                                 _dollar_dollar = msg
                                 if _dollar_dollar.HasField("int128_type"):
-                                    _t1293 = _dollar_dollar.int128_type
+                                    _t1319 = _dollar_dollar.int128_type
                                 else:
-                                    _t1293 = None
-                                deconstruct_result781 = _t1293
-                                if deconstruct_result781 is not None:
-                                    assert deconstruct_result781 is not None
-                                    unwrapped782 = deconstruct_result781
-                                    self.pretty_int128_type(unwrapped782)
+                                    _t1319 = None
+                                deconstruct_result794 = _t1319
+                                if deconstruct_result794 is not None:
+                                    assert deconstruct_result794 is not None
+                                    unwrapped795 = deconstruct_result794
+                                    self.pretty_int128_type(unwrapped795)
                                 else:
                                     _dollar_dollar = msg
                                     if _dollar_dollar.HasField("date_type"):
-                                        _t1294 = _dollar_dollar.date_type
+                                        _t1320 = _dollar_dollar.date_type
                                     else:
-                                        _t1294 = None
-                                    deconstruct_result779 = _t1294
-                                    if deconstruct_result779 is not None:
-                                        assert deconstruct_result779 is not None
-                                        unwrapped780 = deconstruct_result779
-                                        self.pretty_date_type(unwrapped780)
+                                        _t1320 = None
+                                    deconstruct_result792 = _t1320
+                                    if deconstruct_result792 is not None:
+                                        assert deconstruct_result792 is not None
+                                        unwrapped793 = deconstruct_result792
+                                        self.pretty_date_type(unwrapped793)
                                     else:
                                         _dollar_dollar = msg
                                         if _dollar_dollar.HasField("datetime_type"):
-                                            _t1295 = _dollar_dollar.datetime_type
+                                            _t1321 = _dollar_dollar.datetime_type
                                         else:
-                                            _t1295 = None
-                                        deconstruct_result777 = _t1295
-                                        if deconstruct_result777 is not None:
-                                            assert deconstruct_result777 is not None
-                                            unwrapped778 = deconstruct_result777
-                                            self.pretty_datetime_type(unwrapped778)
+                                            _t1321 = None
+                                        deconstruct_result790 = _t1321
+                                        if deconstruct_result790 is not None:
+                                            assert deconstruct_result790 is not None
+                                            unwrapped791 = deconstruct_result790
+                                            self.pretty_datetime_type(unwrapped791)
                                         else:
                                             _dollar_dollar = msg
                                             if _dollar_dollar.HasField("missing_type"):
-                                                _t1296 = _dollar_dollar.missing_type
+                                                _t1322 = _dollar_dollar.missing_type
                                             else:
-                                                _t1296 = None
-                                            deconstruct_result775 = _t1296
-                                            if deconstruct_result775 is not None:
-                                                assert deconstruct_result775 is not None
-                                                unwrapped776 = deconstruct_result775
-                                                self.pretty_missing_type(unwrapped776)
+                                                _t1322 = None
+                                            deconstruct_result788 = _t1322
+                                            if deconstruct_result788 is not None:
+                                                assert deconstruct_result788 is not None
+                                                unwrapped789 = deconstruct_result788
+                                                self.pretty_missing_type(unwrapped789)
                                             else:
                                                 _dollar_dollar = msg
                                                 if _dollar_dollar.HasField("decimal_type"):
-                                                    _t1297 = _dollar_dollar.decimal_type
+                                                    _t1323 = _dollar_dollar.decimal_type
                                                 else:
-                                                    _t1297 = None
-                                                deconstruct_result773 = _t1297
-                                                if deconstruct_result773 is not None:
-                                                    assert deconstruct_result773 is not None
-                                                    unwrapped774 = deconstruct_result773
-                                                    self.pretty_decimal_type(unwrapped774)
+                                                    _t1323 = None
+                                                deconstruct_result786 = _t1323
+                                                if deconstruct_result786 is not None:
+                                                    assert deconstruct_result786 is not None
+                                                    unwrapped787 = deconstruct_result786
+                                                    self.pretty_decimal_type(unwrapped787)
                                                 else:
                                                     _dollar_dollar = msg
                                                     if _dollar_dollar.HasField("boolean_type"):
-                                                        _t1298 = _dollar_dollar.boolean_type
+                                                        _t1324 = _dollar_dollar.boolean_type
                                                     else:
-                                                        _t1298 = None
-                                                    deconstruct_result771 = _t1298
-                                                    if deconstruct_result771 is not None:
-                                                        assert deconstruct_result771 is not None
-                                                        unwrapped772 = deconstruct_result771
-                                                        self.pretty_boolean_type(unwrapped772)
+                                                        _t1324 = None
+                                                    deconstruct_result784 = _t1324
+                                                    if deconstruct_result784 is not None:
+                                                        assert deconstruct_result784 is not None
+                                                        unwrapped785 = deconstruct_result784
+                                                        self.pretty_boolean_type(unwrapped785)
                                                     else:
                                                         raise ParseError("No matching rule for type")
 
     def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType):
-        fields794 = msg
+        fields807 = msg
         self.write("UNKNOWN")
 
     def pretty_string_type(self, msg: logic_pb2.StringType):
-        fields795 = msg
+        fields808 = msg
         self.write("STRING")
 
     def pretty_int_type(self, msg: logic_pb2.IntType):
-        fields796 = msg
+        fields809 = msg
         self.write("INT")
 
     def pretty_float_type(self, msg: logic_pb2.FloatType):
-        fields797 = msg
+        fields810 = msg
         self.write("FLOAT")
 
     def pretty_uint128_type(self, msg: logic_pb2.UInt128Type):
-        fields798 = msg
+        fields811 = msg
         self.write("UINT128")
 
     def pretty_int128_type(self, msg: logic_pb2.Int128Type):
-        fields799 = msg
+        fields812 = msg
         self.write("INT128")
 
     def pretty_date_type(self, msg: logic_pb2.DateType):
-        fields800 = msg
+        fields813 = msg
         self.write("DATE")
 
     def pretty_datetime_type(self, msg: logic_pb2.DateTimeType):
-        fields801 = msg
+        fields814 = msg
         self.write("DATETIME")
 
     def pretty_missing_type(self, msg: logic_pb2.MissingType):
-        fields802 = msg
+        fields815 = msg
         self.write("MISSING")
 
     def pretty_decimal_type(self, msg: logic_pb2.DecimalType):
-        flat807 = self._try_flat(msg, self.pretty_decimal_type)
-        if flat807 is not None:
-            assert flat807 is not None
-            self.write(flat807)
+        flat820 = self._try_flat(msg, self.pretty_decimal_type)
+        if flat820 is not None:
+            assert flat820 is not None
+            self.write(flat820)
             return None
         else:
             _dollar_dollar = msg
-            fields803 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),)
-            assert fields803 is not None
-            unwrapped_fields804 = fields803
+            fields816 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),)
+            assert fields816 is not None
+            unwrapped_fields817 = fields816
             self.write("(DECIMAL")
             self.indent_sexp()
             self.newline()
-            field805 = unwrapped_fields804[0]
-            self.write(str(field805))
+            field818 = unwrapped_fields817[0]
+            self.write(str(field818))
             self.newline()
-            field806 = unwrapped_fields804[1]
-            self.write(str(field806))
+            field819 = unwrapped_fields817[1]
+            self.write(str(field819))
             self.dedent()
             self.write(")")
 
     def pretty_boolean_type(self, msg: logic_pb2.BooleanType):
-        fields808 = msg
+        fields821 = msg
         self.write("BOOLEAN")
 
     def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]):
-        flat812 = self._try_flat(msg, self.pretty_value_bindings)
-        if flat812 is not None:
-            assert flat812 is not None
-            self.write(flat812)
+        flat825 = self._try_flat(msg, self.pretty_value_bindings)
+        if flat825 is not None:
+            assert flat825 is not None
+            self.write(flat825)
             return None
         else:
-            fields809 = msg
+            fields822 = msg
             self.write("|")
-            if not len(fields809) == 0:
+            if not len(fields822) == 0:
                 self.write(" ")
-                for i811, elem810 in enumerate(fields809):
-                    if (i811 > 0):
+                for i824, elem823 in enumerate(fields822):
+                    if (i824 > 0):
                         self.newline()
-                    self.pretty_binding(elem810)
+                    self.pretty_binding(elem823)
 
     def pretty_formula(self, msg: logic_pb2.Formula):
-        flat839 = self._try_flat(msg, self.pretty_formula)
-        if flat839 is not None:
-            assert flat839 is not None
-            self.write(flat839)
+        flat852 = self._try_flat(msg, self.pretty_formula)
+        if flat852 is not None:
+            assert flat852 is not None
+            self.write(flat852)
             return None
         else:
             _dollar_dollar = msg
             if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0):
-                _t1299 = _dollar_dollar.conjunction
+                _t1325 = _dollar_dollar.conjunction
             else:
-                _t1299 = None
-            deconstruct_result837 = _t1299
-            if deconstruct_result837 is not None:
-                assert deconstruct_result837 is not None
-                unwrapped838 = deconstruct_result837
-                self.pretty_true(unwrapped838)
+                _t1325 = None
+            deconstruct_result850 = _t1325
+            if deconstruct_result850 is not None:
+                assert deconstruct_result850 is not None
+                unwrapped851 = deconstruct_result850
+                self.pretty_true(unwrapped851)
             else:
                 _dollar_dollar = msg
                 if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0):
-                    _t1300 = _dollar_dollar.disjunction
+                    _t1326 = _dollar_dollar.disjunction
                 else:
-                    _t1300 = None
-                deconstruct_result835 = _t1300
-                if deconstruct_result835 is not None:
-                    assert deconstruct_result835 is not None
-                    unwrapped836 = deconstruct_result835
-                    self.pretty_false(unwrapped836)
+                    _t1326 = None
+                deconstruct_result848 = _t1326
+                if deconstruct_result848 is not None:
+                    assert deconstruct_result848 is not None
+                    unwrapped849 = deconstruct_result848
+                    self.pretty_false(unwrapped849)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("exists"):
-                        _t1301 = _dollar_dollar.exists
+                        _t1327 = _dollar_dollar.exists
                     else:
-                        _t1301 = None
-                    deconstruct_result833 = _t1301
-                    if deconstruct_result833 is not None:
-                        assert deconstruct_result833 is not None
-                        unwrapped834 = deconstruct_result833
-                        self.pretty_exists(unwrapped834)
+                        _t1327 = None
+                    deconstruct_result846 = _t1327
+                    if deconstruct_result846 is not None:
+                        assert deconstruct_result846 is not None
+                        unwrapped847 = deconstruct_result846
+                        self.pretty_exists(unwrapped847)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("reduce"):
-                            _t1302 = _dollar_dollar.reduce
+                            _t1328 = _dollar_dollar.reduce
                         else:
-                            _t1302 = None
-                        deconstruct_result831 = _t1302
-                        if deconstruct_result831 is not None:
-                            assert deconstruct_result831 is not None
-                            unwrapped832 = deconstruct_result831
-                            self.pretty_reduce(unwrapped832)
+                            _t1328 = None
+                        deconstruct_result844 = _t1328
+                        if deconstruct_result844 is not None:
+                            assert deconstruct_result844 is not None
+                            unwrapped845 = deconstruct_result844
+                            self.pretty_reduce(unwrapped845)
                         else:
                             _dollar_dollar = msg
                             if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0):
-                                _t1303 = _dollar_dollar.conjunction
+                                _t1329 = _dollar_dollar.conjunction
                             else:
-                                _t1303 = None
-                            deconstruct_result829 = _t1303
-                            if deconstruct_result829 is not None:
-                                assert deconstruct_result829 is not None
-                                unwrapped830 = deconstruct_result829
-                                self.pretty_conjunction(unwrapped830)
+                                _t1329 = None
+                            deconstruct_result842 = _t1329
+                            if deconstruct_result842 is not None:
+                                assert deconstruct_result842 is not None
+                                unwrapped843 = deconstruct_result842
+                                self.pretty_conjunction(unwrapped843)
                             else:
                                 _dollar_dollar = msg
                                 if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0):
-                                    _t1304 = _dollar_dollar.disjunction
+                                    _t1330 = _dollar_dollar.disjunction
                                 else:
-                                    _t1304 = None
-                                deconstruct_result827 = _t1304
-                                if deconstruct_result827 is not None:
-                                    assert deconstruct_result827 is not None
-                                    unwrapped828 = deconstruct_result827
-                                    self.pretty_disjunction(unwrapped828)
+                                    _t1330 = None
+                                deconstruct_result840 = _t1330
+                                if deconstruct_result840 is not None:
+                                    assert deconstruct_result840 is not None
+                                    unwrapped841 = deconstruct_result840
+                                    self.pretty_disjunction(unwrapped841)
                                 else:
                                     _dollar_dollar = msg
                                     if _dollar_dollar.HasField("not"):
-                                        _t1305 = getattr(_dollar_dollar, 'not')
+                                        _t1331 = getattr(_dollar_dollar, 'not')
                                     else:
-                                        _t1305 = None
-                                    deconstruct_result825 = _t1305
-                                    if deconstruct_result825 is not None:
-                                        assert deconstruct_result825 is not None
-                                        unwrapped826 = deconstruct_result825
-                                        self.pretty_not(unwrapped826)
+                                        _t1331 = None
+                                    deconstruct_result838 = _t1331
+                                    if deconstruct_result838 is not None:
+                                        assert deconstruct_result838 is not None
+                                        unwrapped839 = deconstruct_result838
+                                        self.pretty_not(unwrapped839)
                                     else:
                                         _dollar_dollar = msg
                                         if _dollar_dollar.HasField("ffi"):
-                                            _t1306 = _dollar_dollar.ffi
+                                            _t1332 = _dollar_dollar.ffi
                                         else:
-                                            _t1306 = None
-                                        deconstruct_result823 = _t1306
-                                        if deconstruct_result823 is not None:
-                                            assert deconstruct_result823 is not None
-                                            unwrapped824 = deconstruct_result823
-                                            self.pretty_ffi(unwrapped824)
+                                            _t1332 = None
+                                        deconstruct_result836 = _t1332
+                                        if deconstruct_result836 is not None:
+                                            assert deconstruct_result836 is not None
+                                            unwrapped837 = deconstruct_result836
+                                            self.pretty_ffi(unwrapped837)
                                         else:
                                             _dollar_dollar = msg
                                             if _dollar_dollar.HasField("atom"):
-                                                _t1307 = _dollar_dollar.atom
+                                                _t1333 = _dollar_dollar.atom
                                             else:
-                                                _t1307 = None
-                                            deconstruct_result821 = _t1307
-                                            if deconstruct_result821 is not None:
-                                                assert deconstruct_result821 is not None
-                                                unwrapped822 = deconstruct_result821
-                                                self.pretty_atom(unwrapped822)
+                                                _t1333 = None
+                                            deconstruct_result834 = _t1333
+                                            if deconstruct_result834 is not None:
+                                                assert deconstruct_result834 is not None
+                                                unwrapped835 = deconstruct_result834
+                                                self.pretty_atom(unwrapped835)
                                             else:
                                                 _dollar_dollar = msg
                                                 if _dollar_dollar.HasField("pragma"):
-                                                    _t1308 = _dollar_dollar.pragma
+                                                    _t1334 = _dollar_dollar.pragma
                                                 else:
-                                                    _t1308 = None
-                                                deconstruct_result819 = _t1308
-                                                if deconstruct_result819 is not None:
-                                                    assert deconstruct_result819 is not None
-                                                    unwrapped820 = deconstruct_result819
-                                                    self.pretty_pragma(unwrapped820)
+                                                    _t1334 = None
+                                                deconstruct_result832 = _t1334
+                                                if deconstruct_result832 is not None:
+                                                    assert deconstruct_result832 is not None
+                                                    unwrapped833 = deconstruct_result832
+                                                    self.pretty_pragma(unwrapped833)
                                                 else:
                                                     _dollar_dollar = msg
                                                     if _dollar_dollar.HasField("primitive"):
-                                                        _t1309 = _dollar_dollar.primitive
+                                                        _t1335 = _dollar_dollar.primitive
                                                     else:
-                                                        _t1309 = None
-                                                    deconstruct_result817 = _t1309
-                                                    if deconstruct_result817 is not None:
-                                                        assert deconstruct_result817 is not None
-                                                        unwrapped818 = deconstruct_result817
-                                                        self.pretty_primitive(unwrapped818)
+                                                        _t1335 = None
+                                                    deconstruct_result830 = _t1335
+                                                    if deconstruct_result830 is not None:
+                                                        assert deconstruct_result830 is not None
+                                                        unwrapped831 = deconstruct_result830
+                                                        self.pretty_primitive(unwrapped831)
                                                     else:
                                                         _dollar_dollar = msg
                                                         if _dollar_dollar.HasField("rel_atom"):
-                                                            _t1310 = _dollar_dollar.rel_atom
+                                                            _t1336 = _dollar_dollar.rel_atom
                                                         else:
-                                                            _t1310 = None
-                                                        deconstruct_result815 = _t1310
-                                                        if deconstruct_result815 is not None:
-                                                            assert deconstruct_result815 is not None
-                                                            unwrapped816 = deconstruct_result815
-                                                            self.pretty_rel_atom(unwrapped816)
+                                                            _t1336 = None
+                                                        deconstruct_result828 = _t1336
+                                                        if deconstruct_result828 is not None:
+                                                            assert deconstruct_result828 is not None
+                                                            unwrapped829 = deconstruct_result828
+                                                            self.pretty_rel_atom(unwrapped829)
                                                         else:
                                                             _dollar_dollar = msg
                                                             if _dollar_dollar.HasField("cast"):
-                                                                _t1311 = _dollar_dollar.cast
+                                                                _t1337 = _dollar_dollar.cast
                                                             else:
-                                                                _t1311 = None
-                                                            deconstruct_result813 = _t1311
-                                                            if deconstruct_result813 is not None:
-                                                                assert deconstruct_result813 is not None
-                                                                unwrapped814 = deconstruct_result813
-                                                                self.pretty_cast(unwrapped814)
+                                                                _t1337 = None
+                                                            deconstruct_result826 = _t1337
+                                                            if deconstruct_result826 is not None:
+                                                                assert deconstruct_result826 is not None
+                                                                unwrapped827 = deconstruct_result826
+                                                                self.pretty_cast(unwrapped827)
                                                             else:
                                                                 raise ParseError("No matching rule for formula")
 
     def pretty_true(self, msg: logic_pb2.Conjunction):
-        fields840 = msg
+        fields853 = msg
         self.write("(true)")
 
     def pretty_false(self, msg: logic_pb2.Disjunction):
-        fields841 = msg
+        fields854 = msg
         self.write("(false)")
 
     def pretty_exists(self, msg: logic_pb2.Exists):
-        flat846 = self._try_flat(msg, self.pretty_exists)
-        if flat846 is not None:
-            assert flat846 is not None
-            self.write(flat846)
+        flat859 = self._try_flat(msg, self.pretty_exists)
+        if flat859 is not None:
+            assert flat859 is not None
+            self.write(flat859)
             return None
         else:
             _dollar_dollar = msg
-            _t1312 = self.deconstruct_bindings(_dollar_dollar.body)
-            fields842 = (_t1312, _dollar_dollar.body.value,)
-            assert fields842 is not None
-            unwrapped_fields843 = fields842
+            _t1338 = self.deconstruct_bindings(_dollar_dollar.body)
+            fields855 = (_t1338, _dollar_dollar.body.value,)
+            assert fields855 is not None
+            unwrapped_fields856 = fields855
             self.write("(exists")
             self.indent_sexp()
             self.newline()
-            field844 = unwrapped_fields843[0]
-            self.pretty_bindings(field844)
+            field857 = unwrapped_fields856[0]
+            self.pretty_bindings(field857)
             self.newline()
-            field845 = unwrapped_fields843[1]
-            self.pretty_formula(field845)
+            field858 = unwrapped_fields856[1]
+            self.pretty_formula(field858)
             self.dedent()
             self.write(")")
 
     def pretty_reduce(self, msg: logic_pb2.Reduce):
-        flat852 = self._try_flat(msg, self.pretty_reduce)
-        if flat852 is not None:
-            assert flat852 is not None
-            self.write(flat852)
+        flat865 = self._try_flat(msg, self.pretty_reduce)
+        if flat865 is not None:
+            assert flat865 is not None
+            self.write(flat865)
             return None
         else:
             _dollar_dollar = msg
-            fields847 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,)
-            assert fields847 is not None
-            unwrapped_fields848 = fields847
+            fields860 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,)
+            assert fields860 is not None
+            unwrapped_fields861 = fields860
             self.write("(reduce")
             self.indent_sexp()
             self.newline()
-            field849 = unwrapped_fields848[0]
-            self.pretty_abstraction(field849)
+            field862 = unwrapped_fields861[0]
+            self.pretty_abstraction(field862)
             self.newline()
-            field850 = unwrapped_fields848[1]
-            self.pretty_abstraction(field850)
+            field863 = unwrapped_fields861[1]
+            self.pretty_abstraction(field863)
             self.newline()
-            field851 = unwrapped_fields848[2]
-            self.pretty_terms(field851)
+            field864 = unwrapped_fields861[2]
+            self.pretty_terms(field864)
             self.dedent()
             self.write(")")
 
     def pretty_terms(self, msg: Sequence[logic_pb2.Term]):
-        flat856 = self._try_flat(msg, self.pretty_terms)
-        if flat856 is not None:
-            assert flat856 is not None
-            self.write(flat856)
+        flat869 = self._try_flat(msg, self.pretty_terms)
+        if flat869 is not None:
+            assert flat869 is not None
+            self.write(flat869)
             return None
         else:
-            fields853 = msg
+            fields866 = msg
             self.write("(terms")
             self.indent_sexp()
-            if not len(fields853) == 0:
+            if not len(fields866) == 0:
                 self.newline()
-                for i855, elem854 in enumerate(fields853):
-                    if (i855 > 0):
+                for i868, elem867 in enumerate(fields866):
+                    if (i868 > 0):
                         self.newline()
-                    self.pretty_term(elem854)
+                    self.pretty_term(elem867)
             self.dedent()
             self.write(")")
 
     def pretty_term(self, msg: logic_pb2.Term):
-        flat861 = self._try_flat(msg, self.pretty_term)
-        if flat861 is not None:
-            assert flat861 is not None
-            self.write(flat861)
+        flat874 = self._try_flat(msg, self.pretty_term)
+        if flat874 is not None:
+            assert flat874 is not None
+            self.write(flat874)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("var"):
-                _t1313 = _dollar_dollar.var
+                _t1339 = _dollar_dollar.var
             else:
-                _t1313 = None
-            deconstruct_result859 = _t1313
-            if deconstruct_result859 is not None:
-                assert deconstruct_result859 is not None
-                unwrapped860 = deconstruct_result859
-                self.pretty_var(unwrapped860)
+                _t1339 = None
+            deconstruct_result872 = _t1339
+            if deconstruct_result872 is not None:
+                assert deconstruct_result872 is not None
+                unwrapped873 = deconstruct_result872
+                self.pretty_var(unwrapped873)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("constant"):
-                    _t1314 = _dollar_dollar.constant
+                    _t1340 = _dollar_dollar.constant
                 else:
-                    _t1314 = None
-                deconstruct_result857 = _t1314
-                if deconstruct_result857 is not None:
-                    assert deconstruct_result857 is not None
-                    unwrapped858 = deconstruct_result857
-                    self.pretty_constant(unwrapped858)
+                    _t1340 = None
+                deconstruct_result870 = _t1340
+                if deconstruct_result870 is not None:
+                    assert deconstruct_result870 is not None
+                    unwrapped871 = deconstruct_result870
+                    self.pretty_constant(unwrapped871)
                 else:
                     raise ParseError("No matching rule for term")
 
     def pretty_var(self, msg: logic_pb2.Var):
-        flat864 = self._try_flat(msg, self.pretty_var)
-        if flat864 is not None:
-            assert flat864 is not None
-            self.write(flat864)
+        flat877 = self._try_flat(msg, self.pretty_var)
+        if flat877 is not None:
+            assert flat877 is not None
+            self.write(flat877)
             return None
         else:
             _dollar_dollar = msg
-            fields862 = _dollar_dollar.name
-            assert fields862 is not None
-            unwrapped_fields863 = fields862
-            self.write(unwrapped_fields863)
+            fields875 = _dollar_dollar.name
+            assert fields875 is not None
+            unwrapped_fields876 = fields875
+            self.write(unwrapped_fields876)
 
     def pretty_constant(self, msg: logic_pb2.Value):
-        flat866 = self._try_flat(msg, self.pretty_constant)
-        if flat866 is not None:
-            assert flat866 is not None
-            self.write(flat866)
+        flat879 = self._try_flat(msg, self.pretty_constant)
+        if flat879 is not None:
+            assert flat879 is not None
+            self.write(flat879)
             return None
         else:
-            fields865 = msg
-            self.pretty_value(fields865)
+            fields878 = msg
+            self.pretty_value(fields878)
 
     def pretty_conjunction(self, msg: logic_pb2.Conjunction):
-        flat871 = self._try_flat(msg, self.pretty_conjunction)
-        if flat871 is not None:
-            assert flat871 is not None
-            self.write(flat871)
+        flat884 = self._try_flat(msg, self.pretty_conjunction)
+        if flat884 is not None:
+            assert flat884 is not None
+            self.write(flat884)
             return None
         else:
             _dollar_dollar = msg
-            fields867 = _dollar_dollar.args
-            assert fields867 is not None
-            unwrapped_fields868 = fields867
+            fields880 = _dollar_dollar.args
+            assert fields880 is not None
+            unwrapped_fields881 = fields880
             self.write("(and")
             self.indent_sexp()
-            if not len(unwrapped_fields868) == 0:
+            if not len(unwrapped_fields881) == 0:
                 self.newline()
-                for i870, elem869 in enumerate(unwrapped_fields868):
-                    if (i870 > 0):
+                for i883, elem882 in enumerate(unwrapped_fields881):
+                    if (i883 > 0):
                         self.newline()
-                    self.pretty_formula(elem869)
+                    self.pretty_formula(elem882)
             self.dedent()
             self.write(")")
 
     def pretty_disjunction(self, msg: logic_pb2.Disjunction):
-        flat876 = self._try_flat(msg, self.pretty_disjunction)
-        if flat876 is not None:
-            assert flat876 is not None
-            self.write(flat876)
+        flat889 = self._try_flat(msg, self.pretty_disjunction)
+        if flat889 is not None:
+            assert flat889 is not None
+            self.write(flat889)
             return None
         else:
             _dollar_dollar = msg
-            fields872 = _dollar_dollar.args
-            assert fields872 is not None
-            unwrapped_fields873 = fields872
+            fields885 = _dollar_dollar.args
+            assert fields885 is not None
+            unwrapped_fields886 = fields885
             self.write("(or")
             self.indent_sexp()
-            if not len(unwrapped_fields873) == 0:
+            if not len(unwrapped_fields886) == 0:
                 self.newline()
-                for i875, elem874 in enumerate(unwrapped_fields873):
-                    if (i875 > 0):
+                for i888, elem887 in enumerate(unwrapped_fields886):
+                    if (i888 > 0):
                         self.newline()
-                    self.pretty_formula(elem874)
+                    self.pretty_formula(elem887)
             self.dedent()
             self.write(")")
 
     def pretty_not(self, msg: logic_pb2.Not):
-        flat879 = self._try_flat(msg, self.pretty_not)
-        if flat879 is not None:
-            assert flat879 is not None
-            self.write(flat879)
+        flat892 = self._try_flat(msg, self.pretty_not)
+        if flat892 is not None:
+            assert flat892 is not None
+            self.write(flat892)
             return None
         else:
             _dollar_dollar = msg
-            fields877 = _dollar_dollar.arg
-            assert fields877 is not None
-            unwrapped_fields878 = fields877
+            fields890 = _dollar_dollar.arg
+            assert fields890 is not None
+            unwrapped_fields891 = fields890
             self.write("(not")
             self.indent_sexp()
             self.newline()
-            self.pretty_formula(unwrapped_fields878)
+            self.pretty_formula(unwrapped_fields891)
             self.dedent()
             self.write(")")
 
     def pretty_ffi(self, msg: logic_pb2.FFI):
-        flat885 = self._try_flat(msg, self.pretty_ffi)
-        if flat885 is not None:
-            assert flat885 is not None
-            self.write(flat885)
+        flat898 = self._try_flat(msg, self.pretty_ffi)
+        if flat898 is not None:
+            assert flat898 is not None
+            self.write(flat898)
             return None
         else:
             _dollar_dollar = msg
-            fields880 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,)
-            assert fields880 is not None
-            unwrapped_fields881 = fields880
+            fields893 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,)
+            assert fields893 is not None
+            unwrapped_fields894 = fields893
             self.write("(ffi")
             self.indent_sexp()
             self.newline()
-            field882 = unwrapped_fields881[0]
-            self.pretty_name(field882)
+            field895 = unwrapped_fields894[0]
+            self.pretty_name(field895)
             self.newline()
-            field883 = unwrapped_fields881[1]
-            self.pretty_ffi_args(field883)
+            field896 = unwrapped_fields894[1]
+            self.pretty_ffi_args(field896)
             self.newline()
-            field884 = unwrapped_fields881[2]
-            self.pretty_terms(field884)
+            field897 = unwrapped_fields894[2]
+            self.pretty_terms(field897)
             self.dedent()
             self.write(")")
 
     def pretty_name(self, msg: str):
-        flat887 = self._try_flat(msg, self.pretty_name)
-        if flat887 is not None:
-            assert flat887 is not None
-            self.write(flat887)
+        flat900 = self._try_flat(msg, self.pretty_name)
+        if flat900 is not None:
+            assert flat900 is not None
+            self.write(flat900)
             return None
         else:
-            fields886 = msg
+            fields899 = msg
             self.write(":")
-            self.write(fields886)
+            self.write(fields899)
 
     def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]):
-        flat891 = self._try_flat(msg, self.pretty_ffi_args)
-        if flat891 is not None:
-            assert flat891 is not None
-            self.write(flat891)
+        flat904 = self._try_flat(msg, self.pretty_ffi_args)
+        if flat904 is not None:
+            assert flat904 is not None
+            self.write(flat904)
             return None
         else:
-            fields888 = msg
+            fields901 = msg
             self.write("(args")
             self.indent_sexp()
-            if not len(fields888) == 0:
+            if not len(fields901) == 0:
                 self.newline()
-                for i890, elem889 in enumerate(fields888):
-                    if (i890 > 0):
+                for i903, elem902 in enumerate(fields901):
+                    if (i903 > 0):
                         self.newline()
-                    self.pretty_abstraction(elem889)
+                    self.pretty_abstraction(elem902)
             self.dedent()
             self.write(")")
 
     def pretty_atom(self, msg: logic_pb2.Atom):
-        flat898 = self._try_flat(msg, self.pretty_atom)
-        if flat898 is not None:
-            assert flat898 is not None
-            self.write(flat898)
+        flat911 = self._try_flat(msg, self.pretty_atom)
+        if flat911 is not None:
+            assert flat911 is not None
+            self.write(flat911)
             return None
         else:
             _dollar_dollar = msg
-            fields892 = (_dollar_dollar.name, _dollar_dollar.terms,)
-            assert fields892 is not None
-            unwrapped_fields893 = fields892
+            fields905 = (_dollar_dollar.name, _dollar_dollar.terms,)
+            assert fields905 is not None
+            unwrapped_fields906 = fields905
             self.write("(atom")
             self.indent_sexp()
             self.newline()
-            field894 = unwrapped_fields893[0]
-            self.pretty_relation_id(field894)
-            field895 = unwrapped_fields893[1]
-            if not len(field895) == 0:
+            field907 = unwrapped_fields906[0]
+            self.pretty_relation_id(field907)
+            field908 = unwrapped_fields906[1]
+            if not len(field908) == 0:
                 self.newline()
-                for i897, elem896 in enumerate(field895):
-                    if (i897 > 0):
+                for i910, elem909 in enumerate(field908):
+                    if (i910 > 0):
                         self.newline()
-                    self.pretty_term(elem896)
+                    self.pretty_term(elem909)
             self.dedent()
             self.write(")")
 
     def pretty_pragma(self, msg: logic_pb2.Pragma):
-        flat905 = self._try_flat(msg, self.pretty_pragma)
-        if flat905 is not None:
-            assert flat905 is not None
-            self.write(flat905)
+        flat918 = self._try_flat(msg, self.pretty_pragma)
+        if flat918 is not None:
+            assert flat918 is not None
+            self.write(flat918)
             return None
         else:
             _dollar_dollar = msg
-            fields899 = (_dollar_dollar.name, _dollar_dollar.terms,)
-            assert fields899 is not None
-            unwrapped_fields900 = fields899
+            fields912 = (_dollar_dollar.name, _dollar_dollar.terms,)
+            assert fields912 is not None
+            unwrapped_fields913 = fields912
             self.write("(pragma")
             self.indent_sexp()
             self.newline()
-            field901 = unwrapped_fields900[0]
-            self.pretty_name(field901)
-            field902 = unwrapped_fields900[1]
-            if not len(field902) == 0:
+            field914 = unwrapped_fields913[0]
+            self.pretty_name(field914)
+            field915 = unwrapped_fields913[1]
+            if not len(field915) == 0:
                 self.newline()
-                for i904, elem903 in enumerate(field902):
-                    if (i904 > 0):
+                for i917, elem916 in enumerate(field915):
+                    if (i917 > 0):
                         self.newline()
-                    self.pretty_term(elem903)
+                    self.pretty_term(elem916)
             self.dedent()
             self.write(")")
 
     def pretty_primitive(self, msg: logic_pb2.Primitive):
-        flat921 = self._try_flat(msg, self.pretty_primitive)
-        if flat921 is not None:
-            assert flat921 is not None
-            self.write(flat921)
+        flat934 = self._try_flat(msg, self.pretty_primitive)
+        if flat934 is not None:
+            assert flat934 is not None
+            self.write(flat934)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_eq":
-                _t1315 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1341 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1315 = None
-            guard_result920 = _t1315
-            if guard_result920 is not None:
+                _t1341 = None
+            guard_result933 = _t1341
+            if guard_result933 is not None:
                 self.pretty_eq(msg)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.name == "rel_primitive_lt_monotype":
-                    _t1316 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                    _t1342 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
                 else:
-                    _t1316 = None
-                guard_result919 = _t1316
-                if guard_result919 is not None:
+                    _t1342 = None
+                guard_result932 = _t1342
+                if guard_result932 is not None:
                     self.pretty_lt(msg)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.name == "rel_primitive_lt_eq_monotype":
-                        _t1317 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                        _t1343 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
                     else:
-                        _t1317 = None
-                    guard_result918 = _t1317
-                    if guard_result918 is not None:
+                        _t1343 = None
+                    guard_result931 = _t1343
+                    if guard_result931 is not None:
                         self.pretty_lt_eq(msg)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.name == "rel_primitive_gt_monotype":
-                            _t1318 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                            _t1344 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
                         else:
-                            _t1318 = None
-                        guard_result917 = _t1318
-                        if guard_result917 is not None:
+                            _t1344 = None
+                        guard_result930 = _t1344
+                        if guard_result930 is not None:
                             self.pretty_gt(msg)
                         else:
                             _dollar_dollar = msg
                             if _dollar_dollar.name == "rel_primitive_gt_eq_monotype":
-                                _t1319 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                                _t1345 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
                             else:
-                                _t1319 = None
-                            guard_result916 = _t1319
-                            if guard_result916 is not None:
+                                _t1345 = None
+                            guard_result929 = _t1345
+                            if guard_result929 is not None:
                                 self.pretty_gt_eq(msg)
                             else:
                                 _dollar_dollar = msg
                                 if _dollar_dollar.name == "rel_primitive_add_monotype":
-                                    _t1320 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                                    _t1346 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
                                 else:
-                                    _t1320 = None
-                                guard_result915 = _t1320
-                                if guard_result915 is not None:
+                                    _t1346 = None
+                                guard_result928 = _t1346
+                                if guard_result928 is not None:
                                     self.pretty_add(msg)
                                 else:
                                     _dollar_dollar = msg
                                     if _dollar_dollar.name == "rel_primitive_subtract_monotype":
-                                        _t1321 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                                        _t1347 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
                                     else:
-                                        _t1321 = None
-                                    guard_result914 = _t1321
-                                    if guard_result914 is not None:
+                                        _t1347 = None
+                                    guard_result927 = _t1347
+                                    if guard_result927 is not None:
                                         self.pretty_minus(msg)
                                     else:
                                         _dollar_dollar = msg
                                         if _dollar_dollar.name == "rel_primitive_multiply_monotype":
-                                            _t1322 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                                            _t1348 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
                                         else:
-                                            _t1322 = None
-                                        guard_result913 = _t1322
-                                        if guard_result913 is not None:
+                                            _t1348 = None
+                                        guard_result926 = _t1348
+                                        if guard_result926 is not None:
                                             self.pretty_multiply(msg)
                                         else:
                                             _dollar_dollar = msg
                                             if _dollar_dollar.name == "rel_primitive_divide_monotype":
-                                                _t1323 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                                                _t1349 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
                                             else:
-                                                _t1323 = None
-                                            guard_result912 = _t1323
-                                            if guard_result912 is not None:
+                                                _t1349 = None
+                                            guard_result925 = _t1349
+                                            if guard_result925 is not None:
                                                 self.pretty_divide(msg)
                                             else:
                                                 _dollar_dollar = msg
-                                                fields906 = (_dollar_dollar.name, _dollar_dollar.terms,)
-                                                assert fields906 is not None
-                                                unwrapped_fields907 = fields906
+                                                fields919 = (_dollar_dollar.name, _dollar_dollar.terms,)
+                                                assert fields919 is not None
+                                                unwrapped_fields920 = fields919
                                                 self.write("(primitive")
                                                 self.indent_sexp()
                                                 self.newline()
-                                                field908 = unwrapped_fields907[0]
-                                                self.pretty_name(field908)
-                                                field909 = unwrapped_fields907[1]
-                                                if not len(field909) == 0:
+                                                field921 = unwrapped_fields920[0]
+                                                self.pretty_name(field921)
+                                                field922 = unwrapped_fields920[1]
+                                                if not len(field922) == 0:
                                                     self.newline()
-                                                    for i911, elem910 in enumerate(field909):
-                                                        if (i911 > 0):
+                                                    for i924, elem923 in enumerate(field922):
+                                                        if (i924 > 0):
                                                             self.newline()
-                                                        self.pretty_rel_term(elem910)
+                                                        self.pretty_rel_term(elem923)
                                                 self.dedent()
                                                 self.write(")")
 
     def pretty_eq(self, msg: logic_pb2.Primitive):
-        flat926 = self._try_flat(msg, self.pretty_eq)
-        if flat926 is not None:
-            assert flat926 is not None
-            self.write(flat926)
+        flat939 = self._try_flat(msg, self.pretty_eq)
+        if flat939 is not None:
+            assert flat939 is not None
+            self.write(flat939)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_eq":
-                _t1324 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1350 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1324 = None
-            fields922 = _t1324
-            assert fields922 is not None
-            unwrapped_fields923 = fields922
+                _t1350 = None
+            fields935 = _t1350
+            assert fields935 is not None
+            unwrapped_fields936 = fields935
             self.write("(=")
             self.indent_sexp()
             self.newline()
-            field924 = unwrapped_fields923[0]
-            self.pretty_term(field924)
+            field937 = unwrapped_fields936[0]
+            self.pretty_term(field937)
             self.newline()
-            field925 = unwrapped_fields923[1]
-            self.pretty_term(field925)
+            field938 = unwrapped_fields936[1]
+            self.pretty_term(field938)
             self.dedent()
             self.write(")")
 
     def pretty_lt(self, msg: logic_pb2.Primitive):
-        flat931 = self._try_flat(msg, self.pretty_lt)
-        if flat931 is not None:
-            assert flat931 is not None
-            self.write(flat931)
+        flat944 = self._try_flat(msg, self.pretty_lt)
+        if flat944 is not None:
+            assert flat944 is not None
+            self.write(flat944)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_lt_monotype":
-                _t1325 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1351 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1325 = None
-            fields927 = _t1325
-            assert fields927 is not None
-            unwrapped_fields928 = fields927
+                _t1351 = None
+            fields940 = _t1351
+            assert fields940 is not None
+            unwrapped_fields941 = fields940
             self.write("(<")
             self.indent_sexp()
             self.newline()
-            field929 = unwrapped_fields928[0]
-            self.pretty_term(field929)
+            field942 = unwrapped_fields941[0]
+            self.pretty_term(field942)
             self.newline()
-            field930 = unwrapped_fields928[1]
-            self.pretty_term(field930)
+            field943 = unwrapped_fields941[1]
+            self.pretty_term(field943)
             self.dedent()
             self.write(")")
 
     def pretty_lt_eq(self, msg: logic_pb2.Primitive):
-        flat936 = self._try_flat(msg, self.pretty_lt_eq)
-        if flat936 is not None:
-            assert flat936 is not None
-            self.write(flat936)
+        flat949 = self._try_flat(msg, self.pretty_lt_eq)
+        if flat949 is not None:
+            assert flat949 is not None
+            self.write(flat949)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_lt_eq_monotype":
-                _t1326 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1352 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1326 = None
-            fields932 = _t1326
-            assert fields932 is not None
-            unwrapped_fields933 = fields932
+                _t1352 = None
+            fields945 = _t1352
+            assert fields945 is not None
+            unwrapped_fields946 = fields945
             self.write("(<=")
             self.indent_sexp()
             self.newline()
-            field934 = unwrapped_fields933[0]
-            self.pretty_term(field934)
+            field947 = unwrapped_fields946[0]
+            self.pretty_term(field947)
             self.newline()
-            field935 = unwrapped_fields933[1]
-            self.pretty_term(field935)
+            field948 = unwrapped_fields946[1]
+            self.pretty_term(field948)
             self.dedent()
             self.write(")")
 
     def pretty_gt(self, msg: logic_pb2.Primitive):
-        flat941 = self._try_flat(msg, self.pretty_gt)
-        if flat941 is not None:
-            assert flat941 is not None
-            self.write(flat941)
+        flat954 = self._try_flat(msg, self.pretty_gt)
+        if flat954 is not None:
+            assert flat954 is not None
+            self.write(flat954)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_gt_monotype":
-                _t1327 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1353 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1327 = None
-            fields937 = _t1327
-            assert fields937 is not None
-            unwrapped_fields938 = fields937
+                _t1353 = None
+            fields950 = _t1353
+            assert fields950 is not None
+            unwrapped_fields951 = fields950
             self.write("(>")
             self.indent_sexp()
             self.newline()
-            field939 = unwrapped_fields938[0]
-            self.pretty_term(field939)
+            field952 = unwrapped_fields951[0]
+            self.pretty_term(field952)
             self.newline()
-            field940 = unwrapped_fields938[1]
-            self.pretty_term(field940)
+            field953 = unwrapped_fields951[1]
+            self.pretty_term(field953)
             self.dedent()
             self.write(")")
 
     def pretty_gt_eq(self, msg: logic_pb2.Primitive):
-        flat946 = self._try_flat(msg, self.pretty_gt_eq)
-        if flat946 is not None:
-            assert flat946 is not None
-            self.write(flat946)
+        flat959 = self._try_flat(msg, self.pretty_gt_eq)
+        if flat959 is not None:
+            assert flat959 is not None
+            self.write(flat959)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_gt_eq_monotype":
-                _t1328 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
+                _t1354 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,)
             else:
-                _t1328 = None
-            fields942 = _t1328
-            assert fields942 is not None
-            unwrapped_fields943 = fields942
+                _t1354 = None
+            fields955 = _t1354
+            assert fields955 is not None
+            unwrapped_fields956 = fields955
             self.write("(>=")
             self.indent_sexp()
             self.newline()
-            field944 = unwrapped_fields943[0]
-            self.pretty_term(field944)
+            field957 = unwrapped_fields956[0]
+            self.pretty_term(field957)
             self.newline()
-            field945 = unwrapped_fields943[1]
-            self.pretty_term(field945)
+            field958 = unwrapped_fields956[1]
+            self.pretty_term(field958)
             self.dedent()
             self.write(")")
 
     def pretty_add(self, msg: logic_pb2.Primitive):
-        flat952 = self._try_flat(msg, self.pretty_add)
-        if flat952 is not None:
-            assert flat952 is not None
-            self.write(flat952)
+        flat965 = self._try_flat(msg, self.pretty_add)
+        if flat965 is not None:
+            assert flat965 is not None
+            self.write(flat965)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_add_monotype":
-                _t1329 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                _t1355 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
             else:
-                _t1329 = None
-            fields947 = _t1329
-            assert fields947 is not None
-            unwrapped_fields948 = fields947
+                _t1355 = None
+            fields960 = _t1355
+            assert fields960 is not None
+            unwrapped_fields961 = fields960
             self.write("(+")
             self.indent_sexp()
             self.newline()
-            field949 = unwrapped_fields948[0]
-            self.pretty_term(field949)
+            field962 = unwrapped_fields961[0]
+            self.pretty_term(field962)
             self.newline()
-            field950 = unwrapped_fields948[1]
-            self.pretty_term(field950)
+            field963 = unwrapped_fields961[1]
+            self.pretty_term(field963)
             self.newline()
-            field951 = unwrapped_fields948[2]
-            self.pretty_term(field951)
+            field964 = unwrapped_fields961[2]
+            self.pretty_term(field964)
             self.dedent()
             self.write(")")
 
     def pretty_minus(self, msg: logic_pb2.Primitive):
-        flat958 = self._try_flat(msg, self.pretty_minus)
-        if flat958 is not None:
-            assert flat958 is not None
-            self.write(flat958)
+        flat971 = self._try_flat(msg, self.pretty_minus)
+        if flat971 is not None:
+            assert flat971 is not None
+            self.write(flat971)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_subtract_monotype":
-                _t1330 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                _t1356 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
             else:
-                _t1330 = None
-            fields953 = _t1330
-            assert fields953 is not None
-            unwrapped_fields954 = fields953
+                _t1356 = None
+            fields966 = _t1356
+            assert fields966 is not None
+            unwrapped_fields967 = fields966
             self.write("(-")
             self.indent_sexp()
             self.newline()
-            field955 = unwrapped_fields954[0]
-            self.pretty_term(field955)
+            field968 = unwrapped_fields967[0]
+            self.pretty_term(field968)
             self.newline()
-            field956 = unwrapped_fields954[1]
-            self.pretty_term(field956)
+            field969 = unwrapped_fields967[1]
+            self.pretty_term(field969)
             self.newline()
-            field957 = unwrapped_fields954[2]
-            self.pretty_term(field957)
+            field970 = unwrapped_fields967[2]
+            self.pretty_term(field970)
             self.dedent()
             self.write(")")
 
     def pretty_multiply(self, msg: logic_pb2.Primitive):
-        flat964 = self._try_flat(msg, self.pretty_multiply)
-        if flat964 is not None:
-            assert flat964 is not None
-            self.write(flat964)
+        flat977 = self._try_flat(msg, self.pretty_multiply)
+        if flat977 is not None:
+            assert flat977 is not None
+            self.write(flat977)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_multiply_monotype":
-                _t1331 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                _t1357 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
             else:
-                _t1331 = None
-            fields959 = _t1331
-            assert fields959 is not None
-            unwrapped_fields960 = fields959
+                _t1357 = None
+            fields972 = _t1357
+            assert fields972 is not None
+            unwrapped_fields973 = fields972
             self.write("(*")
             self.indent_sexp()
             self.newline()
-            field961 = unwrapped_fields960[0]
-            self.pretty_term(field961)
+            field974 = unwrapped_fields973[0]
+            self.pretty_term(field974)
             self.newline()
-            field962 = unwrapped_fields960[1]
-            self.pretty_term(field962)
+            field975 = unwrapped_fields973[1]
+            self.pretty_term(field975)
             self.newline()
-            field963 = unwrapped_fields960[2]
-            self.pretty_term(field963)
+            field976 = unwrapped_fields973[2]
+            self.pretty_term(field976)
             self.dedent()
             self.write(")")
 
     def pretty_divide(self, msg: logic_pb2.Primitive):
-        flat970 = self._try_flat(msg, self.pretty_divide)
-        if flat970 is not None:
-            assert flat970 is not None
-            self.write(flat970)
+        flat983 = self._try_flat(msg, self.pretty_divide)
+        if flat983 is not None:
+            assert flat983 is not None
+            self.write(flat983)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name == "rel_primitive_divide_monotype":
-                _t1332 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
+                _t1358 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,)
             else:
-                _t1332 = None
-            fields965 = _t1332
-            assert fields965 is not None
-            unwrapped_fields966 = fields965
+                _t1358 = None
+            fields978 = _t1358
+            assert fields978 is not None
+            unwrapped_fields979 = fields978
             self.write("(/")
             self.indent_sexp()
             self.newline()
-            field967 = unwrapped_fields966[0]
-            self.pretty_term(field967)
+            field980 = unwrapped_fields979[0]
+            self.pretty_term(field980)
             self.newline()
-            field968 = unwrapped_fields966[1]
-            self.pretty_term(field968)
+            field981 = unwrapped_fields979[1]
+            self.pretty_term(field981)
             self.newline()
-            field969 = unwrapped_fields966[2]
-            self.pretty_term(field969)
+            field982 = unwrapped_fields979[2]
+            self.pretty_term(field982)
             self.dedent()
             self.write(")")
 
     def pretty_rel_term(self, msg: logic_pb2.RelTerm):
-        flat975 = self._try_flat(msg, self.pretty_rel_term)
-        if flat975 is not None:
-            assert flat975 is not None
-            self.write(flat975)
+        flat988 = self._try_flat(msg, self.pretty_rel_term)
+        if flat988 is not None:
+            assert flat988 is not None
+            self.write(flat988)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("specialized_value"):
-                _t1333 = _dollar_dollar.specialized_value
+                _t1359 = _dollar_dollar.specialized_value
             else:
-                _t1333 = None
-            deconstruct_result973 = _t1333
-            if deconstruct_result973 is not None:
-                assert deconstruct_result973 is not None
-                unwrapped974 = deconstruct_result973
-                self.pretty_specialized_value(unwrapped974)
+                _t1359 = None
+            deconstruct_result986 = _t1359
+            if deconstruct_result986 is not None:
+                assert deconstruct_result986 is not None
+                unwrapped987 = deconstruct_result986
+                self.pretty_specialized_value(unwrapped987)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("term"):
-                    _t1334 = _dollar_dollar.term
+                    _t1360 = _dollar_dollar.term
                 else:
-                    _t1334 = None
-                deconstruct_result971 = _t1334
-                if deconstruct_result971 is not None:
-                    assert deconstruct_result971 is not None
-                    unwrapped972 = deconstruct_result971
-                    self.pretty_term(unwrapped972)
+                    _t1360 = None
+                deconstruct_result984 = _t1360
+                if deconstruct_result984 is not None:
+                    assert deconstruct_result984 is not None
+                    unwrapped985 = deconstruct_result984
+                    self.pretty_term(unwrapped985)
                 else:
                     raise ParseError("No matching rule for rel_term")
 
     def pretty_specialized_value(self, msg: logic_pb2.Value):
-        flat977 = self._try_flat(msg, self.pretty_specialized_value)
-        if flat977 is not None:
-            assert flat977 is not None
-            self.write(flat977)
+        flat990 = self._try_flat(msg, self.pretty_specialized_value)
+        if flat990 is not None:
+            assert flat990 is not None
+            self.write(flat990)
             return None
         else:
-            fields976 = msg
+            fields989 = msg
             self.write("#")
-            self.pretty_value(fields976)
+            self.pretty_value(fields989)
 
     def pretty_rel_atom(self, msg: logic_pb2.RelAtom):
-        flat984 = self._try_flat(msg, self.pretty_rel_atom)
-        if flat984 is not None:
-            assert flat984 is not None
-            self.write(flat984)
+        flat997 = self._try_flat(msg, self.pretty_rel_atom)
+        if flat997 is not None:
+            assert flat997 is not None
+            self.write(flat997)
             return None
         else:
             _dollar_dollar = msg
-            fields978 = (_dollar_dollar.name, _dollar_dollar.terms,)
-            assert fields978 is not None
-            unwrapped_fields979 = fields978
+            fields991 = (_dollar_dollar.name, _dollar_dollar.terms,)
+            assert fields991 is not None
+            unwrapped_fields992 = fields991
             self.write("(relatom")
             self.indent_sexp()
             self.newline()
-            field980 = unwrapped_fields979[0]
-            self.pretty_name(field980)
-            field981 = unwrapped_fields979[1]
-            if not len(field981) == 0:
+            field993 = unwrapped_fields992[0]
+            self.pretty_name(field993)
+            field994 = unwrapped_fields992[1]
+            if not len(field994) == 0:
                 self.newline()
-                for i983, elem982 in enumerate(field981):
-                    if (i983 > 0):
+                for i996, elem995 in enumerate(field994):
+                    if (i996 > 0):
                         self.newline()
-                    self.pretty_rel_term(elem982)
+                    self.pretty_rel_term(elem995)
             self.dedent()
             self.write(")")
 
     def pretty_cast(self, msg: logic_pb2.Cast):
-        flat989 = self._try_flat(msg, self.pretty_cast)
-        if flat989 is not None:
-            assert flat989 is not None
-            self.write(flat989)
+        flat1002 = self._try_flat(msg, self.pretty_cast)
+        if flat1002 is not None:
+            assert flat1002 is not None
+            self.write(flat1002)
             return None
         else:
             _dollar_dollar = msg
-            fields985 = (_dollar_dollar.input, _dollar_dollar.result,)
-            assert fields985 is not None
-            unwrapped_fields986 = fields985
+            fields998 = (_dollar_dollar.input, _dollar_dollar.result,)
+            assert fields998 is not None
+            unwrapped_fields999 = fields998
             self.write("(cast")
             self.indent_sexp()
             self.newline()
-            field987 = unwrapped_fields986[0]
-            self.pretty_term(field987)
+            field1000 = unwrapped_fields999[0]
+            self.pretty_term(field1000)
             self.newline()
-            field988 = unwrapped_fields986[1]
-            self.pretty_term(field988)
+            field1001 = unwrapped_fields999[1]
+            self.pretty_term(field1001)
             self.dedent()
             self.write(")")
 
     def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]):
-        flat993 = self._try_flat(msg, self.pretty_attrs)
-        if flat993 is not None:
-            assert flat993 is not None
-            self.write(flat993)
+        flat1006 = self._try_flat(msg, self.pretty_attrs)
+        if flat1006 is not None:
+            assert flat1006 is not None
+            self.write(flat1006)
             return None
         else:
-            fields990 = msg
+            fields1003 = msg
             self.write("(attrs")
             self.indent_sexp()
-            if not len(fields990) == 0:
+            if not len(fields1003) == 0:
                 self.newline()
-                for i992, elem991 in enumerate(fields990):
-                    if (i992 > 0):
+                for i1005, elem1004 in enumerate(fields1003):
+                    if (i1005 > 0):
                         self.newline()
-                    self.pretty_attribute(elem991)
+                    self.pretty_attribute(elem1004)
             self.dedent()
             self.write(")")
 
     def pretty_attribute(self, msg: logic_pb2.Attribute):
-        flat1000 = self._try_flat(msg, self.pretty_attribute)
-        if flat1000 is not None:
-            assert flat1000 is not None
-            self.write(flat1000)
+        flat1013 = self._try_flat(msg, self.pretty_attribute)
+        if flat1013 is not None:
+            assert flat1013 is not None
+            self.write(flat1013)
             return None
         else:
             _dollar_dollar = msg
-            fields994 = (_dollar_dollar.name, _dollar_dollar.args,)
-            assert fields994 is not None
-            unwrapped_fields995 = fields994
+            fields1007 = (_dollar_dollar.name, _dollar_dollar.args,)
+            assert fields1007 is not None
+            unwrapped_fields1008 = fields1007
             self.write("(attribute")
             self.indent_sexp()
             self.newline()
-            field996 = unwrapped_fields995[0]
-            self.pretty_name(field996)
-            field997 = unwrapped_fields995[1]
-            if not len(field997) == 0:
+            field1009 = unwrapped_fields1008[0]
+            self.pretty_name(field1009)
+            field1010 = unwrapped_fields1008[1]
+            if not len(field1010) == 0:
                 self.newline()
-                for i999, elem998 in enumerate(field997):
-                    if (i999 > 0):
+                for i1012, elem1011 in enumerate(field1010):
+                    if (i1012 > 0):
                         self.newline()
-                    self.pretty_value(elem998)
+                    self.pretty_value(elem1011)
             self.dedent()
             self.write(")")
 
     def pretty_algorithm(self, msg: logic_pb2.Algorithm):
-        flat1007 = self._try_flat(msg, self.pretty_algorithm)
-        if flat1007 is not None:
-            assert flat1007 is not None
-            self.write(flat1007)
+        flat1020 = self._try_flat(msg, self.pretty_algorithm)
+        if flat1020 is not None:
+            assert flat1020 is not None
+            self.write(flat1020)
             return None
         else:
             _dollar_dollar = msg
-            fields1001 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,)
-            assert fields1001 is not None
-            unwrapped_fields1002 = fields1001
+            fields1014 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body,)
+            assert fields1014 is not None
+            unwrapped_fields1015 = fields1014
             self.write("(algorithm")
             self.indent_sexp()
-            field1003 = unwrapped_fields1002[0]
-            if not len(field1003) == 0:
+            field1016 = unwrapped_fields1015[0]
+            if not len(field1016) == 0:
                 self.newline()
-                for i1005, elem1004 in enumerate(field1003):
-                    if (i1005 > 0):
+                for i1018, elem1017 in enumerate(field1016):
+                    if (i1018 > 0):
                         self.newline()
-                    self.pretty_relation_id(elem1004)
+                    self.pretty_relation_id(elem1017)
             self.newline()
-            field1006 = unwrapped_fields1002[1]
-            self.pretty_script(field1006)
+            field1019 = unwrapped_fields1015[1]
+            self.pretty_script(field1019)
             self.dedent()
             self.write(")")
 
     def pretty_script(self, msg: logic_pb2.Script):
-        flat1012 = self._try_flat(msg, self.pretty_script)
-        if flat1012 is not None:
-            assert flat1012 is not None
-            self.write(flat1012)
+        flat1025 = self._try_flat(msg, self.pretty_script)
+        if flat1025 is not None:
+            assert flat1025 is not None
+            self.write(flat1025)
             return None
         else:
             _dollar_dollar = msg
-            fields1008 = _dollar_dollar.constructs
-            assert fields1008 is not None
-            unwrapped_fields1009 = fields1008
+            fields1021 = _dollar_dollar.constructs
+            assert fields1021 is not None
+            unwrapped_fields1022 = fields1021
             self.write("(script")
             self.indent_sexp()
-            if not len(unwrapped_fields1009) == 0:
+            if not len(unwrapped_fields1022) == 0:
                 self.newline()
-                for i1011, elem1010 in enumerate(unwrapped_fields1009):
-                    if (i1011 > 0):
+                for i1024, elem1023 in enumerate(unwrapped_fields1022):
+                    if (i1024 > 0):
                         self.newline()
-                    self.pretty_construct(elem1010)
+                    self.pretty_construct(elem1023)
             self.dedent()
             self.write(")")
 
     def pretty_construct(self, msg: logic_pb2.Construct):
-        flat1017 = self._try_flat(msg, self.pretty_construct)
-        if flat1017 is not None:
-            assert flat1017 is not None
-            self.write(flat1017)
+        flat1030 = self._try_flat(msg, self.pretty_construct)
+        if flat1030 is not None:
+            assert flat1030 is not None
+            self.write(flat1030)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("loop"):
-                _t1335 = _dollar_dollar.loop
+                _t1361 = _dollar_dollar.loop
             else:
-                _t1335 = None
-            deconstruct_result1015 = _t1335
-            if deconstruct_result1015 is not None:
-                assert deconstruct_result1015 is not None
-                unwrapped1016 = deconstruct_result1015
-                self.pretty_loop(unwrapped1016)
+                _t1361 = None
+            deconstruct_result1028 = _t1361
+            if deconstruct_result1028 is not None:
+                assert deconstruct_result1028 is not None
+                unwrapped1029 = deconstruct_result1028
+                self.pretty_loop(unwrapped1029)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("instruction"):
-                    _t1336 = _dollar_dollar.instruction
+                    _t1362 = _dollar_dollar.instruction
                 else:
-                    _t1336 = None
-                deconstruct_result1013 = _t1336
-                if deconstruct_result1013 is not None:
-                    assert deconstruct_result1013 is not None
-                    unwrapped1014 = deconstruct_result1013
-                    self.pretty_instruction(unwrapped1014)
+                    _t1362 = None
+                deconstruct_result1026 = _t1362
+                if deconstruct_result1026 is not None:
+                    assert deconstruct_result1026 is not None
+                    unwrapped1027 = deconstruct_result1026
+                    self.pretty_instruction(unwrapped1027)
                 else:
                     raise ParseError("No matching rule for construct")
 
     def pretty_loop(self, msg: logic_pb2.Loop):
-        flat1022 = self._try_flat(msg, self.pretty_loop)
-        if flat1022 is not None:
-            assert flat1022 is not None
-            self.write(flat1022)
+        flat1035 = self._try_flat(msg, self.pretty_loop)
+        if flat1035 is not None:
+            assert flat1035 is not None
+            self.write(flat1035)
             return None
         else:
             _dollar_dollar = msg
-            fields1018 = (_dollar_dollar.init, _dollar_dollar.body,)
-            assert fields1018 is not None
-            unwrapped_fields1019 = fields1018
+            fields1031 = (_dollar_dollar.init, _dollar_dollar.body,)
+            assert fields1031 is not None
+            unwrapped_fields1032 = fields1031
             self.write("(loop")
             self.indent_sexp()
             self.newline()
-            field1020 = unwrapped_fields1019[0]
-            self.pretty_init(field1020)
+            field1033 = unwrapped_fields1032[0]
+            self.pretty_init(field1033)
             self.newline()
-            field1021 = unwrapped_fields1019[1]
-            self.pretty_script(field1021)
+            field1034 = unwrapped_fields1032[1]
+            self.pretty_script(field1034)
             self.dedent()
             self.write(")")
 
     def pretty_init(self, msg: Sequence[logic_pb2.Instruction]):
-        flat1026 = self._try_flat(msg, self.pretty_init)
-        if flat1026 is not None:
-            assert flat1026 is not None
-            self.write(flat1026)
+        flat1039 = self._try_flat(msg, self.pretty_init)
+        if flat1039 is not None:
+            assert flat1039 is not None
+            self.write(flat1039)
             return None
         else:
-            fields1023 = msg
+            fields1036 = msg
             self.write("(init")
             self.indent_sexp()
-            if not len(fields1023) == 0:
+            if not len(fields1036) == 0:
                 self.newline()
-                for i1025, elem1024 in enumerate(fields1023):
-                    if (i1025 > 0):
+                for i1038, elem1037 in enumerate(fields1036):
+                    if (i1038 > 0):
                         self.newline()
-                    self.pretty_instruction(elem1024)
+                    self.pretty_instruction(elem1037)
             self.dedent()
             self.write(")")
 
     def pretty_instruction(self, msg: logic_pb2.Instruction):
-        flat1037 = self._try_flat(msg, self.pretty_instruction)
-        if flat1037 is not None:
-            assert flat1037 is not None
-            self.write(flat1037)
+        flat1050 = self._try_flat(msg, self.pretty_instruction)
+        if flat1050 is not None:
+            assert flat1050 is not None
+            self.write(flat1050)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("assign"):
-                _t1337 = _dollar_dollar.assign
+                _t1363 = _dollar_dollar.assign
             else:
-                _t1337 = None
-            deconstruct_result1035 = _t1337
-            if deconstruct_result1035 is not None:
-                assert deconstruct_result1035 is not None
-                unwrapped1036 = deconstruct_result1035
-                self.pretty_assign(unwrapped1036)
+                _t1363 = None
+            deconstruct_result1048 = _t1363
+            if deconstruct_result1048 is not None:
+                assert deconstruct_result1048 is not None
+                unwrapped1049 = deconstruct_result1048
+                self.pretty_assign(unwrapped1049)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("upsert"):
-                    _t1338 = _dollar_dollar.upsert
+                    _t1364 = _dollar_dollar.upsert
                 else:
-                    _t1338 = None
-                deconstruct_result1033 = _t1338
-                if deconstruct_result1033 is not None:
-                    assert deconstruct_result1033 is not None
-                    unwrapped1034 = deconstruct_result1033
-                    self.pretty_upsert(unwrapped1034)
+                    _t1364 = None
+                deconstruct_result1046 = _t1364
+                if deconstruct_result1046 is not None:
+                    assert deconstruct_result1046 is not None
+                    unwrapped1047 = deconstruct_result1046
+                    self.pretty_upsert(unwrapped1047)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("break"):
-                        _t1339 = getattr(_dollar_dollar, 'break')
+                        _t1365 = getattr(_dollar_dollar, 'break')
                     else:
-                        _t1339 = None
-                    deconstruct_result1031 = _t1339
-                    if deconstruct_result1031 is not None:
-                        assert deconstruct_result1031 is not None
-                        unwrapped1032 = deconstruct_result1031
-                        self.pretty_break(unwrapped1032)
+                        _t1365 = None
+                    deconstruct_result1044 = _t1365
+                    if deconstruct_result1044 is not None:
+                        assert deconstruct_result1044 is not None
+                        unwrapped1045 = deconstruct_result1044
+                        self.pretty_break(unwrapped1045)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("monoid_def"):
-                            _t1340 = _dollar_dollar.monoid_def
+                            _t1366 = _dollar_dollar.monoid_def
                         else:
-                            _t1340 = None
-                        deconstruct_result1029 = _t1340
-                        if deconstruct_result1029 is not None:
-                            assert deconstruct_result1029 is not None
-                            unwrapped1030 = deconstruct_result1029
-                            self.pretty_monoid_def(unwrapped1030)
+                            _t1366 = None
+                        deconstruct_result1042 = _t1366
+                        if deconstruct_result1042 is not None:
+                            assert deconstruct_result1042 is not None
+                            unwrapped1043 = deconstruct_result1042
+                            self.pretty_monoid_def(unwrapped1043)
                         else:
                             _dollar_dollar = msg
                             if _dollar_dollar.HasField("monus_def"):
-                                _t1341 = _dollar_dollar.monus_def
+                                _t1367 = _dollar_dollar.monus_def
                             else:
-                                _t1341 = None
-                            deconstruct_result1027 = _t1341
-                            if deconstruct_result1027 is not None:
-                                assert deconstruct_result1027 is not None
-                                unwrapped1028 = deconstruct_result1027
-                                self.pretty_monus_def(unwrapped1028)
+                                _t1367 = None
+                            deconstruct_result1040 = _t1367
+                            if deconstruct_result1040 is not None:
+                                assert deconstruct_result1040 is not None
+                                unwrapped1041 = deconstruct_result1040
+                                self.pretty_monus_def(unwrapped1041)
                             else:
                                 raise ParseError("No matching rule for instruction")
 
     def pretty_assign(self, msg: logic_pb2.Assign):
-        flat1044 = self._try_flat(msg, self.pretty_assign)
-        if flat1044 is not None:
-            assert flat1044 is not None
-            self.write(flat1044)
+        flat1057 = self._try_flat(msg, self.pretty_assign)
+        if flat1057 is not None:
+            assert flat1057 is not None
+            self.write(flat1057)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1342 = _dollar_dollar.attrs
+                _t1368 = _dollar_dollar.attrs
             else:
-                _t1342 = None
-            fields1038 = (_dollar_dollar.name, _dollar_dollar.body, _t1342,)
-            assert fields1038 is not None
-            unwrapped_fields1039 = fields1038
+                _t1368 = None
+            fields1051 = (_dollar_dollar.name, _dollar_dollar.body, _t1368,)
+            assert fields1051 is not None
+            unwrapped_fields1052 = fields1051
             self.write("(assign")
             self.indent_sexp()
             self.newline()
-            field1040 = unwrapped_fields1039[0]
-            self.pretty_relation_id(field1040)
+            field1053 = unwrapped_fields1052[0]
+            self.pretty_relation_id(field1053)
             self.newline()
-            field1041 = unwrapped_fields1039[1]
-            self.pretty_abstraction(field1041)
-            field1042 = unwrapped_fields1039[2]
-            if field1042 is not None:
+            field1054 = unwrapped_fields1052[1]
+            self.pretty_abstraction(field1054)
+            field1055 = unwrapped_fields1052[2]
+            if field1055 is not None:
                 self.newline()
-                assert field1042 is not None
-                opt_val1043 = field1042
-                self.pretty_attrs(opt_val1043)
+                assert field1055 is not None
+                opt_val1056 = field1055
+                self.pretty_attrs(opt_val1056)
             self.dedent()
             self.write(")")
 
     def pretty_upsert(self, msg: logic_pb2.Upsert):
-        flat1051 = self._try_flat(msg, self.pretty_upsert)
-        if flat1051 is not None:
-            assert flat1051 is not None
-            self.write(flat1051)
+        flat1064 = self._try_flat(msg, self.pretty_upsert)
+        if flat1064 is not None:
+            assert flat1064 is not None
+            self.write(flat1064)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1343 = _dollar_dollar.attrs
+                _t1369 = _dollar_dollar.attrs
             else:
-                _t1343 = None
-            fields1045 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1343,)
-            assert fields1045 is not None
-            unwrapped_fields1046 = fields1045
+                _t1369 = None
+            fields1058 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1369,)
+            assert fields1058 is not None
+            unwrapped_fields1059 = fields1058
             self.write("(upsert")
             self.indent_sexp()
             self.newline()
-            field1047 = unwrapped_fields1046[0]
-            self.pretty_relation_id(field1047)
+            field1060 = unwrapped_fields1059[0]
+            self.pretty_relation_id(field1060)
             self.newline()
-            field1048 = unwrapped_fields1046[1]
-            self.pretty_abstraction_with_arity(field1048)
-            field1049 = unwrapped_fields1046[2]
-            if field1049 is not None:
+            field1061 = unwrapped_fields1059[1]
+            self.pretty_abstraction_with_arity(field1061)
+            field1062 = unwrapped_fields1059[2]
+            if field1062 is not None:
                 self.newline()
-                assert field1049 is not None
-                opt_val1050 = field1049
-                self.pretty_attrs(opt_val1050)
+                assert field1062 is not None
+                opt_val1063 = field1062
+                self.pretty_attrs(opt_val1063)
             self.dedent()
             self.write(")")
 
     def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]):
-        flat1056 = self._try_flat(msg, self.pretty_abstraction_with_arity)
-        if flat1056 is not None:
-            assert flat1056 is not None
-            self.write(flat1056)
+        flat1069 = self._try_flat(msg, self.pretty_abstraction_with_arity)
+        if flat1069 is not None:
+            assert flat1069 is not None
+            self.write(flat1069)
             return None
         else:
             _dollar_dollar = msg
-            _t1344 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1])
-            fields1052 = (_t1344, _dollar_dollar[0].value,)
-            assert fields1052 is not None
-            unwrapped_fields1053 = fields1052
+            _t1370 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1])
+            fields1065 = (_t1370, _dollar_dollar[0].value,)
+            assert fields1065 is not None
+            unwrapped_fields1066 = fields1065
             self.write("(")
             self.indent()
-            field1054 = unwrapped_fields1053[0]
-            self.pretty_bindings(field1054)
+            field1067 = unwrapped_fields1066[0]
+            self.pretty_bindings(field1067)
             self.newline()
-            field1055 = unwrapped_fields1053[1]
-            self.pretty_formula(field1055)
+            field1068 = unwrapped_fields1066[1]
+            self.pretty_formula(field1068)
             self.dedent()
             self.write(")")
 
     def pretty_break(self, msg: logic_pb2.Break):
-        flat1063 = self._try_flat(msg, self.pretty_break)
-        if flat1063 is not None:
-            assert flat1063 is not None
-            self.write(flat1063)
+        flat1076 = self._try_flat(msg, self.pretty_break)
+        if flat1076 is not None:
+            assert flat1076 is not None
+            self.write(flat1076)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1345 = _dollar_dollar.attrs
+                _t1371 = _dollar_dollar.attrs
             else:
-                _t1345 = None
-            fields1057 = (_dollar_dollar.name, _dollar_dollar.body, _t1345,)
-            assert fields1057 is not None
-            unwrapped_fields1058 = fields1057
+                _t1371 = None
+            fields1070 = (_dollar_dollar.name, _dollar_dollar.body, _t1371,)
+            assert fields1070 is not None
+            unwrapped_fields1071 = fields1070
             self.write("(break")
             self.indent_sexp()
             self.newline()
-            field1059 = unwrapped_fields1058[0]
-            self.pretty_relation_id(field1059)
+            field1072 = unwrapped_fields1071[0]
+            self.pretty_relation_id(field1072)
             self.newline()
-            field1060 = unwrapped_fields1058[1]
-            self.pretty_abstraction(field1060)
-            field1061 = unwrapped_fields1058[2]
-            if field1061 is not None:
+            field1073 = unwrapped_fields1071[1]
+            self.pretty_abstraction(field1073)
+            field1074 = unwrapped_fields1071[2]
+            if field1074 is not None:
                 self.newline()
-                assert field1061 is not None
-                opt_val1062 = field1061
-                self.pretty_attrs(opt_val1062)
+                assert field1074 is not None
+                opt_val1075 = field1074
+                self.pretty_attrs(opt_val1075)
             self.dedent()
             self.write(")")
 
     def pretty_monoid_def(self, msg: logic_pb2.MonoidDef):
-        flat1071 = self._try_flat(msg, self.pretty_monoid_def)
-        if flat1071 is not None:
-            assert flat1071 is not None
-            self.write(flat1071)
+        flat1084 = self._try_flat(msg, self.pretty_monoid_def)
+        if flat1084 is not None:
+            assert flat1084 is not None
+            self.write(flat1084)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1346 = _dollar_dollar.attrs
+                _t1372 = _dollar_dollar.attrs
             else:
-                _t1346 = None
-            fields1064 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1346,)
-            assert fields1064 is not None
-            unwrapped_fields1065 = fields1064
+                _t1372 = None
+            fields1077 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1372,)
+            assert fields1077 is not None
+            unwrapped_fields1078 = fields1077
             self.write("(monoid")
             self.indent_sexp()
             self.newline()
-            field1066 = unwrapped_fields1065[0]
-            self.pretty_monoid(field1066)
+            field1079 = unwrapped_fields1078[0]
+            self.pretty_monoid(field1079)
             self.newline()
-            field1067 = unwrapped_fields1065[1]
-            self.pretty_relation_id(field1067)
+            field1080 = unwrapped_fields1078[1]
+            self.pretty_relation_id(field1080)
             self.newline()
-            field1068 = unwrapped_fields1065[2]
-            self.pretty_abstraction_with_arity(field1068)
-            field1069 = unwrapped_fields1065[3]
-            if field1069 is not None:
+            field1081 = unwrapped_fields1078[2]
+            self.pretty_abstraction_with_arity(field1081)
+            field1082 = unwrapped_fields1078[3]
+            if field1082 is not None:
                 self.newline()
-                assert field1069 is not None
-                opt_val1070 = field1069
-                self.pretty_attrs(opt_val1070)
+                assert field1082 is not None
+                opt_val1083 = field1082
+                self.pretty_attrs(opt_val1083)
             self.dedent()
             self.write(")")
 
     def pretty_monoid(self, msg: logic_pb2.Monoid):
-        flat1080 = self._try_flat(msg, self.pretty_monoid)
-        if flat1080 is not None:
-            assert flat1080 is not None
-            self.write(flat1080)
+        flat1093 = self._try_flat(msg, self.pretty_monoid)
+        if flat1093 is not None:
+            assert flat1093 is not None
+            self.write(flat1093)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("or_monoid"):
-                _t1347 = _dollar_dollar.or_monoid
+                _t1373 = _dollar_dollar.or_monoid
             else:
-                _t1347 = None
-            deconstruct_result1078 = _t1347
-            if deconstruct_result1078 is not None:
-                assert deconstruct_result1078 is not None
-                unwrapped1079 = deconstruct_result1078
-                self.pretty_or_monoid(unwrapped1079)
+                _t1373 = None
+            deconstruct_result1091 = _t1373
+            if deconstruct_result1091 is not None:
+                assert deconstruct_result1091 is not None
+                unwrapped1092 = deconstruct_result1091
+                self.pretty_or_monoid(unwrapped1092)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("min_monoid"):
-                    _t1348 = _dollar_dollar.min_monoid
+                    _t1374 = _dollar_dollar.min_monoid
                 else:
-                    _t1348 = None
-                deconstruct_result1076 = _t1348
-                if deconstruct_result1076 is not None:
-                    assert deconstruct_result1076 is not None
-                    unwrapped1077 = deconstruct_result1076
-                    self.pretty_min_monoid(unwrapped1077)
+                    _t1374 = None
+                deconstruct_result1089 = _t1374
+                if deconstruct_result1089 is not None:
+                    assert deconstruct_result1089 is not None
+                    unwrapped1090 = deconstruct_result1089
+                    self.pretty_min_monoid(unwrapped1090)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("max_monoid"):
-                        _t1349 = _dollar_dollar.max_monoid
+                        _t1375 = _dollar_dollar.max_monoid
                     else:
-                        _t1349 = None
-                    deconstruct_result1074 = _t1349
-                    if deconstruct_result1074 is not None:
-                        assert deconstruct_result1074 is not None
-                        unwrapped1075 = deconstruct_result1074
-                        self.pretty_max_monoid(unwrapped1075)
+                        _t1375 = None
+                    deconstruct_result1087 = _t1375
+                    if deconstruct_result1087 is not None:
+                        assert deconstruct_result1087 is not None
+                        unwrapped1088 = deconstruct_result1087
+                        self.pretty_max_monoid(unwrapped1088)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("sum_monoid"):
-                            _t1350 = _dollar_dollar.sum_monoid
+                            _t1376 = _dollar_dollar.sum_monoid
                         else:
-                            _t1350 = None
-                        deconstruct_result1072 = _t1350
-                        if deconstruct_result1072 is not None:
-                            assert deconstruct_result1072 is not None
-                            unwrapped1073 = deconstruct_result1072
-                            self.pretty_sum_monoid(unwrapped1073)
+                            _t1376 = None
+                        deconstruct_result1085 = _t1376
+                        if deconstruct_result1085 is not None:
+                            assert deconstruct_result1085 is not None
+                            unwrapped1086 = deconstruct_result1085
+                            self.pretty_sum_monoid(unwrapped1086)
                         else:
                             raise ParseError("No matching rule for monoid")
 
     def pretty_or_monoid(self, msg: logic_pb2.OrMonoid):
-        fields1081 = msg
+        fields1094 = msg
         self.write("(or)")
 
     def pretty_min_monoid(self, msg: logic_pb2.MinMonoid):
-        flat1084 = self._try_flat(msg, self.pretty_min_monoid)
-        if flat1084 is not None:
-            assert flat1084 is not None
-            self.write(flat1084)
+        flat1097 = self._try_flat(msg, self.pretty_min_monoid)
+        if flat1097 is not None:
+            assert flat1097 is not None
+            self.write(flat1097)
             return None
         else:
             _dollar_dollar = msg
-            fields1082 = _dollar_dollar.type
-            assert fields1082 is not None
-            unwrapped_fields1083 = fields1082
+            fields1095 = _dollar_dollar.type
+            assert fields1095 is not None
+            unwrapped_fields1096 = fields1095
             self.write("(min")
             self.indent_sexp()
             self.newline()
-            self.pretty_type(unwrapped_fields1083)
+            self.pretty_type(unwrapped_fields1096)
             self.dedent()
             self.write(")")
 
     def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid):
-        flat1087 = self._try_flat(msg, self.pretty_max_monoid)
-        if flat1087 is not None:
-            assert flat1087 is not None
-            self.write(flat1087)
+        flat1100 = self._try_flat(msg, self.pretty_max_monoid)
+        if flat1100 is not None:
+            assert flat1100 is not None
+            self.write(flat1100)
             return None
         else:
             _dollar_dollar = msg
-            fields1085 = _dollar_dollar.type
-            assert fields1085 is not None
-            unwrapped_fields1086 = fields1085
+            fields1098 = _dollar_dollar.type
+            assert fields1098 is not None
+            unwrapped_fields1099 = fields1098
             self.write("(max")
             self.indent_sexp()
             self.newline()
-            self.pretty_type(unwrapped_fields1086)
+            self.pretty_type(unwrapped_fields1099)
             self.dedent()
             self.write(")")
 
     def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid):
-        flat1090 = self._try_flat(msg, self.pretty_sum_monoid)
-        if flat1090 is not None:
-            assert flat1090 is not None
-            self.write(flat1090)
+        flat1103 = self._try_flat(msg, self.pretty_sum_monoid)
+        if flat1103 is not None:
+            assert flat1103 is not None
+            self.write(flat1103)
             return None
         else:
             _dollar_dollar = msg
-            fields1088 = _dollar_dollar.type
-            assert fields1088 is not None
-            unwrapped_fields1089 = fields1088
+            fields1101 = _dollar_dollar.type
+            assert fields1101 is not None
+            unwrapped_fields1102 = fields1101
             self.write("(sum")
             self.indent_sexp()
             self.newline()
-            self.pretty_type(unwrapped_fields1089)
+            self.pretty_type(unwrapped_fields1102)
             self.dedent()
             self.write(")")
 
     def pretty_monus_def(self, msg: logic_pb2.MonusDef):
-        flat1098 = self._try_flat(msg, self.pretty_monus_def)
-        if flat1098 is not None:
-            assert flat1098 is not None
-            self.write(flat1098)
+        flat1111 = self._try_flat(msg, self.pretty_monus_def)
+        if flat1111 is not None:
+            assert flat1111 is not None
+            self.write(flat1111)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.attrs) == 0:
-                _t1351 = _dollar_dollar.attrs
+                _t1377 = _dollar_dollar.attrs
             else:
-                _t1351 = None
-            fields1091 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1351,)
-            assert fields1091 is not None
-            unwrapped_fields1092 = fields1091
+                _t1377 = None
+            fields1104 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1377,)
+            assert fields1104 is not None
+            unwrapped_fields1105 = fields1104
             self.write("(monus")
             self.indent_sexp()
             self.newline()
-            field1093 = unwrapped_fields1092[0]
-            self.pretty_monoid(field1093)
+            field1106 = unwrapped_fields1105[0]
+            self.pretty_monoid(field1106)
             self.newline()
-            field1094 = unwrapped_fields1092[1]
-            self.pretty_relation_id(field1094)
+            field1107 = unwrapped_fields1105[1]
+            self.pretty_relation_id(field1107)
             self.newline()
-            field1095 = unwrapped_fields1092[2]
-            self.pretty_abstraction_with_arity(field1095)
-            field1096 = unwrapped_fields1092[3]
-            if field1096 is not None:
+            field1108 = unwrapped_fields1105[2]
+            self.pretty_abstraction_with_arity(field1108)
+            field1109 = unwrapped_fields1105[3]
+            if field1109 is not None:
                 self.newline()
-                assert field1096 is not None
-                opt_val1097 = field1096
-                self.pretty_attrs(opt_val1097)
+                assert field1109 is not None
+                opt_val1110 = field1109
+                self.pretty_attrs(opt_val1110)
             self.dedent()
             self.write(")")
 
     def pretty_constraint(self, msg: logic_pb2.Constraint):
-        flat1105 = self._try_flat(msg, self.pretty_constraint)
-        if flat1105 is not None:
-            assert flat1105 is not None
-            self.write(flat1105)
+        flat1118 = self._try_flat(msg, self.pretty_constraint)
+        if flat1118 is not None:
+            assert flat1118 is not None
+            self.write(flat1118)
             return None
         else:
             _dollar_dollar = msg
-            fields1099 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,)
-            assert fields1099 is not None
-            unwrapped_fields1100 = fields1099
+            fields1112 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,)
+            assert fields1112 is not None
+            unwrapped_fields1113 = fields1112
             self.write("(functional_dependency")
             self.indent_sexp()
             self.newline()
-            field1101 = unwrapped_fields1100[0]
-            self.pretty_relation_id(field1101)
+            field1114 = unwrapped_fields1113[0]
+            self.pretty_relation_id(field1114)
             self.newline()
-            field1102 = unwrapped_fields1100[1]
-            self.pretty_abstraction(field1102)
+            field1115 = unwrapped_fields1113[1]
+            self.pretty_abstraction(field1115)
             self.newline()
-            field1103 = unwrapped_fields1100[2]
-            self.pretty_functional_dependency_keys(field1103)
+            field1116 = unwrapped_fields1113[2]
+            self.pretty_functional_dependency_keys(field1116)
             self.newline()
-            field1104 = unwrapped_fields1100[3]
-            self.pretty_functional_dependency_values(field1104)
+            field1117 = unwrapped_fields1113[3]
+            self.pretty_functional_dependency_values(field1117)
             self.dedent()
             self.write(")")
 
     def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]):
-        flat1109 = self._try_flat(msg, self.pretty_functional_dependency_keys)
-        if flat1109 is not None:
-            assert flat1109 is not None
-            self.write(flat1109)
+        flat1122 = self._try_flat(msg, self.pretty_functional_dependency_keys)
+        if flat1122 is not None:
+            assert flat1122 is not None
+            self.write(flat1122)
             return None
         else:
-            fields1106 = msg
+            fields1119 = msg
             self.write("(keys")
             self.indent_sexp()
-            if not len(fields1106) == 0:
+            if not len(fields1119) == 0:
                 self.newline()
-                for i1108, elem1107 in enumerate(fields1106):
-                    if (i1108 > 0):
+                for i1121, elem1120 in enumerate(fields1119):
+                    if (i1121 > 0):
                         self.newline()
-                    self.pretty_var(elem1107)
+                    self.pretty_var(elem1120)
             self.dedent()
             self.write(")")
 
     def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]):
-        flat1113 = self._try_flat(msg, self.pretty_functional_dependency_values)
-        if flat1113 is not None:
-            assert flat1113 is not None
-            self.write(flat1113)
+        flat1126 = self._try_flat(msg, self.pretty_functional_dependency_values)
+        if flat1126 is not None:
+            assert flat1126 is not None
+            self.write(flat1126)
             return None
         else:
-            fields1110 = msg
+            fields1123 = msg
             self.write("(values")
             self.indent_sexp()
-            if not len(fields1110) == 0:
+            if not len(fields1123) == 0:
                 self.newline()
-                for i1112, elem1111 in enumerate(fields1110):
-                    if (i1112 > 0):
+                for i1125, elem1124 in enumerate(fields1123):
+                    if (i1125 > 0):
                         self.newline()
-                    self.pretty_var(elem1111)
+                    self.pretty_var(elem1124)
             self.dedent()
             self.write(")")
 
     def pretty_data(self, msg: logic_pb2.Data):
-        flat1120 = self._try_flat(msg, self.pretty_data)
-        if flat1120 is not None:
-            assert flat1120 is not None
-            self.write(flat1120)
+        flat1133 = self._try_flat(msg, self.pretty_data)
+        if flat1133 is not None:
+            assert flat1133 is not None
+            self.write(flat1133)
             return None
         else:
             _dollar_dollar = msg
-            if _dollar_dollar.HasField("rel_edb"):
-                _t1352 = _dollar_dollar.rel_edb
+            if _dollar_dollar.HasField("edb"):
+                _t1378 = _dollar_dollar.edb
             else:
-                _t1352 = None
-            deconstruct_result1118 = _t1352
-            if deconstruct_result1118 is not None:
-                assert deconstruct_result1118 is not None
-                unwrapped1119 = deconstruct_result1118
-                self.pretty_rel_edb(unwrapped1119)
+                _t1378 = None
+            deconstruct_result1131 = _t1378
+            if deconstruct_result1131 is not None:
+                assert deconstruct_result1131 is not None
+                unwrapped1132 = deconstruct_result1131
+                self.pretty_edb(unwrapped1132)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("betree_relation"):
-                    _t1353 = _dollar_dollar.betree_relation
+                    _t1379 = _dollar_dollar.betree_relation
                 else:
-                    _t1353 = None
-                deconstruct_result1116 = _t1353
-                if deconstruct_result1116 is not None:
-                    assert deconstruct_result1116 is not None
-                    unwrapped1117 = deconstruct_result1116
-                    self.pretty_betree_relation(unwrapped1117)
+                    _t1379 = None
+                deconstruct_result1129 = _t1379
+                if deconstruct_result1129 is not None:
+                    assert deconstruct_result1129 is not None
+                    unwrapped1130 = deconstruct_result1129
+                    self.pretty_betree_relation(unwrapped1130)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("csv_data"):
-                        _t1354 = _dollar_dollar.csv_data
+                        _t1380 = _dollar_dollar.csv_data
                     else:
-                        _t1354 = None
-                    deconstruct_result1114 = _t1354
-                    if deconstruct_result1114 is not None:
-                        assert deconstruct_result1114 is not None
-                        unwrapped1115 = deconstruct_result1114
-                        self.pretty_csv_data(unwrapped1115)
+                        _t1380 = None
+                    deconstruct_result1127 = _t1380
+                    if deconstruct_result1127 is not None:
+                        assert deconstruct_result1127 is not None
+                        unwrapped1128 = deconstruct_result1127
+                        self.pretty_csv_data(unwrapped1128)
                     else:
                         raise ParseError("No matching rule for data")
 
-    def pretty_rel_edb(self, msg: logic_pb2.RelEDB):
-        flat1126 = self._try_flat(msg, self.pretty_rel_edb)
-        if flat1126 is not None:
-            assert flat1126 is not None
-            self.write(flat1126)
+    def pretty_edb(self, msg: logic_pb2.EDB):
+        flat1139 = self._try_flat(msg, self.pretty_edb)
+        if flat1139 is not None:
+            assert flat1139 is not None
+            self.write(flat1139)
             return None
         else:
             _dollar_dollar = msg
-            fields1121 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,)
-            assert fields1121 is not None
-            unwrapped_fields1122 = fields1121
-            self.write("(rel_edb")
+            fields1134 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,)
+            assert fields1134 is not None
+            unwrapped_fields1135 = fields1134
+            self.write("(edb")
             self.indent_sexp()
             self.newline()
-            field1123 = unwrapped_fields1122[0]
-            self.pretty_relation_id(field1123)
+            field1136 = unwrapped_fields1135[0]
+            self.pretty_relation_id(field1136)
             self.newline()
-            field1124 = unwrapped_fields1122[1]
-            self.pretty_rel_edb_path(field1124)
+            field1137 = unwrapped_fields1135[1]
+            self.pretty_edb_path(field1137)
             self.newline()
-            field1125 = unwrapped_fields1122[2]
-            self.pretty_rel_edb_types(field1125)
+            field1138 = unwrapped_fields1135[2]
+            self.pretty_edb_types(field1138)
             self.dedent()
             self.write(")")
 
-    def pretty_rel_edb_path(self, msg: Sequence[str]):
-        flat1130 = self._try_flat(msg, self.pretty_rel_edb_path)
-        if flat1130 is not None:
-            assert flat1130 is not None
-            self.write(flat1130)
+    def pretty_edb_path(self, msg: Sequence[str]):
+        flat1143 = self._try_flat(msg, self.pretty_edb_path)
+        if flat1143 is not None:
+            assert flat1143 is not None
+            self.write(flat1143)
             return None
         else:
-            fields1127 = msg
+            fields1140 = msg
             self.write("[")
             self.indent()
-            for i1129, elem1128 in enumerate(fields1127):
-                if (i1129 > 0):
+            for i1142, elem1141 in enumerate(fields1140):
+                if (i1142 > 0):
                     self.newline()
-                self.write(self.format_string_value(elem1128))
+                self.write(self.format_string_value(elem1141))
             self.dedent()
             self.write("]")
 
-    def pretty_rel_edb_types(self, msg: Sequence[logic_pb2.Type]):
-        flat1134 = self._try_flat(msg, self.pretty_rel_edb_types)
-        if flat1134 is not None:
-            assert flat1134 is not None
-            self.write(flat1134)
+    def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]):
+        flat1147 = self._try_flat(msg, self.pretty_edb_types)
+        if flat1147 is not None:
+            assert flat1147 is not None
+            self.write(flat1147)
             return None
         else:
-            fields1131 = msg
+            fields1144 = msg
             self.write("[")
             self.indent()
-            for i1133, elem1132 in enumerate(fields1131):
-                if (i1133 > 0):
+            for i1146, elem1145 in enumerate(fields1144):
+                if (i1146 > 0):
                     self.newline()
-                self.pretty_type(elem1132)
+                self.pretty_type(elem1145)
             self.dedent()
             self.write("]")
 
     def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation):
-        flat1139 = self._try_flat(msg, self.pretty_betree_relation)
-        if flat1139 is not None:
-            assert flat1139 is not None
-            self.write(flat1139)
+        flat1152 = self._try_flat(msg, self.pretty_betree_relation)
+        if flat1152 is not None:
+            assert flat1152 is not None
+            self.write(flat1152)
             return None
         else:
             _dollar_dollar = msg
-            fields1135 = (_dollar_dollar.name, _dollar_dollar.relation_info,)
-            assert fields1135 is not None
-            unwrapped_fields1136 = fields1135
+            fields1148 = (_dollar_dollar.name, _dollar_dollar.relation_info,)
+            assert fields1148 is not None
+            unwrapped_fields1149 = fields1148
             self.write("(betree_relation")
             self.indent_sexp()
             self.newline()
-            field1137 = unwrapped_fields1136[0]
-            self.pretty_relation_id(field1137)
+            field1150 = unwrapped_fields1149[0]
+            self.pretty_relation_id(field1150)
             self.newline()
-            field1138 = unwrapped_fields1136[1]
-            self.pretty_betree_info(field1138)
+            field1151 = unwrapped_fields1149[1]
+            self.pretty_betree_info(field1151)
             self.dedent()
             self.write(")")
 
     def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo):
-        flat1145 = self._try_flat(msg, self.pretty_betree_info)
-        if flat1145 is not None:
-            assert flat1145 is not None
-            self.write(flat1145)
+        flat1158 = self._try_flat(msg, self.pretty_betree_info)
+        if flat1158 is not None:
+            assert flat1158 is not None
+            self.write(flat1158)
             return None
         else:
             _dollar_dollar = msg
-            _t1355 = self.deconstruct_betree_info_config(_dollar_dollar)
-            fields1140 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1355,)
-            assert fields1140 is not None
-            unwrapped_fields1141 = fields1140
+            _t1381 = self.deconstruct_betree_info_config(_dollar_dollar)
+            fields1153 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1381,)
+            assert fields1153 is not None
+            unwrapped_fields1154 = fields1153
             self.write("(betree_info")
             self.indent_sexp()
             self.newline()
-            field1142 = unwrapped_fields1141[0]
-            self.pretty_betree_info_key_types(field1142)
+            field1155 = unwrapped_fields1154[0]
+            self.pretty_betree_info_key_types(field1155)
             self.newline()
-            field1143 = unwrapped_fields1141[1]
-            self.pretty_betree_info_value_types(field1143)
+            field1156 = unwrapped_fields1154[1]
+            self.pretty_betree_info_value_types(field1156)
             self.newline()
-            field1144 = unwrapped_fields1141[2]
-            self.pretty_config_dict(field1144)
+            field1157 = unwrapped_fields1154[2]
+            self.pretty_config_dict(field1157)
             self.dedent()
             self.write(")")
 
     def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]):
-        flat1149 = self._try_flat(msg, self.pretty_betree_info_key_types)
-        if flat1149 is not None:
-            assert flat1149 is not None
-            self.write(flat1149)
+        flat1162 = self._try_flat(msg, self.pretty_betree_info_key_types)
+        if flat1162 is not None:
+            assert flat1162 is not None
+            self.write(flat1162)
             return None
         else:
-            fields1146 = msg
+            fields1159 = msg
             self.write("(key_types")
             self.indent_sexp()
-            if not len(fields1146) == 0:
+            if not len(fields1159) == 0:
                 self.newline()
-                for i1148, elem1147 in enumerate(fields1146):
-                    if (i1148 > 0):
+                for i1161, elem1160 in enumerate(fields1159):
+                    if (i1161 > 0):
                         self.newline()
-                    self.pretty_type(elem1147)
+                    self.pretty_type(elem1160)
             self.dedent()
             self.write(")")
 
     def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]):
-        flat1153 = self._try_flat(msg, self.pretty_betree_info_value_types)
-        if flat1153 is not None:
-            assert flat1153 is not None
-            self.write(flat1153)
+        flat1166 = self._try_flat(msg, self.pretty_betree_info_value_types)
+        if flat1166 is not None:
+            assert flat1166 is not None
+            self.write(flat1166)
             return None
         else:
-            fields1150 = msg
+            fields1163 = msg
             self.write("(value_types")
             self.indent_sexp()
-            if not len(fields1150) == 0:
+            if not len(fields1163) == 0:
                 self.newline()
-                for i1152, elem1151 in enumerate(fields1150):
-                    if (i1152 > 0):
+                for i1165, elem1164 in enumerate(fields1163):
+                    if (i1165 > 0):
                         self.newline()
-                    self.pretty_type(elem1151)
+                    self.pretty_type(elem1164)
             self.dedent()
             self.write(")")
 
     def pretty_csv_data(self, msg: logic_pb2.CSVData):
-        flat1160 = self._try_flat(msg, self.pretty_csv_data)
-        if flat1160 is not None:
-            assert flat1160 is not None
-            self.write(flat1160)
+        flat1173 = self._try_flat(msg, self.pretty_csv_data)
+        if flat1173 is not None:
+            assert flat1173 is not None
+            self.write(flat1173)
             return None
         else:
             _dollar_dollar = msg
-            fields1154 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,)
-            assert fields1154 is not None
-            unwrapped_fields1155 = fields1154
+            fields1167 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,)
+            assert fields1167 is not None
+            unwrapped_fields1168 = fields1167
             self.write("(csv_data")
             self.indent_sexp()
             self.newline()
-            field1156 = unwrapped_fields1155[0]
-            self.pretty_csvlocator(field1156)
+            field1169 = unwrapped_fields1168[0]
+            self.pretty_csvlocator(field1169)
             self.newline()
-            field1157 = unwrapped_fields1155[1]
-            self.pretty_csv_config(field1157)
+            field1170 = unwrapped_fields1168[1]
+            self.pretty_csv_config(field1170)
             self.newline()
-            field1158 = unwrapped_fields1155[2]
-            self.pretty_csv_columns(field1158)
+            field1171 = unwrapped_fields1168[2]
+            self.pretty_gnf_columns(field1171)
             self.newline()
-            field1159 = unwrapped_fields1155[3]
-            self.pretty_csv_asof(field1159)
+            field1172 = unwrapped_fields1168[3]
+            self.pretty_csv_asof(field1172)
             self.dedent()
             self.write(")")
 
     def pretty_csvlocator(self, msg: logic_pb2.CSVLocator):
-        flat1167 = self._try_flat(msg, self.pretty_csvlocator)
-        if flat1167 is not None:
-            assert flat1167 is not None
-            self.write(flat1167)
+        flat1180 = self._try_flat(msg, self.pretty_csvlocator)
+        if flat1180 is not None:
+            assert flat1180 is not None
+            self.write(flat1180)
             return None
         else:
             _dollar_dollar = msg
             if not len(_dollar_dollar.paths) == 0:
-                _t1356 = _dollar_dollar.paths
+                _t1382 = _dollar_dollar.paths
             else:
-                _t1356 = None
+                _t1382 = None
             if _dollar_dollar.inline_data.decode('utf-8') != "":
-                _t1357 = _dollar_dollar.inline_data.decode('utf-8')
+                _t1383 = _dollar_dollar.inline_data.decode('utf-8')
             else:
-                _t1357 = None
-            fields1161 = (_t1356, _t1357,)
-            assert fields1161 is not None
-            unwrapped_fields1162 = fields1161
+                _t1383 = None
+            fields1174 = (_t1382, _t1383,)
+            assert fields1174 is not None
+            unwrapped_fields1175 = fields1174
             self.write("(csv_locator")
             self.indent_sexp()
-            field1163 = unwrapped_fields1162[0]
-            if field1163 is not None:
+            field1176 = unwrapped_fields1175[0]
+            if field1176 is not None:
                 self.newline()
-                assert field1163 is not None
-                opt_val1164 = field1163
-                self.pretty_csv_locator_paths(opt_val1164)
-            field1165 = unwrapped_fields1162[1]
-            if field1165 is not None:
+                assert field1176 is not None
+                opt_val1177 = field1176
+                self.pretty_csv_locator_paths(opt_val1177)
+            field1178 = unwrapped_fields1175[1]
+            if field1178 is not None:
                 self.newline()
-                assert field1165 is not None
-                opt_val1166 = field1165
-                self.pretty_csv_locator_inline_data(opt_val1166)
+                assert field1178 is not None
+                opt_val1179 = field1178
+                self.pretty_csv_locator_inline_data(opt_val1179)
             self.dedent()
             self.write(")")
 
     def pretty_csv_locator_paths(self, msg: Sequence[str]):
-        flat1171 = self._try_flat(msg, self.pretty_csv_locator_paths)
-        if flat1171 is not None:
-            assert flat1171 is not None
-            self.write(flat1171)
+        flat1184 = self._try_flat(msg, self.pretty_csv_locator_paths)
+        if flat1184 is not None:
+            assert flat1184 is not None
+            self.write(flat1184)
             return None
         else:
-            fields1168 = msg
+            fields1181 = msg
             self.write("(paths")
             self.indent_sexp()
-            if not len(fields1168) == 0:
+            if not len(fields1181) == 0:
                 self.newline()
-                for i1170, elem1169 in enumerate(fields1168):
-                    if (i1170 > 0):
+                for i1183, elem1182 in enumerate(fields1181):
+                    if (i1183 > 0):
                         self.newline()
-                    self.write(self.format_string_value(elem1169))
+                    self.write(self.format_string_value(elem1182))
             self.dedent()
             self.write(")")
 
     def pretty_csv_locator_inline_data(self, msg: str):
-        flat1173 = self._try_flat(msg, self.pretty_csv_locator_inline_data)
-        if flat1173 is not None:
-            assert flat1173 is not None
-            self.write(flat1173)
+        flat1186 = self._try_flat(msg, self.pretty_csv_locator_inline_data)
+        if flat1186 is not None:
+            assert flat1186 is not None
+            self.write(flat1186)
             return None
         else:
-            fields1172 = msg
+            fields1185 = msg
             self.write("(inline_data")
             self.indent_sexp()
             self.newline()
-            self.write(self.format_string_value(fields1172))
+            self.write(self.format_string_value(fields1185))
             self.dedent()
             self.write(")")
 
     def pretty_csv_config(self, msg: logic_pb2.CSVConfig):
-        flat1176 = self._try_flat(msg, self.pretty_csv_config)
-        if flat1176 is not None:
-            assert flat1176 is not None
-            self.write(flat1176)
+        flat1189 = self._try_flat(msg, self.pretty_csv_config)
+        if flat1189 is not None:
+            assert flat1189 is not None
+            self.write(flat1189)
             return None
         else:
             _dollar_dollar = msg
-            _t1358 = self.deconstruct_csv_config(_dollar_dollar)
-            fields1174 = _t1358
-            assert fields1174 is not None
-            unwrapped_fields1175 = fields1174
+            _t1384 = self.deconstruct_csv_config(_dollar_dollar)
+            fields1187 = _t1384
+            assert fields1187 is not None
+            unwrapped_fields1188 = fields1187
             self.write("(csv_config")
             self.indent_sexp()
             self.newline()
-            self.pretty_config_dict(unwrapped_fields1175)
+            self.pretty_config_dict(unwrapped_fields1188)
             self.dedent()
             self.write(")")
 
-    def pretty_csv_columns(self, msg: Sequence[logic_pb2.CSVColumn]):
-        flat1180 = self._try_flat(msg, self.pretty_csv_columns)
-        if flat1180 is not None:
-            assert flat1180 is not None
-            self.write(flat1180)
+    def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]):
+        flat1193 = self._try_flat(msg, self.pretty_gnf_columns)
+        if flat1193 is not None:
+            assert flat1193 is not None
+            self.write(flat1193)
             return None
         else:
-            fields1177 = msg
+            fields1190 = msg
             self.write("(columns")
             self.indent_sexp()
-            if not len(fields1177) == 0:
+            if not len(fields1190) == 0:
                 self.newline()
-                for i1179, elem1178 in enumerate(fields1177):
-                    if (i1179 > 0):
+                for i1192, elem1191 in enumerate(fields1190):
+                    if (i1192 > 0):
                         self.newline()
-                    self.pretty_csv_column(elem1178)
+                    self.pretty_gnf_column(elem1191)
             self.dedent()
             self.write(")")
 
-    def pretty_csv_column(self, msg: logic_pb2.CSVColumn):
-        flat1188 = self._try_flat(msg, self.pretty_csv_column)
-        if flat1188 is not None:
-            assert flat1188 is not None
-            self.write(flat1188)
+    def pretty_gnf_column(self, msg: logic_pb2.GNFColumn):
+        flat1202 = self._try_flat(msg, self.pretty_gnf_column)
+        if flat1202 is not None:
+            assert flat1202 is not None
+            self.write(flat1202)
             return None
         else:
             _dollar_dollar = msg
-            fields1181 = (_dollar_dollar.column_name, _dollar_dollar.target_id, _dollar_dollar.types,)
-            assert fields1181 is not None
-            unwrapped_fields1182 = fields1181
+            if _dollar_dollar.HasField("target_id"):
+                _t1385 = _dollar_dollar.target_id
+            else:
+                _t1385 = None
+            fields1194 = (_dollar_dollar.column_path, _t1385, _dollar_dollar.types,)
+            assert fields1194 is not None
+            unwrapped_fields1195 = fields1194
             self.write("(column")
             self.indent_sexp()
             self.newline()
-            field1183 = unwrapped_fields1182[0]
-            self.write(self.format_string_value(field1183))
-            self.newline()
-            field1184 = unwrapped_fields1182[1]
-            self.pretty_relation_id(field1184)
+            field1196 = unwrapped_fields1195[0]
+            self.pretty_gnf_column_path(field1196)
+            field1197 = unwrapped_fields1195[1]
+            if field1197 is not None:
+                self.newline()
+                assert field1197 is not None
+                opt_val1198 = field1197
+                self.pretty_relation_id(opt_val1198)
             self.newline()
             self.write("[")
-            field1185 = unwrapped_fields1182[2]
-            for i1187, elem1186 in enumerate(field1185):
-                if (i1187 > 0):
+            field1199 = unwrapped_fields1195[2]
+            for i1201, elem1200 in enumerate(field1199):
+                if (i1201 > 0):
                     self.newline()
-                self.pretty_type(elem1186)
+                self.pretty_type(elem1200)
             self.write("]")
             self.dedent()
             self.write(")")
 
+    def pretty_gnf_column_path(self, msg: Sequence[str]):
+        flat1209 = self._try_flat(msg, self.pretty_gnf_column_path)
+        if flat1209 is not None:
+            assert flat1209 is not None
+            self.write(flat1209)
+            return None
+        else:
+            _dollar_dollar = msg
+            if len(_dollar_dollar) == 1:
+                _t1386 = _dollar_dollar[0]
+            else:
+                _t1386 = None
+            deconstruct_result1207 = _t1386
+            if deconstruct_result1207 is not None:
+                assert deconstruct_result1207 is not None
+                unwrapped1208 = deconstruct_result1207
+                self.write(self.format_string_value(unwrapped1208))
+            else:
+                _dollar_dollar = msg
+                if len(_dollar_dollar) != 1:
+                    _t1387 = _dollar_dollar
+                else:
+                    _t1387 = None
+                deconstruct_result1203 = _t1387
+                if deconstruct_result1203 is not None:
+                    assert deconstruct_result1203 is not None
+                    unwrapped1204 = deconstruct_result1203
+                    self.write("[")
+                    self.indent()
+                    for i1206, elem1205 in enumerate(unwrapped1204):
+                        if (i1206 > 0):
+                            self.newline()
+                        self.write(self.format_string_value(elem1205))
+                    self.dedent()
+                    self.write("]")
+                else:
+                    raise ParseError("No matching rule for gnf_column_path")
+
     def pretty_csv_asof(self, msg: str):
-        flat1190 = self._try_flat(msg, self.pretty_csv_asof)
-        if flat1190 is not None:
-            assert flat1190 is not None
-            self.write(flat1190)
+        flat1211 = self._try_flat(msg, self.pretty_csv_asof)
+        if flat1211 is not None:
+            assert flat1211 is not None
+            self.write(flat1211)
             return None
         else:
-            fields1189 = msg
+            fields1210 = msg
             self.write("(asof")
             self.indent_sexp()
             self.newline()
-            self.write(self.format_string_value(fields1189))
+            self.write(self.format_string_value(fields1210))
             self.dedent()
             self.write(")")
 
     def pretty_undefine(self, msg: transactions_pb2.Undefine):
-        flat1193 = self._try_flat(msg, self.pretty_undefine)
-        if flat1193 is not None:
-            assert flat1193 is not None
-            self.write(flat1193)
+        flat1214 = self._try_flat(msg, self.pretty_undefine)
+        if flat1214 is not None:
+            assert flat1214 is not None
+            self.write(flat1214)
             return None
         else:
             _dollar_dollar = msg
-            fields1191 = _dollar_dollar.fragment_id
-            assert fields1191 is not None
-            unwrapped_fields1192 = fields1191
+            fields1212 = _dollar_dollar.fragment_id
+            assert fields1212 is not None
+            unwrapped_fields1213 = fields1212
             self.write("(undefine")
             self.indent_sexp()
             self.newline()
-            self.pretty_fragment_id(unwrapped_fields1192)
+            self.pretty_fragment_id(unwrapped_fields1213)
             self.dedent()
             self.write(")")
 
     def pretty_context(self, msg: transactions_pb2.Context):
-        flat1198 = self._try_flat(msg, self.pretty_context)
-        if flat1198 is not None:
-            assert flat1198 is not None
-            self.write(flat1198)
+        flat1219 = self._try_flat(msg, self.pretty_context)
+        if flat1219 is not None:
+            assert flat1219 is not None
+            self.write(flat1219)
             return None
         else:
             _dollar_dollar = msg
-            fields1194 = _dollar_dollar.relations
-            assert fields1194 is not None
-            unwrapped_fields1195 = fields1194
+            fields1215 = _dollar_dollar.relations
+            assert fields1215 is not None
+            unwrapped_fields1216 = fields1215
             self.write("(context")
             self.indent_sexp()
-            if not len(unwrapped_fields1195) == 0:
+            if not len(unwrapped_fields1216) == 0:
                 self.newline()
-                for i1197, elem1196 in enumerate(unwrapped_fields1195):
-                    if (i1197 > 0):
+                for i1218, elem1217 in enumerate(unwrapped_fields1216):
+                    if (i1218 > 0):
                         self.newline()
-                    self.pretty_relation_id(elem1196)
+                    self.pretty_relation_id(elem1217)
             self.dedent()
             self.write(")")
 
     def pretty_snapshot(self, msg: transactions_pb2.Snapshot):
-        flat1203 = self._try_flat(msg, self.pretty_snapshot)
-        if flat1203 is not None:
-            assert flat1203 is not None
-            self.write(flat1203)
+        flat1224 = self._try_flat(msg, self.pretty_snapshot)
+        if flat1224 is not None:
+            assert flat1224 is not None
+            self.write(flat1224)
             return None
         else:
             _dollar_dollar = msg
-            fields1199 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,)
-            assert fields1199 is not None
-            unwrapped_fields1200 = fields1199
+            fields1220 = _dollar_dollar.mappings
+            assert fields1220 is not None
+            unwrapped_fields1221 = fields1220
             self.write("(snapshot")
             self.indent_sexp()
-            self.newline()
-            field1201 = unwrapped_fields1200[0]
-            self.pretty_rel_edb_path(field1201)
-            self.newline()
-            field1202 = unwrapped_fields1200[1]
-            self.pretty_relation_id(field1202)
+            if not len(unwrapped_fields1221) == 0:
+                self.newline()
+                for i1223, elem1222 in enumerate(unwrapped_fields1221):
+                    if (i1223 > 0):
+                        self.newline()
+                    self.pretty_snapshot_mapping(elem1222)
             self.dedent()
             self.write(")")
 
+    def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping):
+        flat1229 = self._try_flat(msg, self.pretty_snapshot_mapping)
+        if flat1229 is not None:
+            assert flat1229 is not None
+            self.write(flat1229)
+            return None
+        else:
+            _dollar_dollar = msg
+            fields1225 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,)
+            assert fields1225 is not None
+            unwrapped_fields1226 = fields1225
+            field1227 = unwrapped_fields1226[0]
+            self.pretty_edb_path(field1227)
+            self.write(" ")
+            field1228 = unwrapped_fields1226[1]
+            self.pretty_relation_id(field1228)
+
     def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]):
-        flat1207 = self._try_flat(msg, self.pretty_epoch_reads)
-        if flat1207 is not None:
-            assert flat1207 is not None
-            self.write(flat1207)
+        flat1233 = self._try_flat(msg, self.pretty_epoch_reads)
+        if flat1233 is not None:
+            assert flat1233 is not None
+            self.write(flat1233)
             return None
         else:
-            fields1204 = msg
+            fields1230 = msg
             self.write("(reads")
             self.indent_sexp()
-            if not len(fields1204) == 0:
+            if not len(fields1230) == 0:
                 self.newline()
-                for i1206, elem1205 in enumerate(fields1204):
-                    if (i1206 > 0):
+                for i1232, elem1231 in enumerate(fields1230):
+                    if (i1232 > 0):
                         self.newline()
-                    self.pretty_read(elem1205)
+                    self.pretty_read(elem1231)
             self.dedent()
             self.write(")")
 
     def pretty_read(self, msg: transactions_pb2.Read):
-        flat1218 = self._try_flat(msg, self.pretty_read)
-        if flat1218 is not None:
-            assert flat1218 is not None
-            self.write(flat1218)
+        flat1244 = self._try_flat(msg, self.pretty_read)
+        if flat1244 is not None:
+            assert flat1244 is not None
+            self.write(flat1244)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.HasField("demand"):
-                _t1359 = _dollar_dollar.demand
+                _t1388 = _dollar_dollar.demand
             else:
-                _t1359 = None
-            deconstruct_result1216 = _t1359
-            if deconstruct_result1216 is not None:
-                assert deconstruct_result1216 is not None
-                unwrapped1217 = deconstruct_result1216
-                self.pretty_demand(unwrapped1217)
+                _t1388 = None
+            deconstruct_result1242 = _t1388
+            if deconstruct_result1242 is not None:
+                assert deconstruct_result1242 is not None
+                unwrapped1243 = deconstruct_result1242
+                self.pretty_demand(unwrapped1243)
             else:
                 _dollar_dollar = msg
                 if _dollar_dollar.HasField("output"):
-                    _t1360 = _dollar_dollar.output
+                    _t1389 = _dollar_dollar.output
                 else:
-                    _t1360 = None
-                deconstruct_result1214 = _t1360
-                if deconstruct_result1214 is not None:
-                    assert deconstruct_result1214 is not None
-                    unwrapped1215 = deconstruct_result1214
-                    self.pretty_output(unwrapped1215)
+                    _t1389 = None
+                deconstruct_result1240 = _t1389
+                if deconstruct_result1240 is not None:
+                    assert deconstruct_result1240 is not None
+                    unwrapped1241 = deconstruct_result1240
+                    self.pretty_output(unwrapped1241)
                 else:
                     _dollar_dollar = msg
                     if _dollar_dollar.HasField("what_if"):
-                        _t1361 = _dollar_dollar.what_if
+                        _t1390 = _dollar_dollar.what_if
                     else:
-                        _t1361 = None
-                    deconstruct_result1212 = _t1361
-                    if deconstruct_result1212 is not None:
-                        assert deconstruct_result1212 is not None
-                        unwrapped1213 = deconstruct_result1212
-                        self.pretty_what_if(unwrapped1213)
+                        _t1390 = None
+                    deconstruct_result1238 = _t1390
+                    if deconstruct_result1238 is not None:
+                        assert deconstruct_result1238 is not None
+                        unwrapped1239 = deconstruct_result1238
+                        self.pretty_what_if(unwrapped1239)
                     else:
                         _dollar_dollar = msg
                         if _dollar_dollar.HasField("abort"):
-                            _t1362 = _dollar_dollar.abort
+                            _t1391 = _dollar_dollar.abort
                         else:
-                            _t1362 = None
-                        deconstruct_result1210 = _t1362
-                        if deconstruct_result1210 is not None:
-                            assert deconstruct_result1210 is not None
-                            unwrapped1211 = deconstruct_result1210
-                            self.pretty_abort(unwrapped1211)
+                            _t1391 = None
+                        deconstruct_result1236 = _t1391
+                        if deconstruct_result1236 is not None:
+                            assert deconstruct_result1236 is not None
+                            unwrapped1237 = deconstruct_result1236
+                            self.pretty_abort(unwrapped1237)
                         else:
                             _dollar_dollar = msg
                             if _dollar_dollar.HasField("export"):
-                                _t1363 = _dollar_dollar.export
+                                _t1392 = _dollar_dollar.export
                             else:
-                                _t1363 = None
-                            deconstruct_result1208 = _t1363
-                            if deconstruct_result1208 is not None:
-                                assert deconstruct_result1208 is not None
-                                unwrapped1209 = deconstruct_result1208
-                                self.pretty_export(unwrapped1209)
+                                _t1392 = None
+                            deconstruct_result1234 = _t1392
+                            if deconstruct_result1234 is not None:
+                                assert deconstruct_result1234 is not None
+                                unwrapped1235 = deconstruct_result1234
+                                self.pretty_export(unwrapped1235)
                             else:
                                 raise ParseError("No matching rule for read")
 
     def pretty_demand(self, msg: transactions_pb2.Demand):
-        flat1221 = self._try_flat(msg, self.pretty_demand)
-        if flat1221 is not None:
-            assert flat1221 is not None
-            self.write(flat1221)
+        flat1247 = self._try_flat(msg, self.pretty_demand)
+        if flat1247 is not None:
+            assert flat1247 is not None
+            self.write(flat1247)
             return None
         else:
             _dollar_dollar = msg
-            fields1219 = _dollar_dollar.relation_id
-            assert fields1219 is not None
-            unwrapped_fields1220 = fields1219
+            fields1245 = _dollar_dollar.relation_id
+            assert fields1245 is not None
+            unwrapped_fields1246 = fields1245
             self.write("(demand")
             self.indent_sexp()
             self.newline()
-            self.pretty_relation_id(unwrapped_fields1220)
+            self.pretty_relation_id(unwrapped_fields1246)
             self.dedent()
             self.write(")")
 
     def pretty_output(self, msg: transactions_pb2.Output):
-        flat1226 = self._try_flat(msg, self.pretty_output)
-        if flat1226 is not None:
-            assert flat1226 is not None
-            self.write(flat1226)
+        flat1252 = self._try_flat(msg, self.pretty_output)
+        if flat1252 is not None:
+            assert flat1252 is not None
+            self.write(flat1252)
             return None
         else:
             _dollar_dollar = msg
-            fields1222 = (_dollar_dollar.name, _dollar_dollar.relation_id,)
-            assert fields1222 is not None
-            unwrapped_fields1223 = fields1222
+            fields1248 = (_dollar_dollar.name, _dollar_dollar.relation_id,)
+            assert fields1248 is not None
+            unwrapped_fields1249 = fields1248
             self.write("(output")
             self.indent_sexp()
             self.newline()
-            field1224 = unwrapped_fields1223[0]
-            self.pretty_name(field1224)
+            field1250 = unwrapped_fields1249[0]
+            self.pretty_name(field1250)
             self.newline()
-            field1225 = unwrapped_fields1223[1]
-            self.pretty_relation_id(field1225)
+            field1251 = unwrapped_fields1249[1]
+            self.pretty_relation_id(field1251)
             self.dedent()
             self.write(")")
 
     def pretty_what_if(self, msg: transactions_pb2.WhatIf):
-        flat1231 = self._try_flat(msg, self.pretty_what_if)
-        if flat1231 is not None:
-            assert flat1231 is not None
-            self.write(flat1231)
+        flat1257 = self._try_flat(msg, self.pretty_what_if)
+        if flat1257 is not None:
+            assert flat1257 is not None
+            self.write(flat1257)
             return None
         else:
             _dollar_dollar = msg
-            fields1227 = (_dollar_dollar.branch, _dollar_dollar.epoch,)
-            assert fields1227 is not None
-            unwrapped_fields1228 = fields1227
+            fields1253 = (_dollar_dollar.branch, _dollar_dollar.epoch,)
+            assert fields1253 is not None
+            unwrapped_fields1254 = fields1253
             self.write("(what_if")
             self.indent_sexp()
             self.newline()
-            field1229 = unwrapped_fields1228[0]
-            self.pretty_name(field1229)
+            field1255 = unwrapped_fields1254[0]
+            self.pretty_name(field1255)
             self.newline()
-            field1230 = unwrapped_fields1228[1]
-            self.pretty_epoch(field1230)
+            field1256 = unwrapped_fields1254[1]
+            self.pretty_epoch(field1256)
             self.dedent()
             self.write(")")
 
     def pretty_abort(self, msg: transactions_pb2.Abort):
-        flat1237 = self._try_flat(msg, self.pretty_abort)
-        if flat1237 is not None:
-            assert flat1237 is not None
-            self.write(flat1237)
+        flat1263 = self._try_flat(msg, self.pretty_abort)
+        if flat1263 is not None:
+            assert flat1263 is not None
+            self.write(flat1263)
             return None
         else:
             _dollar_dollar = msg
             if _dollar_dollar.name != "abort":
-                _t1364 = _dollar_dollar.name
+                _t1393 = _dollar_dollar.name
             else:
-                _t1364 = None
-            fields1232 = (_t1364, _dollar_dollar.relation_id,)
-            assert fields1232 is not None
-            unwrapped_fields1233 = fields1232
+                _t1393 = None
+            fields1258 = (_t1393, _dollar_dollar.relation_id,)
+            assert fields1258 is not None
+            unwrapped_fields1259 = fields1258
             self.write("(abort")
             self.indent_sexp()
-            field1234 = unwrapped_fields1233[0]
-            if field1234 is not None:
+            field1260 = unwrapped_fields1259[0]
+            if field1260 is not None:
                 self.newline()
-                assert field1234 is not None
-                opt_val1235 = field1234
-                self.pretty_name(opt_val1235)
+                assert field1260 is not None
+                opt_val1261 = field1260
+                self.pretty_name(opt_val1261)
             self.newline()
-            field1236 = unwrapped_fields1233[1]
-            self.pretty_relation_id(field1236)
+            field1262 = unwrapped_fields1259[1]
+            self.pretty_relation_id(field1262)
             self.dedent()
             self.write(")")
 
     def pretty_export(self, msg: transactions_pb2.Export):
-        flat1240 = self._try_flat(msg, self.pretty_export)
-        if flat1240 is not None:
-            assert flat1240 is not None
-            self.write(flat1240)
+        flat1266 = self._try_flat(msg, self.pretty_export)
+        if flat1266 is not None:
+            assert flat1266 is not None
+            self.write(flat1266)
             return None
         else:
             _dollar_dollar = msg
-            fields1238 = _dollar_dollar.csv_config
-            assert fields1238 is not None
-            unwrapped_fields1239 = fields1238
+            fields1264 = _dollar_dollar.csv_config
+            assert fields1264 is not None
+            unwrapped_fields1265 = fields1264
             self.write("(export")
             self.indent_sexp()
             self.newline()
-            self.pretty_export_csv_config(unwrapped_fields1239)
+            self.pretty_export_csv_config(unwrapped_fields1265)
             self.dedent()
             self.write(")")
 
     def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig):
-        flat1246 = self._try_flat(msg, self.pretty_export_csv_config)
-        if flat1246 is not None:
-            assert flat1246 is not None
-            self.write(flat1246)
+        flat1272 = self._try_flat(msg, self.pretty_export_csv_config)
+        if flat1272 is not None:
+            assert flat1272 is not None
+            self.write(flat1272)
             return None
         else:
             _dollar_dollar = msg
-            _t1365 = self.deconstruct_export_csv_config(_dollar_dollar)
-            fields1241 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1365,)
-            assert fields1241 is not None
-            unwrapped_fields1242 = fields1241
+            _t1394 = self.deconstruct_export_csv_config(_dollar_dollar)
+            fields1267 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1394,)
+            assert fields1267 is not None
+            unwrapped_fields1268 = fields1267
             self.write("(export_csv_config")
             self.indent_sexp()
             self.newline()
-            field1243 = unwrapped_fields1242[0]
-            self.pretty_export_csv_path(field1243)
+            field1269 = unwrapped_fields1268[0]
+            self.pretty_export_csv_path(field1269)
             self.newline()
-            field1244 = unwrapped_fields1242[1]
-            self.pretty_export_csv_columns(field1244)
+            field1270 = unwrapped_fields1268[1]
+            self.pretty_export_csv_columns(field1270)
             self.newline()
-            field1245 = unwrapped_fields1242[2]
-            self.pretty_config_dict(field1245)
+            field1271 = unwrapped_fields1268[2]
+            self.pretty_config_dict(field1271)
             self.dedent()
             self.write(")")
 
     def pretty_export_csv_path(self, msg: str):
-        flat1248 = self._try_flat(msg, self.pretty_export_csv_path)
-        if flat1248 is not None:
-            assert flat1248 is not None
-            self.write(flat1248)
+        flat1274 = self._try_flat(msg, self.pretty_export_csv_path)
+        if flat1274 is not None:
+            assert flat1274 is not None
+            self.write(flat1274)
             return None
         else:
-            fields1247 = msg
+            fields1273 = msg
             self.write("(path")
             self.indent_sexp()
             self.newline()
-            self.write(self.format_string_value(fields1247))
+            self.write(self.format_string_value(fields1273))
             self.dedent()
             self.write(")")
 
     def pretty_export_csv_columns(self, msg: Sequence[transactions_pb2.ExportCSVColumn]):
-        flat1252 = self._try_flat(msg, self.pretty_export_csv_columns)
-        if flat1252 is not None:
-            assert flat1252 is not None
-            self.write(flat1252)
+        flat1278 = self._try_flat(msg, self.pretty_export_csv_columns)
+        if flat1278 is not None:
+            assert flat1278 is not None
+            self.write(flat1278)
             return None
         else:
-            fields1249 = msg
+            fields1275 = msg
             self.write("(columns")
             self.indent_sexp()
-            if not len(fields1249) == 0:
+            if not len(fields1275) == 0:
                 self.newline()
-                for i1251, elem1250 in enumerate(fields1249):
-                    if (i1251 > 0):
+                for i1277, elem1276 in enumerate(fields1275):
+                    if (i1277 > 0):
                         self.newline()
-                    self.pretty_export_csv_column(elem1250)
+                    self.pretty_export_csv_column(elem1276)
             self.dedent()
             self.write(")")
 
     def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn):
-        flat1257 = self._try_flat(msg, self.pretty_export_csv_column)
-        if flat1257 is not None:
-            assert flat1257 is not None
-            self.write(flat1257)
+        flat1283 = self._try_flat(msg, self.pretty_export_csv_column)
+        if flat1283 is not None:
+            assert flat1283 is not None
+            self.write(flat1283)
             return None
         else:
             _dollar_dollar = msg
-            fields1253 = (_dollar_dollar.column_name, _dollar_dollar.column_data,)
-            assert fields1253 is not None
-            unwrapped_fields1254 = fields1253
+            fields1279 = (_dollar_dollar.column_name, _dollar_dollar.column_data,)
+            assert fields1279 is not None
+            unwrapped_fields1280 = fields1279
             self.write("(column")
             self.indent_sexp()
             self.newline()
-            field1255 = unwrapped_fields1254[0]
-            self.write(self.format_string_value(field1255))
+            field1281 = unwrapped_fields1280[0]
+            self.write(self.format_string_value(field1281))
             self.newline()
-            field1256 = unwrapped_fields1254[1]
-            self.pretty_relation_id(field1256)
+            field1282 = unwrapped_fields1280[1]
+            self.pretty_relation_id(field1282)
             self.dedent()
             self.write(")")
 
@@ -3434,8 +3496,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo):
         for _idx, _rid in enumerate(msg.ids):
             self.newline()
             self.write("(")
-            _t1403 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high)
-            self.pprint_dispatch(_t1403)
+            _t1432 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high)
+            self.pprint_dispatch(_t1432)
             self.write(" ")
             self.write(self.format_string_value(msg.orig_names[_idx]))
             self.write(")")
@@ -3670,8 +3732,8 @@ def pprint_dispatch(self, msg):
             self.pretty_constraint(msg)
         elif isinstance(msg, logic_pb2.Data):
             self.pretty_data(msg)
-        elif isinstance(msg, logic_pb2.RelEDB):
-            self.pretty_rel_edb(msg)
+        elif isinstance(msg, logic_pb2.EDB):
+            self.pretty_edb(msg)
         elif isinstance(msg, logic_pb2.BeTreeRelation):
             self.pretty_betree_relation(msg)
         elif isinstance(msg, logic_pb2.BeTreeInfo):
@@ -3682,14 +3744,16 @@ def pprint_dispatch(self, msg):
             self.pretty_csvlocator(msg)
         elif isinstance(msg, logic_pb2.CSVConfig):
             self.pretty_csv_config(msg)
-        elif isinstance(msg, logic_pb2.CSVColumn):
-            self.pretty_csv_column(msg)
+        elif isinstance(msg, logic_pb2.GNFColumn):
+            self.pretty_gnf_column(msg)
         elif isinstance(msg, transactions_pb2.Undefine):
             self.pretty_undefine(msg)
         elif isinstance(msg, transactions_pb2.Context):
             self.pretty_context(msg)
         elif isinstance(msg, transactions_pb2.Snapshot):
             self.pretty_snapshot(msg)
+        elif isinstance(msg, transactions_pb2.SnapshotMapping):
+            self.pretty_snapshot_mapping(msg)
         elif isinstance(msg, transactions_pb2.Read):
             self.pretty_read(msg)
         elif isinstance(msg, transactions_pb2.Demand):
diff --git a/sdks/python/src/lqp/proto/v1/fragments_pb2.py b/sdks/python/src/lqp/proto/v1/fragments_pb2.py
index 1ed054e4..54986913 100644
--- a/sdks/python/src/lqp/proto/v1/fragments_pb2.py
+++ b/sdks/python/src/lqp/proto/v1/fragments_pb2.py
@@ -15,14 +15,14 @@
 from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#relationalai/lqp/v1/fragments.proto\x12\x13relationalai.lqp.v1\x1a\x1frelationalai/lqp/v1/logic.proto\"\xc0\x01\n\x08\x46ragment\x12/\n\x02id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\x02id\x12\x44\n\x0c\x64\x65\x63larations\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.DeclarationR\x0c\x64\x65\x63larations\x12=\n\ndebug_info\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DebugInfoR\tdebugInfo\"]\n\tDebugInfo\x12\x31\n\x03ids\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x03ids\x12\x1d\n\norig_names\x18\x02 \x03(\tR\torigNames\"\x1c\n\nFragmentId\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02idB\x1fZ\x1dlogical-query-protocol/lqp/v1b\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#relationalai/lqp/v1/fragments.proto\x12\x13relationalai.lqp.v1\x1a\x1frelationalai/lqp/v1/logic.proto\"\xc0\x01\n\x08\x46ragment\x12/\n\x02id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\x02id\x12\x44\n\x0c\x64\x65\x63larations\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.DeclarationR\x0c\x64\x65\x63larations\x12=\n\ndebug_info\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DebugInfoR\tdebugInfo\"]\n\tDebugInfo\x12\x31\n\x03ids\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x03ids\x12\x1d\n\norig_names\x18\x02 \x03(\tR\torigNames\"\x1c\n\nFragmentId\x12\x0e\n\x02id\x18\x01 \x01(\x0cR\x02idBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.fragments_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['DESCRIPTOR']._options = None
-  _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1'
+  _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1'
   _globals['_FRAGMENT']._serialized_start=94
   _globals['_FRAGMENT']._serialized_end=286
   _globals['_DEBUGINFO']._serialized_start=288
diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.py b/sdks/python/src/lqp/proto/v1/logic_pb2.py
index 3f02d031..74019ce3 100644
--- a/sdks/python/src/lqp/proto/v1/logic_pb2.py
+++ b/sdks/python/src/lqp/proto/v1/logic_pb2.py
@@ -14,14 +14,14 @@
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"u\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"m\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\xd6\x01\n\x04\x44\x61ta\x12\x36\n\x07rel_edb\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.RelEDBH\x00R\x06relEdb\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svDataB\x0b\n\tdata_type\"\x8b\x01\n\x06RelEDB\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xca\x01\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.CSVColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\"\x9b\x01\n\tCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12<\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\x89\x06\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanTypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\xd1\x04\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueB\x1fZ\x1dlogical-query-protocol/lqp/v1b\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"u\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"m\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\xcc\x01\n\x04\x44\x61ta\x12,\n\x03\x65\x64\x62\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.EDBH\x00R\x03\x65\x64\x62\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svDataB\x0b\n\tdata_type\"\x88\x01\n\x03\x45\x44\x42\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xca\x01\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\xe3\x02\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\"\xae\x01\n\tGNFColumn\x12\x1f\n\x0b\x63olumn_path\x18\x01 \x03(\tR\ncolumnPath\x12\x41\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08targetId\x88\x01\x01\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05typesB\x0c\n\n_target_id\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\x89\x06\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanTypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\xd1\x04\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.logic_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['DESCRIPTOR']._options = None
-  _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1'
+  _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1'
   _globals['_DECLARATION']._serialized_start=57
   _globals['_DECLARATION']._serialized_end=316
   _globals['_DEF']._serialized_start=319
@@ -97,63 +97,63 @@
   _globals['_ATTRIBUTE']._serialized_start=5346
   _globals['_ATTRIBUTE']._serialized_end=5425
   _globals['_DATA']._serialized_start=5428
-  _globals['_DATA']._serialized_end=5642
-  _globals['_RELEDB']._serialized_start=5645
-  _globals['_RELEDB']._serialized_end=5784
-  _globals['_BETREERELATION']._serialized_start=5787
-  _globals['_BETREERELATION']._serialized_end=5926
-  _globals['_BETREEINFO']._serialized_start=5929
-  _globals['_BETREEINFO']._serialized_end=6216
-  _globals['_BETREECONFIG']._serialized_start=6219
-  _globals['_BETREECONFIG']._serialized_end=6348
-  _globals['_BETREELOCATOR']._serialized_start=6351
-  _globals['_BETREELOCATOR']._serialized_end=6553
-  _globals['_CSVDATA']._serialized_start=6556
-  _globals['_CSVDATA']._serialized_end=6758
-  _globals['_CSVLOCATOR']._serialized_start=6760
-  _globals['_CSVLOCATOR']._serialized_end=6827
-  _globals['_CSVCONFIG']._serialized_start=6830
-  _globals['_CSVCONFIG']._serialized_end=7185
-  _globals['_CSVCOLUMN']._serialized_start=7188
-  _globals['_CSVCOLUMN']._serialized_end=7343
-  _globals['_RELATIONID']._serialized_start=7345
-  _globals['_RELATIONID']._serialized_end=7405
-  _globals['_TYPE']._serialized_start=7408
-  _globals['_TYPE']._serialized_end=8185
-  _globals['_UNSPECIFIEDTYPE']._serialized_start=8187
-  _globals['_UNSPECIFIEDTYPE']._serialized_end=8204
-  _globals['_STRINGTYPE']._serialized_start=8206
-  _globals['_STRINGTYPE']._serialized_end=8218
-  _globals['_INTTYPE']._serialized_start=8220
-  _globals['_INTTYPE']._serialized_end=8229
-  _globals['_FLOATTYPE']._serialized_start=8231
-  _globals['_FLOATTYPE']._serialized_end=8242
-  _globals['_UINT128TYPE']._serialized_start=8244
-  _globals['_UINT128TYPE']._serialized_end=8257
-  _globals['_INT128TYPE']._serialized_start=8259
-  _globals['_INT128TYPE']._serialized_end=8271
-  _globals['_DATETYPE']._serialized_start=8273
-  _globals['_DATETYPE']._serialized_end=8283
-  _globals['_DATETIMETYPE']._serialized_start=8285
-  _globals['_DATETIMETYPE']._serialized_end=8299
-  _globals['_MISSINGTYPE']._serialized_start=8301
-  _globals['_MISSINGTYPE']._serialized_end=8314
-  _globals['_DECIMALTYPE']._serialized_start=8316
-  _globals['_DECIMALTYPE']._serialized_end=8381
-  _globals['_BOOLEANTYPE']._serialized_start=8383
-  _globals['_BOOLEANTYPE']._serialized_end=8396
-  _globals['_VALUE']._serialized_start=8399
-  _globals['_VALUE']._serialized_end=8992
-  _globals['_UINT128VALUE']._serialized_start=8994
-  _globals['_UINT128VALUE']._serialized_end=9046
-  _globals['_INT128VALUE']._serialized_start=9048
-  _globals['_INT128VALUE']._serialized_end=9099
-  _globals['_MISSINGVALUE']._serialized_start=9101
-  _globals['_MISSINGVALUE']._serialized_end=9115
-  _globals['_DATEVALUE']._serialized_start=9117
-  _globals['_DATEVALUE']._serialized_end=9188
-  _globals['_DATETIMEVALUE']._serialized_start=9191
-  _globals['_DATETIMEVALUE']._serialized_end=9368
-  _globals['_DECIMALVALUE']._serialized_start=9370
-  _globals['_DECIMALVALUE']._serialized_end=9492
+  _globals['_DATA']._serialized_end=5632
+  _globals['_EDB']._serialized_start=5635
+  _globals['_EDB']._serialized_end=5771
+  _globals['_BETREERELATION']._serialized_start=5774
+  _globals['_BETREERELATION']._serialized_end=5913
+  _globals['_BETREEINFO']._serialized_start=5916
+  _globals['_BETREEINFO']._serialized_end=6203
+  _globals['_BETREECONFIG']._serialized_start=6206
+  _globals['_BETREECONFIG']._serialized_end=6335
+  _globals['_BETREELOCATOR']._serialized_start=6338
+  _globals['_BETREELOCATOR']._serialized_end=6540
+  _globals['_CSVDATA']._serialized_start=6543
+  _globals['_CSVDATA']._serialized_end=6745
+  _globals['_CSVLOCATOR']._serialized_start=6747
+  _globals['_CSVLOCATOR']._serialized_end=6814
+  _globals['_CSVCONFIG']._serialized_start=6817
+  _globals['_CSVCONFIG']._serialized_end=7172
+  _globals['_GNFCOLUMN']._serialized_start=7175
+  _globals['_GNFCOLUMN']._serialized_end=7349
+  _globals['_RELATIONID']._serialized_start=7351
+  _globals['_RELATIONID']._serialized_end=7411
+  _globals['_TYPE']._serialized_start=7414
+  _globals['_TYPE']._serialized_end=8191
+  _globals['_UNSPECIFIEDTYPE']._serialized_start=8193
+  _globals['_UNSPECIFIEDTYPE']._serialized_end=8210
+  _globals['_STRINGTYPE']._serialized_start=8212
+  _globals['_STRINGTYPE']._serialized_end=8224
+  _globals['_INTTYPE']._serialized_start=8226
+  _globals['_INTTYPE']._serialized_end=8235
+  _globals['_FLOATTYPE']._serialized_start=8237
+  _globals['_FLOATTYPE']._serialized_end=8248
+  _globals['_UINT128TYPE']._serialized_start=8250
+  _globals['_UINT128TYPE']._serialized_end=8263
+  _globals['_INT128TYPE']._serialized_start=8265
+  _globals['_INT128TYPE']._serialized_end=8277
+  _globals['_DATETYPE']._serialized_start=8279
+  _globals['_DATETYPE']._serialized_end=8289
+  _globals['_DATETIMETYPE']._serialized_start=8291
+  _globals['_DATETIMETYPE']._serialized_end=8305
+  _globals['_MISSINGTYPE']._serialized_start=8307
+  _globals['_MISSINGTYPE']._serialized_end=8320
+  _globals['_DECIMALTYPE']._serialized_start=8322
+  _globals['_DECIMALTYPE']._serialized_end=8387
+  _globals['_BOOLEANTYPE']._serialized_start=8389
+  _globals['_BOOLEANTYPE']._serialized_end=8402
+  _globals['_VALUE']._serialized_start=8405
+  _globals['_VALUE']._serialized_end=8998
+  _globals['_UINT128VALUE']._serialized_start=9000
+  _globals['_UINT128VALUE']._serialized_end=9052
+  _globals['_INT128VALUE']._serialized_start=9054
+  _globals['_INT128VALUE']._serialized_end=9105
+  _globals['_MISSINGVALUE']._serialized_start=9107
+  _globals['_MISSINGVALUE']._serialized_end=9121
+  _globals['_DATEVALUE']._serialized_start=9123
+  _globals['_DATEVALUE']._serialized_end=9194
+  _globals['_DATETIMEVALUE']._serialized_start=9197
+  _globals['_DATETIMEVALUE']._serialized_end=9374
+  _globals['_DECIMALVALUE']._serialized_start=9376
+  _globals['_DECIMALVALUE']._serialized_end=9498
 # @@protoc_insertion_point(module_scope)
diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi
index 7f98bbcf..8f8e1a08 100644
--- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi
+++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi
@@ -337,16 +337,16 @@ class Attribute(_message.Message):
     def __init__(self, name: _Optional[str] = ..., args: _Optional[_Iterable[_Union[Value, _Mapping]]] = ...) -> None: ...
 
 class Data(_message.Message):
-    __slots__ = ("rel_edb", "betree_relation", "csv_data")
-    REL_EDB_FIELD_NUMBER: _ClassVar[int]
+    __slots__ = ("edb", "betree_relation", "csv_data")
+    EDB_FIELD_NUMBER: _ClassVar[int]
     BETREE_RELATION_FIELD_NUMBER: _ClassVar[int]
     CSV_DATA_FIELD_NUMBER: _ClassVar[int]
-    rel_edb: RelEDB
+    edb: EDB
     betree_relation: BeTreeRelation
     csv_data: CSVData
-    def __init__(self, rel_edb: _Optional[_Union[RelEDB, _Mapping]] = ..., betree_relation: _Optional[_Union[BeTreeRelation, _Mapping]] = ..., csv_data: _Optional[_Union[CSVData, _Mapping]] = ...) -> None: ...
+    def __init__(self, edb: _Optional[_Union[EDB, _Mapping]] = ..., betree_relation: _Optional[_Union[BeTreeRelation, _Mapping]] = ..., csv_data: _Optional[_Union[CSVData, _Mapping]] = ...) -> None: ...
 
-class RelEDB(_message.Message):
+class EDB(_message.Message):
     __slots__ = ("target_id", "path", "types")
     TARGET_ID_FIELD_NUMBER: _ClassVar[int]
     PATH_FIELD_NUMBER: _ClassVar[int]
@@ -408,9 +408,9 @@ class CSVData(_message.Message):
     ASOF_FIELD_NUMBER: _ClassVar[int]
     locator: CSVLocator
     config: CSVConfig
-    columns: _containers.RepeatedCompositeFieldContainer[CSVColumn]
+    columns: _containers.RepeatedCompositeFieldContainer[GNFColumn]
     asof: str
-    def __init__(self, locator: _Optional[_Union[CSVLocator, _Mapping]] = ..., config: _Optional[_Union[CSVConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[CSVColumn, _Mapping]]] = ..., asof: _Optional[str] = ...) -> None: ...
+    def __init__(self, locator: _Optional[_Union[CSVLocator, _Mapping]] = ..., config: _Optional[_Union[CSVConfig, _Mapping]] = ..., columns: _Optional[_Iterable[_Union[GNFColumn, _Mapping]]] = ..., asof: _Optional[str] = ...) -> None: ...
 
 class CSVLocator(_message.Message):
     __slots__ = ("paths", "inline_data")
@@ -446,15 +446,15 @@ class CSVConfig(_message.Message):
     compression: str
     def __init__(self, header_row: _Optional[int] = ..., skip: _Optional[int] = ..., new_line: _Optional[str] = ..., delimiter: _Optional[str] = ..., quotechar: _Optional[str] = ..., escapechar: _Optional[str] = ..., comment: _Optional[str] = ..., missing_strings: _Optional[_Iterable[str]] = ..., decimal_separator: _Optional[str] = ..., encoding: _Optional[str] = ..., compression: _Optional[str] = ...) -> None: ...
 
-class CSVColumn(_message.Message):
-    __slots__ = ("column_name", "target_id", "types")
-    COLUMN_NAME_FIELD_NUMBER: _ClassVar[int]
+class GNFColumn(_message.Message):
+    __slots__ = ("column_path", "target_id", "types")
+    COLUMN_PATH_FIELD_NUMBER: _ClassVar[int]
     TARGET_ID_FIELD_NUMBER: _ClassVar[int]
     TYPES_FIELD_NUMBER: _ClassVar[int]
-    column_name: str
+    column_path: _containers.RepeatedScalarFieldContainer[str]
     target_id: RelationId
     types: _containers.RepeatedCompositeFieldContainer[Type]
-    def __init__(self, column_name: _Optional[str] = ..., target_id: _Optional[_Union[RelationId, _Mapping]] = ..., types: _Optional[_Iterable[_Union[Type, _Mapping]]] = ...) -> None: ...
+    def __init__(self, column_path: _Optional[_Iterable[str]] = ..., target_id: _Optional[_Union[RelationId, _Mapping]] = ..., types: _Optional[_Iterable[_Union[Type, _Mapping]]] = ...) -> None: ...
 
 class RelationId(_message.Message):
     __slots__ = ("id_low", "id_high")
diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py
index fdca81c0..5d4f5cd3 100644
--- a/sdks/python/src/lqp/proto/v1/transactions_pb2.py
+++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.py
@@ -16,16 +16,16 @@
 from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x7f\n\x08Snapshot\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x1fZ\x1dlogical-query-protocol/lqp/v1b\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x86\x01\n\x0fSnapshotMapping\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"L\n\x08Snapshot\x12@\n\x08mappings\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.SnapshotMappingR\x08mappings\"\xc4\x04\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"`\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'relationalai.lqp.v1.transactions_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['DESCRIPTOR']._options = None
-  _globals['DESCRIPTOR']._serialized_options = b'Z\035logical-query-protocol/lqp/v1'
-  _globals['_MAINTENANCELEVEL']._serialized_start=2761
-  _globals['_MAINTENANCELEVEL']._serialized_end=2896
+  _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1'
+  _globals['_MAINTENANCELEVEL']._serialized_start=2847
+  _globals['_MAINTENANCELEVEL']._serialized_end=2982
   _globals['_TRANSACTION']._serialized_start=134
   _globals['_TRANSACTION']._serialized_end=322
   _globals['_CONFIGURE']._serialized_start=324
@@ -44,22 +44,24 @@
   _globals['_UNDEFINE']._serialized_end=1110
   _globals['_CONTEXT']._serialized_start=1112
   _globals['_CONTEXT']._serialized_end=1184
-  _globals['_SNAPSHOT']._serialized_start=1186
-  _globals['_SNAPSHOT']._serialized_end=1313
-  _globals['_EXPORTCSVCONFIG']._serialized_start=1316
-  _globals['_EXPORTCSVCONFIG']._serialized_end=1896
-  _globals['_EXPORTCSVCOLUMN']._serialized_start=1898
-  _globals['_EXPORTCSVCOLUMN']._serialized_end=2014
-  _globals['_READ']._serialized_start=2017
-  _globals['_READ']._serialized_end=2309
-  _globals['_DEMAND']._serialized_start=2311
-  _globals['_DEMAND']._serialized_end=2385
-  _globals['_OUTPUT']._serialized_start=2387
-  _globals['_OUTPUT']._serialized_end=2481
-  _globals['_EXPORT']._serialized_start=2483
-  _globals['_EXPORT']._serialized_end=2579
-  _globals['_WHATIF']._serialized_start=2581
-  _globals['_WHATIF']._serialized_end=2663
-  _globals['_ABORT']._serialized_start=2665
-  _globals['_ABORT']._serialized_end=2758
+  _globals['_SNAPSHOTMAPPING']._serialized_start=1187
+  _globals['_SNAPSHOTMAPPING']._serialized_end=1321
+  _globals['_SNAPSHOT']._serialized_start=1323
+  _globals['_SNAPSHOT']._serialized_end=1399
+  _globals['_EXPORTCSVCONFIG']._serialized_start=1402
+  _globals['_EXPORTCSVCONFIG']._serialized_end=1982
+  _globals['_EXPORTCSVCOLUMN']._serialized_start=1984
+  _globals['_EXPORTCSVCOLUMN']._serialized_end=2100
+  _globals['_READ']._serialized_start=2103
+  _globals['_READ']._serialized_end=2395
+  _globals['_DEMAND']._serialized_start=2397
+  _globals['_DEMAND']._serialized_end=2471
+  _globals['_OUTPUT']._serialized_start=2473
+  _globals['_OUTPUT']._serialized_end=2567
+  _globals['_EXPORT']._serialized_start=2569
+  _globals['_EXPORT']._serialized_end=2665
+  _globals['_WHATIF']._serialized_start=2667
+  _globals['_WHATIF']._serialized_end=2749
+  _globals['_ABORT']._serialized_start=2751
+  _globals['_ABORT']._serialized_end=2844
 # @@protoc_insertion_point(module_scope)
diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi
index 7af683a7..58274043 100644
--- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi
+++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi
@@ -88,7 +88,7 @@ class Context(_message.Message):
     relations: _containers.RepeatedCompositeFieldContainer[_logic_pb2.RelationId]
     def __init__(self, relations: _Optional[_Iterable[_Union[_logic_pb2.RelationId, _Mapping]]] = ...) -> None: ...
 
-class Snapshot(_message.Message):
+class SnapshotMapping(_message.Message):
     __slots__ = ("destination_path", "source_relation")
     DESTINATION_PATH_FIELD_NUMBER: _ClassVar[int]
     SOURCE_RELATION_FIELD_NUMBER: _ClassVar[int]
@@ -96,6 +96,12 @@ class Snapshot(_message.Message):
     source_relation: _logic_pb2.RelationId
     def __init__(self, destination_path: _Optional[_Iterable[str]] = ..., source_relation: _Optional[_Union[_logic_pb2.RelationId, _Mapping]] = ...) -> None: ...
 
+class Snapshot(_message.Message):
+    __slots__ = ("mappings",)
+    MAPPINGS_FIELD_NUMBER: _ClassVar[int]
+    mappings: _containers.RepeatedCompositeFieldContainer[SnapshotMapping]
+    def __init__(self, mappings: _Optional[_Iterable[_Union[SnapshotMapping, _Mapping]]] = ...) -> None: ...
+
 class ExportCSVConfig(_message.Message):
     __slots__ = ("path", "data_columns", "partition_size", "compression", "syntax_header_row", "syntax_missing_string", "syntax_delim", "syntax_quotechar", "syntax_escapechar")
     PATH_FIELD_NUMBER: _ClassVar[int]
diff --git a/sdks/python/tests/test_extra_pretty.py b/sdks/python/tests/test_extra_pretty.py
index 152d5a2d..60955a17 100644
--- a/sdks/python/tests/test_extra_pretty.py
+++ b/sdks/python/tests/test_extra_pretty.py
@@ -221,16 +221,16 @@ def test_instruction_assign(self):
         result = _pp(msg)
         assert result.startswith("(assign")
 
-    def test_data_rel_edb(self):
+    def test_data_edb(self):
         msg = logic_pb2.Data(
-            rel_edb=logic_pb2.RelEDB(
+            edb=logic_pb2.EDB(
                 target_id=logic_pb2.RelationId(id_low=1, id_high=0),
                 path=["base", "rel"],
                 types=[],
             )
         )
         result = _pp(msg)
-        assert result.startswith("(rel_edb")
+        assert result.startswith("(edb")
 
     def test_read_demand(self):
         msg = transactions_pb2.Read(
diff --git a/tests/bin/cdc.bin b/tests/bin/cdc.bin
new file mode 100644
index 00000000..85b823bc
Binary files /dev/null and b/tests/bin/cdc.bin differ
diff --git a/tests/bin/snapshot.bin b/tests/bin/snapshot.bin
index dc1cbf24..122c1426 100644
Binary files a/tests/bin/snapshot.bin and b/tests/bin/snapshot.bin differ
diff --git a/tests/lqp/cdc.lqp b/tests/lqp/cdc.lqp
new file mode 100644
index 00000000..0d14a75f
--- /dev/null
+++ b/tests/lqp/cdc.lqp
@@ -0,0 +1,36 @@
+(transaction
+  (epoch
+    (writes
+      (define
+        (fragment :f1
+          ;; CDC load with path-based columns
+          (csv_data
+            (csv_locator
+              (paths "s3://bucket/cdc/batch_001.csv"))
+            (csv_config {})
+            (columns
+              ;; Unbound column (schema only)
+              (column "raw_data" [])
+
+              ;; METADATA$KEY insert + delete deltas
+              (column ["append" "METADATA$KEY"] :mk_ins [UINT128])
+              (column ["delete" "METADATA$KEY"] :mk_del [UINT128])
+
+              ;; Data columns: insert-only deltas
+              (column ["append" "user_id"] :uid_ins [INT])
+              (column ["append" "name"] :name_ins [STRING])
+
+              ;; Full snapshot + delta on same column
+              (column "id" :entity_id [INT])
+              (column ["append" "id"] :eid_ins [INT])
+              (column ["delete" "id"] :eid_del [INT]))
+            (asof "2025-06-01T00:00:00Z")))))
+
+    (reads
+      (output :mk_ins :mk_ins)
+      (output :mk_del :mk_del)
+      (output :uid_ins :uid_ins)
+      (output :name_ins :name_ins)
+      (output :entity_id :entity_id)
+      (output :eid_ins :eid_ins)
+      (output :eid_del :eid_del))))
diff --git a/tests/lqp/edb.lqp b/tests/lqp/edb.lqp
index b1bee8a5..5f0b9a84 100644
--- a/tests/lqp/edb.lqp
+++ b/tests/lqp/edb.lqp
@@ -81,18 +81,18 @@
                 :betree_locator_element_count 10
                 :betree_locator_tree_height 1 }))
 
-          ;; RelEDB examples (formerly BaseRelationPath)
+          ;; EDB examples (formerly BaseRelationPath)
           ;; Simple path with basic types
-          (rel_edb :path_simple ["my_base_relation"] [INT STRING FLOAT])
+          (edb :path_simple ["my_base_relation"] [INT STRING FLOAT])
 
           ;; Path with multiple segments
-          (rel_edb :path_specialized ["another" "path"] [INT STRING])
+          (edb :path_specialized ["another" "path"] [INT STRING])
 
           ;; Path with mixed types including decimals
-          (rel_edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
+          (edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
 
           ;; Path with no types (empty)
-          (rel_edb :path_empty ["empty_path"] [])
+          (edb :path_empty ["empty_path"] [])
 
           ;; Mix with def and algorithm
           (def :foo ([x::INT] (= x 1)))
diff --git a/tests/lqp/snapshot.lqp b/tests/lqp/snapshot.lqp
index a134ba7a..455f1a59 100644
--- a/tests/lqp/snapshot.lqp
+++ b/tests/lqp/snapshot.lqp
@@ -6,9 +6,9 @@
       ;; Define the EDBs we're going to be referring to.
       (define
         (fragment :snapshots
-          (rel_edb :snapshot1 ["my_edb"] [])
-          (rel_edb :snapshot2 ["database" "table"] [])
-          (rel_edb :snapshot3 ["schema" "namespace" "relation"] [])))
+          (edb :snapshot1 ["my_edb"] [])
+          (edb :snapshot2 ["database" "table"] [])
+          (edb :snapshot3 ["schema" "namespace" "relation"] [])))
       (define
         (fragment :frag1
           (def :my_rel
@@ -45,9 +45,10 @@
   ;; Snapshot the defined relations as EDBs
   (epoch
     (writes
-      (snapshot ["my_edb"] :my_rel)
-      (snapshot ["database" "table"] :computed)
-      (snapshot ["schema" "namespace" "relation"] :big_signed))
+      (snapshot
+        ["my_edb"] :my_rel
+        ["database" "table"] :computed
+        ["schema" "namespace" "relation"] :big_signed))
     ;; Snapshots should match the relations now.
     (reads
       (output :snapshot1 :snapshot1)
diff --git a/tests/pretty/cdc.lqp b/tests/pretty/cdc.lqp
new file mode 100644
index 00000000..5f196d30
--- /dev/null
+++ b/tests/pretty/cdc.lqp
@@ -0,0 +1,37 @@
+(transaction
+  (configure { :ivm.maintenance_level "off" :semantics_version 0})
+  (epoch
+    (writes
+      (define
+        (fragment
+          :f1
+          (csv_data
+            (csv_locator (paths "s3://bucket/cdc/batch_001.csv"))
+            (csv_config
+              {
+               :csv_compression "auto"
+               :csv_decimal_separator "."
+               :csv_delimiter ","
+               :csv_encoding "utf-8"
+               :csv_escapechar "\""
+               :csv_header_row 1
+               :csv_quotechar "\""
+               :csv_skip 0})
+            (columns
+              (column "raw_data" [])
+              (column ["append" "METADATA$KEY"] :mk_ins [UINT128])
+              (column ["delete" "METADATA$KEY"] :mk_del [UINT128])
+              (column ["append" "user_id"] :uid_ins [INT])
+              (column ["append" "name"] :name_ins [STRING])
+              (column "id" :entity_id [INT])
+              (column ["append" "id"] :eid_ins [INT])
+              (column ["delete" "id"] :eid_del [INT]))
+            (asof "2025-06-01T00:00:00Z")))))
+    (reads
+      (output :mk_ins :mk_ins)
+      (output :mk_del :mk_del)
+      (output :uid_ins :uid_ins)
+      (output :name_ins :name_ins)
+      (output :entity_id :entity_id)
+      (output :eid_ins :eid_ins)
+      (output :eid_del :eid_del))))
diff --git a/tests/pretty/edb.lqp b/tests/pretty/edb.lqp
index 6a11a6ac..c39dd33a 100644
--- a/tests/pretty/edb.lqp
+++ b/tests/pretty/edb.lqp
@@ -83,10 +83,10 @@
                :betree_locator_element_count 10
                :betree_locator_root_pageid 0x7777888899990000111122
                :betree_locator_tree_height 1}))
-          (rel_edb :path_simple ["my_base_relation"] [INT STRING FLOAT])
-          (rel_edb :path_specialized ["another" "path"] [INT STRING])
-          (rel_edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
-          (rel_edb :path_empty ["empty_path"] [])
+          (edb :path_simple ["my_base_relation"] [INT STRING FLOAT])
+          (edb :path_specialized ["another" "path"] [INT STRING])
+          (edb :path_mixed ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
+          (edb :path_empty ["empty_path"] [])
           (def :foo ([x::INT] (= x 1)))
           (algorithm :bar :baz (script (assign :bar ([y::INT] (= y 2)))))))
       (define
diff --git a/tests/pretty/snapshot.lqp b/tests/pretty/snapshot.lqp
index c3fa0b3c..df31ba73 100644
--- a/tests/pretty/snapshot.lqp
+++ b/tests/pretty/snapshot.lqp
@@ -5,9 +5,9 @@
       (define
         (fragment
           :snapshots
-          (rel_edb :snapshot1 ["my_edb"] [])
-          (rel_edb :snapshot2 ["database" "table"] [])
-          (rel_edb :snapshot3 ["schema" "namespace" "relation"] [])))
+          (edb :snapshot1 ["my_edb"] [])
+          (edb :snapshot2 ["database" "table"] [])
+          (edb :snapshot3 ["schema" "namespace" "relation"] [])))
       (define
         (fragment
           :frag1
@@ -41,9 +41,10 @@
       (output :snapshot3 :snapshot3)))
   (epoch
     (writes
-      (snapshot ["my_edb"] :my_rel)
-      (snapshot ["database" "table"] :computed)
-      (snapshot ["schema" "namespace" "relation"] :big_signed))
+      (snapshot
+        ["my_edb"] :my_rel
+        ["database" "table"] :computed
+        ["schema" "namespace" "relation"] :big_signed))
     (reads
       (output :snapshot1 :snapshot1)
       (output :snapshot2 :snapshot2)
diff --git a/tests/pretty_debug/cdc.lqp b/tests/pretty_debug/cdc.lqp
new file mode 100644
index 00000000..14da99d1
--- /dev/null
+++ b/tests/pretty_debug/cdc.lqp
@@ -0,0 +1,48 @@
+(transaction
+  (configure { :ivm.maintenance_level "off" :semantics_version 0})
+  (epoch
+    (writes
+      (define
+        (fragment
+          :f1
+          (csv_data
+            (csv_locator (paths "s3://bucket/cdc/batch_001.csv"))
+            (csv_config
+              {
+               :csv_compression "auto"
+               :csv_decimal_separator "."
+               :csv_delimiter ","
+               :csv_encoding "utf-8"
+               :csv_escapechar "\""
+               :csv_header_row 1
+               :csv_quotechar "\""
+               :csv_skip 0})
+            (columns
+              (column "raw_data" [])
+              (column ["append" "METADATA$KEY"] 0xb7219c9b1f7d843d [UINT128])
+              (column ["delete" "METADATA$KEY"] 0xc45b4cf618eed32f [UINT128])
+              (column ["append" "user_id"] 0x7982cff88800e869 [INT])
+              (column ["append" "name"] 0x8cb6c4889f2f67c7 [STRING])
+              (column "id" 0x5364bf081a053f95 [INT])
+              (column ["append" "id"] 0x22d32663113e8a7d [INT])
+              (column ["delete" "id"] 0x337b9038b6bf2f6a [INT]))
+            (asof "2025-06-01T00:00:00Z")))))
+    (reads
+      (output :mk_ins 0xb7219c9b1f7d843d)
+      (output :mk_del 0xc45b4cf618eed32f)
+      (output :uid_ins 0x7982cff88800e869)
+      (output :name_ins 0x8cb6c4889f2f67c7)
+      (output :entity_id 0x5364bf081a053f95)
+      (output :eid_ins 0x22d32663113e8a7d)
+      (output :eid_del 0x337b9038b6bf2f6a))))
+
+;; Debug information
+;; -----------------------
+;; Original names
+;; 	 ID `0x337b9038b6bf2f6a` -> `eid_del`
+;; 	 ID `0x22d32663113e8a7d` -> `eid_ins`
+;; 	 ID `0x5364bf081a053f95` -> `entity_id`
+;; 	 ID `0xc45b4cf618eed32f` -> `mk_del`
+;; 	 ID `0xb7219c9b1f7d843d` -> `mk_ins`
+;; 	 ID `0x8cb6c4889f2f67c7` -> `name_ins`
+;; 	 ID `0x7982cff88800e869` -> `uid_ins`
diff --git a/tests/pretty_debug/edb.lqp b/tests/pretty_debug/edb.lqp
index b15872f3..f56235d6 100644
--- a/tests/pretty_debug/edb.lqp
+++ b/tests/pretty_debug/edb.lqp
@@ -83,10 +83,10 @@
                :betree_locator_element_count 10
                :betree_locator_root_pageid 0x7777888899990000111122
                :betree_locator_tree_height 1}))
-          (rel_edb 0x15840b06a27cfd50 ["my_base_relation"] [INT STRING FLOAT])
-          (rel_edb 0xd18eb5ae6b1c6d60 ["another" "path"] [INT STRING])
-          (rel_edb 0x1d55ba4ed7a92d94 ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
-          (rel_edb 0xce18a64a245dea33 ["empty_path"] [])
+          (edb 0x15840b06a27cfd50 ["my_base_relation"] [INT STRING FLOAT])
+          (edb 0xd18eb5ae6b1c6d60 ["another" "path"] [INT STRING])
+          (edb 0x1d55ba4ed7a92d94 ["complex" "path" "here"] [(DECIMAL 10 2) INT STRING])
+          (edb 0xce18a64a245dea33 ["empty_path"] [])
           (def 0x2c26b46b68ffc68f ([x::INT] (= x 1)))
           (algorithm
             0xfcde2b2edba56bf4
diff --git a/tests/pretty_debug/snapshot.lqp b/tests/pretty_debug/snapshot.lqp
index 88f2f930..8fd02249 100644
--- a/tests/pretty_debug/snapshot.lqp
+++ b/tests/pretty_debug/snapshot.lqp
@@ -5,9 +5,9 @@
       (define
         (fragment
           :snapshots
-          (rel_edb 0xcd3b9ab2de079088 ["my_edb"] [])
-          (rel_edb 0xd1e6d3706be27c8 ["database" "table"] [])
-          (rel_edb 0xc6e65c9a8c481ef1 ["schema" "namespace" "relation"] [])))
+          (edb 0xcd3b9ab2de079088 ["my_edb"] [])
+          (edb 0xd1e6d3706be27c8 ["database" "table"] [])
+          (edb 0xc6e65c9a8c481ef1 ["schema" "namespace" "relation"] [])))
       (define
         (fragment
           :frag1
@@ -44,9 +44,10 @@
       (output :snapshot3 0xc6e65c9a8c481ef1)))
   (epoch
     (writes
-      (snapshot ["my_edb"] 0xaacb662458c1cddb)
-      (snapshot ["database" "table"] 0x5aa562409c66b3b3)
-      (snapshot ["schema" "namespace" "relation"] 0xca186c6bd1825179))
+      (snapshot
+        ["my_edb"] 0xaacb662458c1cddb
+        ["database" "table"] 0x5aa562409c66b3b3
+        ["schema" "namespace" "relation"] 0xca186c6bd1825179))
     (reads
       (output :snapshot1 0xcd3b9ab2de079088)
       (output :snapshot2 0xd1e6d3706be27c8)