diff --git a/pkg/mimirpb/compat.go b/pkg/mimirpb/compat.go
index 922d3058bfe..db83601361b 100644
--- a/pkg/mimirpb/compat.go
+++ b/pkg/mimirpb/compat.go
@@ -30,7 +30,7 @@ import (
 // method implies that only a single sample and optionally exemplar can be set for each series.
 //
 // For histograms use NewWriteRequest and Add* functions to build write request with Floats and Histograms
-func ToWriteRequest(lbls [][]mimirpb_custom.LabelAdapter, samples []Sample, exemplars []*Exemplar, metadata []*MetricMetadata, source WriteRequest_SourceEnum) *WriteRequest {
+func ToWriteRequest(lbls [][]*mimirpb_custom.LabelAdapter, samples []*Sample, exemplars []*Exemplar, metadata []*MetricMetadata, source WriteRequest_SourceEnum) *WriteRequest {
 	return NewWriteRequest(metadata, source).AddFloatSeries(lbls, samples, exemplars)
 }
 
@@ -46,7 +46,7 @@ func NewWriteRequest(metadata []*MetricMetadata, source WriteRequest_SourceEnum)
 // AddFloatSeries converts matched slices of Labels, Samples, Exemplars into a WriteRequest
 // proto. It gets timeseries from the pool, so ReuseSlice() should be called when done. Note that this
 // method implies that only a single sample and optionally exemplar can be set for each series.
-func (req *WriteRequest) AddFloatSeries(lbls [][]mimirpb_custom.LabelAdapter, samples []Sample, exemplars []*Exemplar) *WriteRequest {
+func (req *WriteRequest) AddFloatSeries(lbls [][]*mimirpb_custom.LabelAdapter, samples []*Sample, exemplars []*Exemplar) *WriteRequest {
 	for i, s := range samples {
 		ts := TimeseriesFromPool()
 		ts.Labels = append(ts.Labels, lbls[i]...)
@@ -56,7 +56,7 @@ func (req *WriteRequest) AddFloatSeries(lbls [][]mimirpb_custom.LabelAdapter, sa
 			// If provided, we expect a matched entry for exemplars (like labels and samples) but the
 			// entry may be nil since not every timeseries is guaranteed to have an exemplar.
 			if e := exemplars[i]; e != nil {
-				ts.Exemplars = append(ts.Exemplars, *e)
+				ts.Exemplars = append(ts.Exemplars, e)
 			}
 		}
 
@@ -68,7 +68,7 @@ func (req *WriteRequest) AddFloatSeries(lbls [][]mimirpb_custom.LabelAdapter, sa
 // AddHistogramSeries converts matched slices of Labels, Histograms, Exemplars into a WriteRequest
 // proto. It gets timeseries from the pool, so ReuseSlice() should be called when done. Note that this
 // method implies that only a single sample and optionally exemplar can be set for each series.
-func (req *WriteRequest) AddHistogramSeries(lbls [][]mimirpb_custom.LabelAdapter, histograms []Histogram, exemplars []*Exemplar) *WriteRequest {
+func (req *WriteRequest) AddHistogramSeries(lbls [][]*mimirpb_custom.LabelAdapter, histograms []*Histogram, exemplars []*Exemplar) *WriteRequest {
 	for i, s := range histograms {
 		ts := TimeseriesFromPool()
 		ts.Labels = append(ts.Labels, lbls[i]...)
@@ -78,7 +78,7 @@ func (req *WriteRequest) AddHistogramSeries(lbls [][]mimirpb_custom.LabelAdapter
 			// If provided, we expect a matched entry for exemplars (like labels and samples) but the
 			// entry may be nil since not every timeseries is guaranteed to have an exemplar.
 			if e := exemplars[i]; e != nil {
-				ts.Exemplars = append(ts.Exemplars, *e)
+				ts.Exemplars = append(ts.Exemplars, e)
 			}
 		}
 
@@ -93,7 +93,7 @@ func (req *WriteRequest) AddHistogramSeries(lbls [][]mimirpb_custom.LabelAdapter
 // to be added per time series for simplicity.
 func (req *WriteRequest) AddExemplarsAt(i int, exemplars []*Exemplar) *WriteRequest {
 	for _, e := range exemplars {
-		req.Timeseries[i].Exemplars = append(req.Timeseries[i].Exemplars, *e)
+		req.Timeseries[i].Exemplars = append(req.Timeseries[i].Exemplars, e)
 	}
 	return req
 }
@@ -598,7 +598,7 @@ type PreallocatingMetric struct {
 func (m *PreallocatingMetric) Unmarshal(dAtA []byte) error {
 	numLabels, ok := m.labelsCount(dAtA)
 	if ok && numLabels > 0 {
-		m.Labels = make([]mimirpb_custom.LabelAdapter, 0, numLabels)
+		m.Labels = make([]*mimirpb_custom.LabelAdapter, 0, numLabels)
 	}
 
 	return m.Metric.Unmarshal(dAtA)
diff --git a/pkg/mimirpb/compat_slice.go b/pkg/mimirpb/compat_slice.go
index 2e815cc447a..0746ac167a5 100644
--- a/pkg/mimirpb/compat_slice.go
+++ b/pkg/mimirpb/compat_slice.go
@@ -21,19 +21,23 @@ import (
 //
 // Note: while resulting labels.Labels is supposedly sorted, this function
 // doesn't enforce that. If input is not sorted, output will be wrong.
-func FromLabelAdaptersToLabels(ls []mimirpb_custom.LabelAdapter) labels.Labels {
-	return *(*labels.Labels)(unsafe.Pointer(&ls))
+func FromLabelAdaptersToLabels(ls []*mimirpb_custom.LabelAdapter) labels.Labels {
+	out := make(labels.Labels, len(ls))
+	for i := range ls {
+		out[i] = *(*labels.Label)(unsafe.Pointer(ls[i])) // Dereferencing and converting safely
+	}
+	return out
 }
 
 // This is like FromLabelAdaptersToLabels but easier for stringlabels to implement.
-func FromLabelAdaptersOverwriteLabels(_ *labels.ScratchBuilder, ls []mimirpb_custom.LabelAdapter, dest *labels.Labels) {
+func FromLabelAdaptersOverwriteLabels(_ *labels.ScratchBuilder, ls []*mimirpb_custom.LabelAdapter, dest *labels.Labels) {
 	*dest = FromLabelAdaptersToLabels(ls)
 }
 
 // FromLabelAdaptersToLabelsWithCopy converts []LabelAdapter to labels.Labels.
 // Do NOT use unsafe to convert between data types because this function may
 // get in input labels whose data structure is reused.
-func FromLabelAdaptersToLabelsWithCopy(input []mimirpb_custom.LabelAdapter) labels.Labels {
+func FromLabelAdaptersToLabelsWithCopy(input []*mimirpb_custom.LabelAdapter) labels.Labels {
 	return CopyLabels(FromLabelAdaptersToLabels(input))
 }
 
@@ -72,23 +76,27 @@ func copyStringToBuffer(in string, buf []byte) (string, []byte) {
 }
 
 // FromLabelAdaptersToBuilder converts []LabelAdapter to labels.Builder.
-func FromLabelAdaptersToBuilder(ls []mimirpb_custom.LabelAdapter, builder *labels.Builder) {
+func FromLabelAdaptersToBuilder(ls []*mimirpb_custom.LabelAdapter, builder *labels.Builder) {
 	builder.Reset(FromLabelAdaptersToLabels(ls))
 }
 
 // FromBuilderToLabelAdapters converts labels.Builder to []LabelAdapter.
-func FromBuilderToLabelAdapters(builder *labels.Builder, _ []mimirpb_custom.LabelAdapter) []mimirpb_custom.LabelAdapter {
+func FromBuilderToLabelAdapters(builder *labels.Builder, _ []*mimirpb_custom.LabelAdapter) []*mimirpb_custom.LabelAdapter {
 	return FromLabelsToLabelAdapters(builder.Labels())
 }
 
-// FromLabelsToLabelAdapters casts labels.Labels to []LabelAdapter.
-// It uses unsafe, but as LabelAdapter == labels.Label this should be safe.
-// This allows us to use labels.Labels directly in protos.
-func FromLabelsToLabelAdapters(ls labels.Labels) []mimirpb_custom.LabelAdapter {
-	return *(*[]mimirpb_custom.LabelAdapter)(unsafe.Pointer(&ls))
+// FromLabelsToLabelAdapters converts labels.Labels to []*LabelAdapter.
+// This avoids unsafe operations and ensures correctness.
+func FromLabelsToLabelAdapters(ls labels.Labels) []*mimirpb_custom.LabelAdapter {
+	adapters := make([]*mimirpb_custom.LabelAdapter, len(ls))
+	for i := range ls {
+		// Cast each Label to LabelAdapter and take the address
+		adapters[i] = (*mimirpb_custom.LabelAdapter)(unsafe.Pointer(&ls[i]))
+	}
+	return adapters
 }
 
 // CompareLabelAdapters returns 0 if a==b, <0 if a < b, and >0 if a > b.
-func CompareLabelAdapters(a, b []mimirpb_custom.LabelAdapter) int {
+func CompareLabelAdapters(a, b []*mimirpb_custom.LabelAdapter) int {
 	return labels.Compare(FromLabelAdaptersToLabels(a), FromLabelAdaptersToLabels(b))
 }
diff --git a/pkg/mimirpb/compat_test.go b/pkg/mimirpb/compat_test.go
index f1c1fd8d91f..a626416b872 100644
--- a/pkg/mimirpb/compat_test.go
+++ b/pkg/mimirpb/compat_test.go
@@ -180,7 +180,7 @@ func TestMetricMetadataToMetricTypeToMetricType(t *testing.T) {
 }
 
 func TestFromLabelAdaptersToLabels(t *testing.T) {
-	input := []mimirpb_custom.LabelAdapter{{Name: "hello", Value: "world"}}
+	input := []*mimirpb_custom.LabelAdapter{{Name: "hello", Value: "world"}}
 	expected := labels.FromStrings("hello", "world")
 	actual := FromLabelAdaptersToLabels(input)
 
@@ -188,7 +188,7 @@ func TestFromLabelAdaptersToLabels(t *testing.T) {
 }
 
 func TestFromLabelAdaptersToLabelsWithCopy(t *testing.T) {
-	input := []mimirpb_custom.LabelAdapter{{Name: "hello", Value: "world"}}
+	input := []*mimirpb_custom.LabelAdapter{{Name: "hello", Value: "world"}}
 	expected := labels.FromStrings("hello", "world")
 	actual := FromLabelAdaptersToLabelsWithCopy(input)
 
@@ -200,7 +200,7 @@ func TestFromLabelAdaptersToLabelsWithCopy(t *testing.T) {
 }
 
 func BenchmarkFromLabelAdaptersToLabelsWithCopy(b *testing.B) {
-	input := []mimirpb_custom.LabelAdapter{
+	input := []*mimirpb_custom.LabelAdapter{
 		{Name: "hello", Value: "world"},
 		{Name: "some label", Value: "and its value"},
 		{Name: "long long long long long label name", Value: "perhaps even longer label value, but who's counting anyway?"}}
@@ -266,7 +266,7 @@ func BenchmarkFromHPointsToHistograms(b *testing.B) {
 func TestPreallocatingMetric(t *testing.T) {
 	t.Run("should be unmarshallable from the bytes of a default Metric", func(t *testing.T) {
 		metric := Metric{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "l1", Value: "v1"},
 				{Name: "l2", Value: "v2"},
 				{Name: "l3", Value: "v3"},
@@ -290,7 +290,7 @@ func TestPreallocatingMetric(t *testing.T) {
 
 	t.Run("should correctly preallocate Labels slice", func(t *testing.T) {
 		metric := Metric{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "l1", Value: "v1"},
 				{Name: "l2", Value: "v2"},
 				{Name: "l3", Value: "v3"},
@@ -311,7 +311,7 @@ func TestPreallocatingMetric(t *testing.T) {
 
 	t.Run("should not allocate a slice when there are 0 Labels (same as Metric's behaviour)", func(t *testing.T) {
 		metric := Metric{
-			Labels: []mimirpb_custom.LabelAdapter{},
+			Labels: []*mimirpb_custom.LabelAdapter{},
 		}
 
 		metricBytes, err := metric.Marshal()
@@ -325,7 +325,7 @@ func TestPreallocatingMetric(t *testing.T) {
 
 	t.Run("should marshal to the same bytes as Metric", func(t *testing.T) {
 		preallocMetric := &PreallocatingMetric{Metric{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "l1", Value: "v1"},
 				{Name: "l2", Value: "v2"},
 				{Name: "l3", Value: "v3"},
@@ -335,7 +335,7 @@ func TestPreallocatingMetric(t *testing.T) {
 		}}
 
 		metric := Metric{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "l1", Value: "v1"},
 				{Name: "l2", Value: "v2"},
 				{Name: "l3", Value: "v3"},
@@ -643,65 +643,65 @@ func TestPrometheusHistogramSpanInSyncWithMimirPbBucketSpan(_ *testing.T) {
 }
 
 func TestCompareLabelAdapters(t *testing.T) {
-	labels := []mimirpb_custom.LabelAdapter{
+	labels := []*mimirpb_custom.LabelAdapter{
 		{Name: "aaa", Value: "111"},
 		{Name: "bbb", Value: "222"},
 	}
 
 	tests := []struct {
-		compared []mimirpb_custom.LabelAdapter
+		compared []*mimirpb_custom.LabelAdapter
 		expected int
 	}{
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "110"},
 				{Name: "bbb", Value: "222"},
 			},
 			expected: 1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bbb", Value: "233"},
 			},
 			expected: -1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bar", Value: "222"},
 			},
 			expected: 1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bbc", Value: "222"},
 			},
 			expected: -1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bb", Value: "222"},
 			},
 			expected: 1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bbbb", Value: "222"},
 			},
 			expected: -1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 			},
 			expected: 1,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bbb", Value: "222"},
 				{Name: "ccc", Value: "333"},
@@ -710,14 +710,14 @@ func TestCompareLabelAdapters(t *testing.T) {
 			expected: -2,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{
+			compared: []*mimirpb_custom.LabelAdapter{
 				{Name: "aaa", Value: "111"},
 				{Name: "bbb", Value: "222"},
 			},
 			expected: 0,
 		},
 		{
-			compared: []mimirpb_custom.LabelAdapter{},
+			compared: []*mimirpb_custom.LabelAdapter{},
 			expected: 1,
 		},
 	}
diff --git a/pkg/mimirpb/custom_test.go b/pkg/mimirpb/custom_test.go
index 491b8358fdf..7273267a26a 100644
--- a/pkg/mimirpb/custom_test.go
+++ b/pkg/mimirpb/custom_test.go
@@ -16,27 +16,27 @@ import (
 func TestWriteRequest_MinTimestamp(t *testing.T) {
 	req := &WriteRequest{
 		Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-			Samples:    []Sample{{TimestampMs: 10}},
-			Exemplars:  []Exemplar{{TimestampMs: 20}},
-			Histograms: []Histogram{{Timestamp: 30}},
+			Samples:    []*Sample{{TimestampMs: 10}},
+			Exemplars:  []*Exemplar{{TimestampMs: 20}},
+			Histograms: []*Histogram{{Timestamp: 30}},
 		}}},
 	}
 	assert.Equal(t, int64(10), req.MinTimestamp())
 
 	req = &WriteRequest{
 		Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-			Samples:    []Sample{{TimestampMs: 20}},
-			Exemplars:  []Exemplar{{TimestampMs: 10}},
-			Histograms: []Histogram{{Timestamp: 30}},
+			Samples:    []*Sample{{TimestampMs: 20}},
+			Exemplars:  []*Exemplar{{TimestampMs: 10}},
+			Histograms: []*Histogram{{Timestamp: 30}},
 		}}},
 	}
 	assert.Equal(t, int64(10), req.MinTimestamp())
 
 	req = &WriteRequest{
 		Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-			Samples:    []Sample{{TimestampMs: 20}},
-			Exemplars:  []Exemplar{{TimestampMs: 30}},
-			Histograms: []Histogram{{Timestamp: 10}},
+			Samples:    []*Sample{{TimestampMs: 20}},
+			Exemplars:  []*Exemplar{{TimestampMs: 30}},
+			Histograms: []*Histogram{{Timestamp: 10}},
 		}}},
 	}
 	assert.Equal(t, int64(10), req.MinTimestamp())
@@ -46,7 +46,7 @@ func TestWriteRequest_IsEmpty(t *testing.T) {
 	t.Run("should return false if a WriteRequest has both Timeseries and Metadata", func(t *testing.T) {
 		req := &WriteRequest{
 			Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-				Samples: []Sample{{TimestampMs: 20}},
+				Samples: []*Sample{{TimestampMs: 20}},
 			}}},
 			Metadata: []*MetricMetadata{
 				{Type: COUNTER, MetricFamilyName: "test_metric", Help: "This is a test metric."},
@@ -59,7 +59,7 @@ func TestWriteRequest_IsEmpty(t *testing.T) {
 	t.Run("should return false if a WriteRequest has only Timeseries", func(t *testing.T) {
 		req := &WriteRequest{
 			Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-				Samples: []Sample{{TimestampMs: 20}},
+				Samples: []*Sample{{TimestampMs: 20}},
 			}}},
 		}
 
@@ -89,9 +89,9 @@ func TestWriteRequest_IsEmpty(t *testing.T) {
 func TestWriteRequest_MetadataSize_TimeseriesSize(t *testing.T) {
 	req := &WriteRequest{
 		Timeseries: []PreallocTimeseries{{TimeSeries: &TimeSeries{
-			Samples:    []Sample{{TimestampMs: 20}},
-			Exemplars:  []Exemplar{{TimestampMs: 30}},
-			Histograms: []Histogram{{Timestamp: 10}},
+			Samples:    []*Sample{{TimestampMs: 20}},
+			Exemplars:  []*Exemplar{{TimestampMs: 30}},
+			Histograms: []*Histogram{{Timestamp: 10}},
 		}}},
 		Metadata: []*MetricMetadata{
 			{Type: COUNTER, MetricFamilyName: "test_metric", Help: "This is a test metric."},
diff --git a/pkg/mimirpb/mimir.pb.go b/pkg/mimirpb/mimir.pb.go
index c2385621b17..41eb62857cc 100644
--- a/pkg/mimirpb/mimir.pb.go
+++ b/pkg/mimirpb/mimir.pb.go
@@ -387,11 +387,11 @@ func (m *ErrorDetails) GetCause() ErrorCause {
 }
 
 type TimeSeries struct {
-	Labels []mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
+	Labels []*mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
 	// Sorted by time, oldest sample first.
-	Samples    []Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
-	Exemplars  []Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars"`
-	Histograms []Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms"`
+	Samples    []*Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples,omitempty"`
+	Exemplars  []*Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars,omitempty"`
+	Histograms []*Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms,omitempty"`
 
 	// Skip unmarshaling of exemplars.
 	SkipUnmarshalingExemplars bool
@@ -429,28 +429,28 @@ func (m *TimeSeries) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_TimeSeries proto.InternalMessageInfo
 
-func (m *TimeSeries) GetLabels() []mimirpb_custom.LabelAdapter {
+func (m *TimeSeries) GetLabels() []*mimirpb_custom.LabelAdapter {
 	if m != nil {
 		return m.Labels
 	}
 	return nil
 }
 
-func (m *TimeSeries) GetSamples() []Sample {
+func (m *TimeSeries) GetSamples() []*Sample {
 	if m != nil {
 		return m.Samples
 	}
 	return nil
 }
 
-func (m *TimeSeries) GetExemplars() []Exemplar {
+func (m *TimeSeries) GetExemplars() []*Exemplar {
 	if m != nil {
 		return m.Exemplars
 	}
 	return nil
 }
 
-func (m *TimeSeries) GetHistograms() []Histogram {
+func (m *TimeSeries) GetHistograms() []*Histogram {
 	if m != nil {
 		return m.Histograms
 	}
@@ -577,7 +577,7 @@ func (m *MetricMetadata) GetUnit() string {
 }
 
 type Metric struct {
-	Labels []mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
+	Labels []*mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
 }
 
 func (m *Metric) Reset()      { *m = Metric{} }
@@ -612,7 +612,7 @@ func (m *Metric) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Metric proto.InternalMessageInfo
 
-func (m *Metric) GetLabels() []mimirpb_custom.LabelAdapter {
+func (m *Metric) GetLabels() []*mimirpb_custom.LabelAdapter {
 	if m != nil {
 		return m.Labels
 	}
@@ -621,9 +621,9 @@ func (m *Metric) GetLabels() []mimirpb_custom.LabelAdapter {
 
 type Exemplar struct {
 	// Exemplar labels, different than series labels
-	Labels      []mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
-	Value       float64                       `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
-	TimestampMs int64                         `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
+	Labels      []*mimirpb_custom.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
+	Value       float64                        `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
+	TimestampMs int64                          `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
 }
 
 func (m *Exemplar) Reset()      { *m = Exemplar{} }
@@ -658,7 +658,7 @@ func (m *Exemplar) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Exemplar proto.InternalMessageInfo
 
-func (m *Exemplar) GetLabels() []mimirpb_custom.LabelAdapter {
+func (m *Exemplar) GetLabels() []*mimirpb_custom.LabelAdapter {
 	if m != nil {
 		return m.Labels
 	}
@@ -1894,135 +1894,135 @@ func init() {
 func init() { proto.RegisterFile("mimir.proto", fileDescriptor_86d4d7485f544059) }
 
 var fileDescriptor_86d4d7485f544059 = []byte{
-	// 2033 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x93, 0xdb, 0x48,
-	0x15, 0xb7, 0x6c, 0x8d, 0x6d, 0xbd, 0xb1, 0x67, 0x3a, 0x9d, 0x6c, 0xf0, 0x0e, 0x1b, 0x27, 0xab,
-	0x2d, 0x96, 0x21, 0x05, 0x13, 0x6a, 0x43, 0x65, 0x6b, 0x43, 0xf8, 0x90, 0x6d, 0x25, 0xe3, 0xac,
-	0x2d, 0xcf, 0xb6, 0xe4, 0x84, 0x70, 0x51, 0x69, 0x3c, 0x3d, 0x33, 0xaa, 0x58, 0x92, 0x91, 0xe4,
-	0x6c, 0xc2, 0x69, 0x2f, 0x54, 0x51, 0x9c, 0xb8, 0x70, 0xa1, 0xb8, 0x71, 0xa1, 0x8a, 0x7f, 0x24,
-	0x55, 0x5c, 0x72, 0x5c, 0x38, 0xa4, 0xc8, 0xe4, 0xb2, 0x1c, 0xa0, 0xb6, 0x38, 0x72, 0xa2, 0xba,
-	0x5b, 0x9f, 0x9e, 0x09, 0x04, 0xb2, 0x37, 0xbd, 0xf7, 0x7e, 0xaf, 0xfb, 0xa7, 0x7e, 0x1f, 0x7a,
-	0x2d, 0x58, 0xf7, 0x5c, 0xcf, 0x0d, 0x77, 0x16, 0x61, 0x10, 0x07, 0xb8, 0x39, 0x0b, 0xc2, 0x98,
-	0x3e, 0x5e, 0xec, 0x6f, 0x7d, 0xe7, 0xc8, 0x8d, 0x8f, 0x97, 0xfb, 0x3b, 0xb3, 0xc0, 0xbb, 0x76,
-	0x14, 0x1c, 0x05, 0xd7, 0x38, 0x60, 0x7f, 0x79, 0xc8, 0x25, 0x2e, 0xf0, 0x27, 0xe1, 0xb8, 0x35,
-	0x28, 0xc2, 0x43, 0xe7, 0xd0, 0xf1, 0x9d, 0x6b, 0x7c, 0xe1, 0x6b, 0x8b, 0x87, 0x47, 0xe2, 0x69,
-	0xb1, 0x6f, 0xcf, 0x96, 0x51, 0x1c, 0x78, 0x42, 0x4c, 0x04, 0x3b, 0x7e, 0xb2, 0xa0, 0x91, 0x58,
-	0x45, 0xfd, 0x7b, 0x15, 0x5a, 0xf7, 0x43, 0x37, 0xa6, 0x84, 0xfe, 0x6c, 0x49, 0xa3, 0x18, 0xef,
-	0x01, 0xc4, 0xae, 0x47, 0x23, 0x1a, 0xba, 0x34, 0xea, 0x48, 0x57, 0x6a, 0xdb, 0xeb, 0x1f, 0x5c,
-	0xd8, 0x49, 0x49, 0xee, 0x58, 0xae, 0x47, 0x4d, 0x6e, 0xeb, 0x6d, 0x3d, 0x7d, 0x7e, 0xb9, 0xf2,
-	0x97, 0xe7, 0x97, 0xf1, 0x5e, 0x48, 0x9d, 0xf9, 0x3c, 0x98, 0x59, 0x99, 0x1f, 0x29, 0xac, 0x81,
-	0x3f, 0x82, 0xba, 0x19, 0x2c, 0xc3, 0x19, 0xed, 0x54, 0xaf, 0x48, 0xdb, 0x1b, 0x1f, 0xbc, 0x9b,
-	0xaf, 0x56, 0xdc, 0x79, 0x47, 0x80, 0x74, 0x7f, 0xe9, 0x91, 0xc4, 0x01, 0xdf, 0x84, 0xa6, 0x47,
-	0x63, 0xe7, 0xc0, 0x89, 0x9d, 0x4e, 0x8d, 0x53, 0xe9, 0xe4, 0xce, 0x63, 0x1a, 0x87, 0xee, 0x6c,
-	0x9c, 0xd8, 0x7b, 0xf2, 0xd3, 0xe7, 0x97, 0x25, 0x92, 0xe1, 0xf1, 0x75, 0x78, 0x2b, 0x7a, 0xe8,
-	0x2e, 0xec, 0xb9, 0xb3, 0x4f, 0xe7, 0xf6, 0x23, 0x67, 0xee, 0x1e, 0x38, 0xb1, 0x1b, 0xf8, 0x9d,
-	0x2f, 0x1a, 0x57, 0xa4, 0xed, 0x26, 0x39, 0xcf, 0xac, 0x23, 0x66, 0xbc, 0x97, 0xd9, 0xf0, 0x0f,
-	0xe1, 0xeb, 0x05, 0xa7, 0x59, 0xb0, 0xf4, 0xe3, 0xa2, 0xeb, 0xdf, 0x84, 0x6b, 0x27, 0x73, 0xed,
-	0x33, 0x44, 0xee, 0xaf, 0x5e, 0x06, 0xc8, 0x5f, 0x03, 0x37, 0xa0, 0xa6, 0xed, 0x0d, 0x51, 0x05,
-	0x37, 0x41, 0x26, 0xd3, 0x91, 0x8e, 0x24, 0x75, 0x13, 0xda, 0xc9, 0x4b, 0x47, 0x8b, 0xc0, 0x8f,
-	0xa8, 0x7a, 0x13, 0x5a, 0x7a, 0x18, 0x06, 0xe1, 0x80, 0xc6, 0x8e, 0x3b, 0x8f, 0xf0, 0x55, 0x58,
-	0xeb, 0x3b, 0xcb, 0x88, 0x76, 0x24, 0x7e, 0x58, 0x85, 0xa3, 0xe7, 0x30, 0x6e, 0x23, 0x02, 0xa2,
-	0xfe, 0x43, 0x02, 0xc8, 0x03, 0x82, 0xbf, 0x0f, 0x75, 0xce, 0x3b, 0x0d, 0xdb, 0xa5, 0xcc, 0x37,
-	0x89, 0xfc, 0x0e, 0xe7, 0xac, 0x1d, 0x38, 0x8b, 0x98, 0x86, 0xfc, 0xc0, 0x2a, 0x24, 0x71, 0xc1,
-	0xdf, 0x85, 0x46, 0xe4, 0x78, 0x8b, 0x39, 0x8d, 0x3a, 0x55, 0xee, 0x8d, 0xf2, 0x9d, 0x4d, 0x6e,
-	0x48, 0x1c, 0x52, 0x18, 0xbe, 0x01, 0x0a, 0x7d, 0x4c, 0xbd, 0xc5, 0xdc, 0x09, 0xa3, 0x24, 0x3a,
-	0xb8, 0xc0, 0x36, 0x31, 0x25, 0x5e, 0x39, 0x14, 0x7f, 0x04, 0x70, 0xec, 0x46, 0x71, 0x70, 0x14,
-	0x3a, 0x5e, 0xd4, 0x91, 0xb9, 0xe3, 0xf9, 0xdc, 0x71, 0x37, 0xb5, 0x25, 0x9e, 0x05, 0xb0, 0xaa,
-	0x41, 0x5d, 0x70, 0xc1, 0xef, 0x42, 0x8b, 0xa7, 0x58, 0xec, 0x78, 0x0b, 0xdb, 0x8b, 0x78, 0x6a,
-	0xd5, 0xc8, 0x7a, 0xa6, 0x1b, 0x47, 0xf8, 0x02, 0xac, 0x3d, 0x72, 0xe6, 0x4b, 0x71, 0x92, 0x12,
-	0x11, 0x82, 0xfa, 0xdb, 0x2a, 0x6c, 0x94, 0x33, 0x07, 0x7f, 0x08, 0x32, 0x2b, 0x89, 0xe4, 0xc4,
-	0xdf, 0x7b, 0x55, 0x86, 0x25, 0xa2, 0xf5, 0x64, 0x41, 0x09, 0x77, 0xc0, 0xdf, 0x06, 0xec, 0x71,
-	0x9d, 0x7d, 0xe8, 0x78, 0xee, 0xfc, 0x89, 0xed, 0x3b, 0x9e, 0xc8, 0x72, 0x85, 0x20, 0x61, 0xb9,
-	0xcd, 0x0d, 0x86, 0xe3, 0x51, 0x8c, 0x41, 0x3e, 0xa6, 0xf3, 0x45, 0x47, 0xe6, 0x76, 0xfe, 0xcc,
-	0x74, 0x4b, 0xdf, 0x8d, 0x3b, 0x6b, 0x42, 0xc7, 0x9e, 0xd5, 0x27, 0x00, 0xf9, 0x4e, 0x78, 0x1d,
-	0x1a, 0x53, 0xe3, 0x63, 0x63, 0x72, 0xdf, 0x40, 0x15, 0x26, 0xf4, 0x27, 0x53, 0xc3, 0xd2, 0x09,
-	0x92, 0xb0, 0x02, 0x6b, 0x77, 0xb4, 0xe9, 0x1d, 0x1d, 0x55, 0x71, 0x1b, 0x94, 0xdd, 0xa1, 0x69,
-	0x4d, 0xee, 0x10, 0x6d, 0x8c, 0x6a, 0x18, 0xc3, 0x06, 0xb7, 0xe4, 0x3a, 0x99, 0xb9, 0x9a, 0xd3,
-	0xf1, 0x58, 0x23, 0x0f, 0xd0, 0x1a, 0xcb, 0xc7, 0xa1, 0x71, 0x7b, 0x82, 0xea, 0xb8, 0x05, 0x4d,
-	0xd3, 0xd2, 0x2c, 0xdd, 0xd4, 0x2d, 0xd4, 0x50, 0x75, 0xa8, 0x8b, 0xad, 0xdf, 0x28, 0x97, 0xd4,
-	0xcf, 0x24, 0x68, 0xa6, 0xf1, 0x7f, 0xb3, 0xac, 0xcc, 0x62, 0x58, 0x2d, 0xc4, 0xf0, 0x54, 0xf0,
-	0x6b, 0xa7, 0x82, 0xaf, 0xfe, 0x69, 0x0d, 0x94, 0x2c, 0x93, 0xf0, 0x25, 0x50, 0x44, 0x2d, 0xbb,
-	0x7e, 0xcc, 0xc3, 0x2c, 0xef, 0x56, 0x48, 0x93, 0xab, 0x86, 0x7e, 0x8c, 0xdf, 0x85, 0x75, 0x61,
-	0x3e, 0x9c, 0x07, 0x4e, 0x2c, 0xf6, 0xda, 0xad, 0x10, 0xe0, 0xca, 0xdb, 0x4c, 0x87, 0x11, 0xd4,
-	0xa2, 0xa5, 0xc7, 0x77, 0x92, 0x08, 0x7b, 0xc4, 0x17, 0xa1, 0x1e, 0xcd, 0x8e, 0xa9, 0xe7, 0xf0,
-	0x80, 0x9e, 0x23, 0x89, 0x84, 0xbf, 0x01, 0x1b, 0x3f, 0xa7, 0x61, 0x60, 0xc7, 0xc7, 0x21, 0x8d,
-	0x8e, 0x83, 0xf9, 0x01, 0x0f, 0xae, 0x44, 0xda, 0x4c, 0x6b, 0xa5, 0x4a, 0xfc, 0x7e, 0x02, 0xcb,
-	0x79, 0xd5, 0x39, 0x2f, 0x89, 0xb4, 0x98, 0xbe, 0x9f, 0x72, 0xbb, 0x0a, 0xa8, 0x80, 0x13, 0x04,
-	0x1b, 0x9c, 0xa0, 0x44, 0x36, 0x32, 0xa4, 0x20, 0xa9, 0xc1, 0x86, 0x4f, 0x8f, 0x9c, 0xd8, 0x7d,
-	0x44, 0xed, 0x68, 0xe1, 0xf8, 0x51, 0xa7, 0xb9, 0xda, 0xbf, 0x7b, 0xcb, 0xd9, 0x43, 0x1a, 0x9b,
-	0x0b, 0xc7, 0x4f, 0x4e, 0xba, 0x9d, 0x7a, 0x30, 0x5d, 0x84, 0xbf, 0x09, 0x9b, 0xd9, 0x12, 0x07,
-	0x74, 0x1e, 0x3b, 0x51, 0x47, 0xb9, 0x52, 0xdb, 0xc6, 0x24, 0x5b, 0x79, 0xc0, 0xb5, 0x25, 0x20,
-	0xe7, 0x16, 0x75, 0xe0, 0x4a, 0x6d, 0x5b, 0xca, 0x81, 0x9c, 0x58, 0xc4, 0x48, 0x2d, 0x82, 0xc8,
-	0x2d, 0x90, 0x5a, 0xff, 0xef, 0xa4, 0x52, 0x8f, 0x8c, 0x54, 0xb6, 0x44, 0x42, 0xaa, 0x25, 0x48,
-	0xa5, 0xea, 0x9c, 0x54, 0x06, 0x4c, 0x48, 0xb5, 0x05, 0xa9, 0x54, 0x9d, 0x90, 0xba, 0x05, 0x10,
-	0xd2, 0x88, 0xc6, 0xf6, 0x31, 0x3b, 0xf9, 0x0d, 0x5e, 0xf8, 0x97, 0xce, 0xe8, 0x41, 0x3b, 0x84,
-	0xa1, 0x76, 0x5d, 0x3f, 0x26, 0x4a, 0x98, 0x3e, 0xe2, 0x77, 0x40, 0xc9, 0x72, 0xad, 0xb3, 0xc9,
-	0x93, 0x2f, 0x57, 0xa8, 0x37, 0x41, 0xc9, 0xbc, 0xca, 0xe5, 0xdb, 0x80, 0xda, 0x03, 0xdd, 0x44,
-	0x12, 0xae, 0x43, 0xd5, 0x98, 0xa0, 0x6a, 0x5e, 0xc2, 0xb5, 0x2d, 0xf9, 0x97, 0xbf, 0xef, 0x4a,
-	0xbd, 0x06, 0xac, 0x71, 0xde, 0xbd, 0x16, 0x40, 0x1e, 0x76, 0xf5, 0x9f, 0x32, 0x6c, 0xf0, 0x10,
-	0xe7, 0x29, 0x1d, 0x01, 0xe6, 0x36, 0x1a, 0xda, 0x2b, 0x6f, 0xd2, 0xee, 0xe9, 0xff, 0x7a, 0x7e,
-	0x59, 0x2b, 0x8c, 0x07, 0x8b, 0x30, 0xf0, 0x68, 0x7c, 0x4c, 0x97, 0x51, 0xf1, 0xd1, 0x0b, 0x0e,
-	0xe8, 0xfc, 0x5a, 0xd6, 0x5d, 0x77, 0xfa, 0x62, 0xb9, 0xfc, 0x8d, 0xd1, 0x6c, 0x45, 0xf3, 0xa6,
-	0x39, 0x7f, 0xa9, 0xf8, 0x52, 0x22, 0x8b, 0x89, 0x92, 0xe5, 0x30, 0x2b, 0x76, 0x61, 0x49, 0x8a,
-	0x9d, 0x0b, 0x67, 0x54, 0xde, 0x57, 0x90, 0x51, 0x5f, 0x41, 0xa5, 0x7c, 0x0b, 0x50, 0xc6, 0x62,
-	0x9f, 0x63, 0xd3, 0x64, 0xcb, 0x72, 0x50, 0x2c, 0xc1, 0xa1, 0xd9, 0x6e, 0x29, 0x54, 0x14, 0x4b,
-	0x56, 0x43, 0x29, 0xf4, 0x3d, 0x68, 0x27, 0x53, 0x1a, 0x6f, 0x75, 0x51, 0x07, 0x71, 0x5c, 0x4b,
-	0x28, 0xef, 0x71, 0xdd, 0x5d, 0xb9, 0x29, 0xa1, 0xea, 0x5d, 0xb9, 0x59, 0x47, 0x8d, 0xbb, 0x72,
-	0x53, 0x41, 0x70, 0x57, 0x6e, 0xb6, 0x50, 0xfb, 0xae, 0xdc, 0xdc, 0x44, 0x88, 0xe4, 0xad, 0x8e,
-	0xac, 0xb4, 0x18, 0xb2, 0x5a, 0xdb, 0x64, 0xb5, 0xae, 0x8a, 0x79, 0x7c, 0x0b, 0x20, 0x3f, 0x03,
-	0x16, 0xfa, 0xe0, 0xf0, 0x30, 0xa2, 0xa2, 0x7f, 0x9e, 0x23, 0x89, 0xc4, 0xf4, 0x73, 0xea, 0x1f,
-	0xc5, 0xc7, 0x3c, 0x6a, 0x6d, 0x92, 0x48, 0xea, 0x12, 0x70, 0x39, 0x63, 0xf7, 0x1c, 0x37, 0x7c,
-	0x9d, 0xcf, 0xf6, 0x2d, 0x50, 0xb2, 0x9c, 0xe4, 0x7b, 0x95, 0x86, 0xbe, 0xf2, 0x9a, 0xc9, 0xd0,
-	0x97, 0x3b, 0xa8, 0x3e, 0x6c, 0x8a, 0x09, 0x21, 0xaf, 0x94, 0x2c, 0xad, 0xa4, 0x33, 0xd2, 0xaa,
-	0x9a, 0xa7, 0xd5, 0x75, 0x68, 0xa4, 0xc1, 0x11, 0xd3, 0xcc, 0xdb, 0x67, 0x0d, 0x25, 0x1c, 0x41,
-	0x52, 0xa4, 0x1a, 0xc1, 0xe6, 0x8a, 0x0d, 0x77, 0x01, 0xf6, 0x83, 0xa5, 0x7f, 0xe0, 0x24, 0x13,
-	0xb4, 0xb4, 0xbd, 0x46, 0x0a, 0x1a, 0xc6, 0x67, 0x1e, 0x7c, 0x4a, 0xc3, 0x34, 0xcd, 0xb9, 0xc0,
-	0xb4, 0xcb, 0xc5, 0x82, 0x86, 0x49, 0xa2, 0x0b, 0x21, 0xe7, 0x2e, 0x17, 0xb8, 0xab, 0x73, 0x38,
-	0xbf, 0xf2, 0x92, 0xfc, 0x70, 0x4b, 0x6d, 0xa9, 0xba, 0xd2, 0x96, 0xf0, 0x87, 0xa7, 0xcf, 0xf5,
-	0xed, 0xd5, 0x11, 0x2f, 0x5b, 0xaf, 0x78, 0xa4, 0x7f, 0x96, 0xa1, 0xfd, 0xc9, 0x92, 0x86, 0x4f,
-	0xd2, 0x99, 0x15, 0xdf, 0x80, 0x7a, 0x14, 0x3b, 0xf1, 0x32, 0x4a, 0x46, 0xa6, 0x6e, 0xbe, 0x4e,
-	0x09, 0xb8, 0x63, 0x72, 0x14, 0x49, 0xd0, 0xf8, 0xc7, 0x00, 0x94, 0x0d, 0xb1, 0xfc, 0x06, 0x72,
-	0xfa, 0x36, 0x50, 0xf6, 0xe5, 0xe3, 0x2e, 0x1f, 0xb6, 0x14, 0x9a, 0x3e, 0xb2, 0xf3, 0xe0, 0x02,
-	0x3f, 0x25, 0x85, 0x08, 0x01, 0xef, 0x30, 0x3e, 0xa1, 0xeb, 0x1f, 0xf1, 0x63, 0x2a, 0x55, 0xb1,
-	0xc9, 0xf5, 0x03, 0x27, 0x76, 0x76, 0x2b, 0x24, 0x41, 0x31, 0xfc, 0x23, 0x3a, 0x8b, 0x83, 0x90,
-	0xb7, 0xa9, 0x12, 0xfe, 0x1e, 0xd7, 0xa7, 0x78, 0x81, 0xe2, 0xeb, 0xcf, 0x9c, 0xb9, 0x13, 0xf2,
-	0x6f, 0x74, 0x79, 0x7d, 0xae, 0xcf, 0xd6, 0xe7, 0x12, 0xc3, 0x7b, 0x4e, 0x1c, 0xba, 0x8f, 0x79,
-	0x8f, 0x2b, 0xe1, 0xc7, 0x5c, 0x9f, 0xe2, 0x05, 0x0a, 0x6f, 0x41, 0xf3, 0x53, 0x27, 0xf4, 0x5d,
-	0xff, 0x48, 0xf4, 0x21, 0x85, 0x64, 0x32, 0x7b, 0x63, 0xd7, 0x3f, 0x0c, 0xc4, 0x67, 0x58, 0x21,
-	0x42, 0x50, 0xdf, 0x87, 0xba, 0x38, 0x5b, 0xf6, 0x09, 0xd1, 0x09, 0x99, 0x10, 0x31, 0x1d, 0x9a,
-	0xd3, 0x7e, 0x5f, 0x37, 0x4d, 0x24, 0x89, 0xef, 0x89, 0xfa, 0x1b, 0x09, 0x94, 0xec, 0x20, 0xd9,
-	0xd8, 0x67, 0x4c, 0x0c, 0x5d, 0x40, 0xad, 0xe1, 0x58, 0x9f, 0x4c, 0x2d, 0x24, 0xb1, 0x19, 0xb0,
-	0xaf, 0x19, 0x7d, 0x7d, 0xa4, 0x0f, 0xc4, 0x2c, 0xa9, 0xff, 0x44, 0xef, 0x4f, 0xad, 0xe1, 0xc4,
-	0x40, 0x35, 0x66, 0xec, 0x69, 0x03, 0x7b, 0xa0, 0x59, 0x1a, 0x92, 0x99, 0x34, 0x64, 0xe3, 0xa7,
-	0xa1, 0x8d, 0xd0, 0x1a, 0xde, 0x84, 0xf5, 0xa9, 0xa1, 0xdd, 0xd3, 0x86, 0x23, 0xad, 0x37, 0xd2,
-	0x51, 0x9d, 0xf9, 0x1a, 0x13, 0xcb, 0xbe, 0x3d, 0x99, 0x1a, 0x03, 0xd4, 0x60, 0x73, 0x28, 0x13,
-	0xb5, 0x7e, 0x5f, 0xdf, 0xb3, 0x38, 0xa4, 0x99, 0x7c, 0xe7, 0xea, 0x20, 0xb3, 0x91, 0x5a, 0xd5,
-	0x01, 0xf2, 0x08, 0x95, 0x27, 0x76, 0xe5, 0x55, 0xd3, 0xde, 0xe9, 0x9e, 0xa1, 0xfe, 0x42, 0x02,
-	0xc8, 0x23, 0x87, 0x6f, 0xe4, 0x77, 0x19, 0x31, 0x73, 0x5e, 0x5c, 0x0d, 0xf0, 0xd9, 0x37, 0x9a,
-	0x1f, 0x95, 0x6e, 0x26, 0xd5, 0xd5, 0x26, 0x20, 0x5c, 0xff, 0xd3, 0xfd, 0xc4, 0x86, 0x56, 0x71,
-	0x7d, 0xd6, 0x1c, 0xc5, 0x35, 0x80, 0xf3, 0x50, 0x48, 0x22, 0xfd, 0xff, 0x63, 0xed, 0xaf, 0x24,
-	0xd8, 0x5c, 0xa1, 0xf1, 0xca, 0x4d, 0x4a, 0x8d, 0xb4, 0xfa, 0x1a, 0x8d, 0xb4, 0x52, 0xa8, 0xfa,
-	0xd7, 0x21, 0xc3, 0x82, 0x97, 0xa5, 0xff, 0xd9, 0xd7, 0xad, 0xd7, 0x09, 0x5e, 0x0f, 0x20, 0xaf,
-	0x0a, 0xfc, 0x3d, 0xa8, 0x97, 0xfe, 0x3d, 0x5c, 0x5c, 0xad, 0x9d, 0xe4, 0xef, 0x43, 0x72, 0x4f,
-	0x10, 0x58, 0xf5, 0x77, 0x12, 0xb4, 0x8a, 0xe6, 0x57, 0x1e, 0xca, 0xff, 0x7e, 0xcd, 0xed, 0x95,
-	0x92, 0x42, 0x7c, 0x19, 0xde, 0x79, 0xd5, 0x39, 0xb2, 0x3e, 0x7c, 0x3a, 0x2f, 0xae, 0xfe, 0xb1,
-	0x0a, 0x90, 0x5f, 0xdf, 0xf1, 0x39, 0x68, 0x27, 0x43, 0xa1, 0xdd, 0xd7, 0xa6, 0x26, 0x2b, 0xc8,
-	0x2d, 0xb8, 0x48, 0xf4, 0xbd, 0xd1, 0xb0, 0xaf, 0x99, 0xf6, 0x60, 0x38, 0xb0, 0x59, 0xdd, 0x8c,
-	0x35, 0xab, 0xbf, 0x8b, 0x24, 0xfc, 0x16, 0x9c, 0xb3, 0x26, 0x13, 0x7b, 0xac, 0x19, 0x0f, 0xec,
-	0xfe, 0x68, 0x6a, 0x5a, 0x3a, 0x31, 0x51, 0xb5, 0x54, 0x99, 0x35, 0xb6, 0xc0, 0xd0, 0xb8, 0xa3,
-	0x9b, 0xac, 0x6c, 0x6d, 0xa2, 0x59, 0xba, 0x3d, 0x1a, 0x8e, 0x87, 0x96, 0x3e, 0x40, 0x32, 0xee,
-	0xc0, 0x05, 0xa2, 0x7f, 0x32, 0xd5, 0x4d, 0xab, 0x6c, 0x59, 0x63, 0x15, 0x3a, 0x34, 0x4c, 0x8b,
-	0x55, 0xbf, 0xd0, 0xa2, 0x3a, 0xfe, 0x1a, 0x9c, 0x37, 0x75, 0x72, 0x6f, 0xd8, 0xd7, 0xed, 0x62,
-	0x75, 0x37, 0xf0, 0x05, 0x40, 0x96, 0x39, 0xe8, 0x95, 0xb4, 0x4d, 0x46, 0x83, 0xb1, 0xeb, 0x4d,
-	0xcd, 0x07, 0x48, 0x61, 0x5b, 0xf5, 0x87, 0xa4, 0x3f, 0x1d, 0x5a, 0x76, 0x8f, 0xe8, 0xda, 0xc7,
-	0x3a, 0xb1, 0x27, 0x7b, 0xba, 0x81, 0x00, 0x5f, 0x04, 0x3c, 0xd6, 0xad, 0xdd, 0x89, 0x78, 0x37,
-	0x6d, 0x34, 0x9a, 0xdc, 0xd7, 0x07, 0x68, 0x1d, 0x23, 0x68, 0x59, 0xba, 0xa1, 0x19, 0x56, 0x42,
-	0xa0, 0xd5, 0xfb, 0xc1, 0xb3, 0x17, 0xdd, 0xca, 0xe7, 0x2f, 0xba, 0x95, 0x2f, 0x5f, 0x74, 0xa5,
-	0xcf, 0x4e, 0xba, 0xd2, 0x1f, 0x4e, 0xba, 0xd2, 0xd3, 0x93, 0xae, 0xf4, 0xec, 0xa4, 0x2b, 0xfd,
-	0xf5, 0xa4, 0x2b, 0x7d, 0x71, 0xd2, 0xad, 0x7c, 0x79, 0xd2, 0x95, 0x7e, 0xfd, 0xb2, 0x5b, 0x79,
-	0xf6, 0xb2, 0x5b, 0xf9, 0xfc, 0x65, 0xb7, 0xf2, 0xd3, 0x46, 0xf2, 0xcb, 0x6b, 0xbf, 0xce, 0xff,
-	0x6c, 0x5d, 0xff, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x76, 0x95, 0x60, 0x64, 0x67, 0x13, 0x00,
-	0x00,
+	// 2038 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x8f, 0xdb, 0xc6,
+	0x15, 0x17, 0x25, 0xae, 0x24, 0xbe, 0x95, 0x76, 0xc7, 0x63, 0xc7, 0x55, 0xb6, 0xb1, 0x6c, 0x33,
+	0x68, 0xba, 0x35, 0xda, 0x75, 0x10, 0xb7, 0x09, 0x6a, 0xb8, 0x4d, 0x29, 0x89, 0xf6, 0xca, 0x91,
+	0xa8, 0xcd, 0x90, 0xb2, 0xeb, 0x5e, 0x08, 0xae, 0x76, 0x76, 0x97, 0xb0, 0x48, 0xaa, 0x24, 0xe5,
+	0xd8, 0x39, 0xf5, 0x52, 0xa0, 0xe8, 0xa9, 0x97, 0x5e, 0x8a, 0xde, 0x7a, 0x29, 0xd0, 0x7f, 0xc4,
+	0x40, 0x2f, 0x3e, 0x15, 0x69, 0x0f, 0x46, 0xbd, 0xbe, 0xa4, 0x87, 0x02, 0x41, 0x8f, 0x3d, 0x15,
+	0x33, 0xc3, 0x4f, 0xad, 0x17, 0x31, 0xdc, 0xdc, 0xf8, 0xde, 0xfb, 0xbd, 0x99, 0x1f, 0xe7, 0x7d,
+	0xf0, 0x0d, 0x61, 0xdd, 0x73, 0x3d, 0x37, 0xdc, 0x59, 0x84, 0x41, 0x1c, 0xe0, 0xe6, 0x2c, 0x08,
+	0x63, 0xfa, 0x78, 0xb1, 0xbf, 0xf5, 0x83, 0x23, 0x37, 0x3e, 0x5e, 0xee, 0xef, 0xcc, 0x02, 0xef,
+	0xfa, 0x51, 0x70, 0x14, 0x5c, 0xe7, 0x80, 0xfd, 0xe5, 0x21, 0x97, 0xb8, 0xc0, 0x9f, 0x84, 0xe3,
+	0xd6, 0xa0, 0x08, 0x0f, 0x9d, 0x43, 0xc7, 0x77, 0xae, 0xf3, 0x85, 0xaf, 0x2f, 0x1e, 0x1e, 0x89,
+	0xa7, 0xc5, 0xbe, 0x3d, 0x5b, 0x46, 0x71, 0xe0, 0x09, 0x31, 0x11, 0xec, 0xf8, 0xc9, 0x82, 0x46,
+	0x62, 0x15, 0xf5, 0xdf, 0x55, 0x68, 0xdd, 0x0f, 0xdd, 0x98, 0x12, 0xfa, 0xcb, 0x25, 0x8d, 0x62,
+	0xbc, 0x07, 0x10, 0xbb, 0x1e, 0x8d, 0x68, 0xe8, 0xd2, 0xa8, 0x23, 0x5d, 0xa9, 0x6d, 0xaf, 0x7f,
+	0x70, 0x61, 0x27, 0x25, 0xb9, 0x63, 0xb9, 0x1e, 0x35, 0xb9, 0xad, 0xb7, 0xf5, 0xf4, 0xf9, 0xe5,
+	0xca, 0x3f, 0x9e, 0x5f, 0xc6, 0x7b, 0x21, 0x75, 0xe6, 0xf3, 0x60, 0x66, 0x65, 0x7e, 0xa4, 0xb0,
+	0x06, 0xfe, 0x31, 0xd4, 0xcd, 0x60, 0x19, 0xce, 0x68, 0xa7, 0x7a, 0x45, 0xda, 0xde, 0xf8, 0xe0,
+	0x6a, 0xbe, 0x5a, 0x71, 0xe7, 0x1d, 0x01, 0xd2, 0xfd, 0xa5, 0x47, 0x12, 0x07, 0x7c, 0x13, 0x9a,
+	0x1e, 0x8d, 0x9d, 0x03, 0x27, 0x76, 0x3a, 0x35, 0x4e, 0xa5, 0x93, 0x3b, 0x8f, 0x69, 0x1c, 0xba,
+	0xb3, 0x71, 0x62, 0xef, 0xc9, 0x4f, 0x9f, 0x5f, 0x96, 0x48, 0x86, 0xc7, 0x37, 0xe0, 0xad, 0xe8,
+	0xa1, 0xbb, 0xb0, 0xe7, 0xce, 0x3e, 0x9d, 0xdb, 0x8f, 0x9c, 0xb9, 0x7b, 0xe0, 0xc4, 0x6e, 0xe0,
+	0x77, 0xbe, 0x6c, 0x5c, 0x91, 0xb6, 0x9b, 0xe4, 0x3c, 0xb3, 0x8e, 0x98, 0xf1, 0x5e, 0x66, 0xc3,
+	0x3f, 0x85, 0x6f, 0x17, 0x9c, 0x66, 0xc1, 0xd2, 0x8f, 0x8b, 0xae, 0xff, 0x12, 0xae, 0x9d, 0xcc,
+	0xb5, 0xcf, 0x10, 0xb9, 0xbf, 0x7a, 0x19, 0x20, 0x7f, 0x0d, 0xdc, 0x80, 0x9a, 0xb6, 0x37, 0x44,
+	0x15, 0xdc, 0x04, 0x99, 0x4c, 0x47, 0x3a, 0x92, 0xd4, 0x4d, 0x68, 0x27, 0x2f, 0x1d, 0x2d, 0x02,
+	0x3f, 0xa2, 0xea, 0x4d, 0x68, 0xe9, 0x61, 0x18, 0x84, 0x03, 0x1a, 0x3b, 0xee, 0x3c, 0xc2, 0xd7,
+	0x60, 0xad, 0xef, 0x2c, 0x23, 0xda, 0x91, 0xf8, 0x61, 0x15, 0x8e, 0x9e, 0xc3, 0xb8, 0x8d, 0x08,
+	0x88, 0xfa, 0x37, 0x09, 0x20, 0x0f, 0x08, 0xfe, 0x11, 0xd4, 0x39, 0xef, 0x34, 0x6c, 0x97, 0x32,
+	0xdf, 0x24, 0xf2, 0x3b, 0x9c, 0xb3, 0x76, 0xe0, 0x2c, 0x62, 0x1a, 0x92, 0x04, 0x8c, 0xaf, 0x41,
+	0x23, 0x72, 0xbc, 0xc5, 0x9c, 0x46, 0x9d, 0x2a, 0xf7, 0x43, 0xf9, 0x9e, 0x26, 0x37, 0x90, 0x14,
+	0x80, 0xdf, 0x07, 0x85, 0x3e, 0xa6, 0xde, 0x62, 0xee, 0x84, 0x51, 0x12, 0x11, 0x5c, 0x60, 0x98,
+	0x98, 0x48, 0x0e, 0xc2, 0x37, 0x00, 0x8e, 0xdd, 0x28, 0x0e, 0x8e, 0x42, 0xc7, 0x8b, 0x3a, 0x32,
+	0x77, 0x39, 0x9f, 0xbb, 0xec, 0xa6, 0x36, 0x52, 0x80, 0xa9, 0x1a, 0xd4, 0xc5, 0xce, 0xf8, 0x2a,
+	0xb4, 0x78, 0x2a, 0xc5, 0x8e, 0xb7, 0xb0, 0xbd, 0x88, 0xa7, 0x50, 0x8d, 0xac, 0x67, 0xba, 0x71,
+	0x84, 0x2f, 0xc0, 0xda, 0x23, 0x67, 0xbe, 0x14, 0x27, 0x26, 0x11, 0x21, 0xa8, 0x7f, 0xa8, 0xc2,
+	0x46, 0x39, 0x43, 0xf0, 0x47, 0x20, 0xb3, 0xd4, 0x4f, 0x4e, 0xf6, 0xdd, 0xb3, 0x32, 0x29, 0x11,
+	0xad, 0x27, 0x0b, 0x4a, 0xb8, 0x03, 0xfe, 0x3e, 0x60, 0x8f, 0xeb, 0xec, 0x43, 0xc7, 0x73, 0xe7,
+	0x4f, 0x6c, 0xdf, 0xf1, 0x44, 0x36, 0x2b, 0x04, 0x09, 0xcb, 0x6d, 0x6e, 0x30, 0x1c, 0x8f, 0x62,
+	0x0c, 0xf2, 0x31, 0x9d, 0x2f, 0x3a, 0x32, 0xb7, 0xf3, 0x67, 0xa6, 0x5b, 0xfa, 0x6e, 0xdc, 0x59,
+	0x13, 0x3a, 0xf6, 0xac, 0x3e, 0x01, 0xc8, 0x77, 0xc2, 0xeb, 0xd0, 0x98, 0x1a, 0x9f, 0x18, 0x93,
+	0xfb, 0x06, 0xaa, 0x30, 0xa1, 0x3f, 0x99, 0x1a, 0x96, 0x4e, 0x90, 0x84, 0x15, 0x58, 0xbb, 0xa3,
+	0x4d, 0xef, 0xe8, 0xa8, 0x8a, 0xdb, 0xa0, 0xec, 0x0e, 0x4d, 0x6b, 0x72, 0x87, 0x68, 0x63, 0x54,
+	0xc3, 0x18, 0x36, 0xb8, 0x25, 0xd7, 0xc9, 0xcc, 0xd5, 0x9c, 0x8e, 0xc7, 0x1a, 0x79, 0x80, 0xd6,
+	0x58, 0xde, 0x0d, 0x8d, 0xdb, 0x13, 0x54, 0xc7, 0x2d, 0x68, 0x9a, 0x96, 0x66, 0xe9, 0xa6, 0x6e,
+	0xa1, 0x86, 0xfa, 0x31, 0xd4, 0xc5, 0xd6, 0x6f, 0x98, 0x33, 0xea, 0xe7, 0xd0, 0x4c, 0x83, 0xfd,
+	0xa6, 0x69, 0x97, 0x85, 0xad, 0x5a, 0x08, 0xdb, 0xa9, 0x78, 0xd7, 0x4e, 0xc5, 0x5b, 0xfd, 0xeb,
+	0x1a, 0x28, 0x59, 0xda, 0xe0, 0x4b, 0xa0, 0x88, 0x32, 0x75, 0xfd, 0x98, 0x47, 0x56, 0xde, 0xad,
+	0x90, 0x26, 0x57, 0x0d, 0xfd, 0x18, 0x5f, 0x85, 0x75, 0x61, 0x3e, 0x9c, 0x07, 0x4e, 0x2c, 0xf6,
+	0xda, 0xad, 0x10, 0xe0, 0xca, 0xdb, 0x4c, 0x87, 0x11, 0xd4, 0xa2, 0xa5, 0xc7, 0x77, 0x92, 0x08,
+	0x7b, 0xc4, 0x17, 0xa1, 0x1e, 0xcd, 0x8e, 0xa9, 0xe7, 0xf0, 0x18, 0x9e, 0x23, 0x89, 0x84, 0xbf,
+	0x03, 0x1b, 0x9f, 0xd3, 0x30, 0xb0, 0xe3, 0xe3, 0x90, 0x46, 0xc7, 0xc1, 0xfc, 0x80, 0xc7, 0x53,
+	0x22, 0x6d, 0xa6, 0xb5, 0x52, 0x25, 0x7e, 0x2f, 0x81, 0xe5, 0xbc, 0xea, 0x9c, 0x97, 0x44, 0x5a,
+	0x4c, 0xdf, 0x4f, 0xb9, 0x5d, 0x03, 0x54, 0xc0, 0x09, 0x82, 0x0d, 0x4e, 0x50, 0x22, 0x1b, 0x19,
+	0x52, 0x90, 0xd4, 0x60, 0xc3, 0xa7, 0x47, 0x4e, 0xec, 0x3e, 0xa2, 0x76, 0xb4, 0x70, 0xfc, 0xa8,
+	0xd3, 0x5c, 0x6d, 0xcd, 0xbd, 0xe5, 0xec, 0x21, 0x8d, 0xcd, 0x85, 0xe3, 0xf3, 0x5e, 0x58, 0x21,
+	0xed, 0xd4, 0x83, 0xe9, 0x22, 0xfc, 0x5d, 0xd8, 0xcc, 0x96, 0x38, 0xa0, 0xf3, 0xd8, 0x89, 0x3a,
+	0xca, 0x95, 0xda, 0x36, 0x26, 0xd9, 0xca, 0x03, 0xae, 0x2d, 0x01, 0x39, 0xb7, 0xa8, 0x03, 0x57,
+	0x6a, 0xdb, 0x52, 0x0e, 0xe4, 0xc4, 0x22, 0x46, 0x6a, 0x11, 0x44, 0x6e, 0x81, 0xd4, 0xfa, 0xd7,
+	0x93, 0x4a, 0x3d, 0x32, 0x52, 0xd9, 0x12, 0x09, 0xa9, 0x96, 0x20, 0x95, 0xaa, 0x73, 0x52, 0x19,
+	0x30, 0x21, 0xd5, 0x16, 0xa4, 0x52, 0x75, 0x42, 0xea, 0x16, 0x40, 0x48, 0x23, 0x1a, 0xdb, 0xc7,
+	0xec, 0xe4, 0x37, 0x78, 0xad, 0x5f, 0x7a, 0x45, 0xc3, 0xd9, 0x21, 0x0c, 0xb5, 0xeb, 0xfa, 0x31,
+	0x51, 0xc2, 0xf4, 0x11, 0xbf, 0x03, 0x4a, 0x96, 0x6b, 0x9d, 0x4d, 0x9e, 0x7c, 0xb9, 0x42, 0xbd,
+	0x09, 0x4a, 0xe6, 0x55, 0xae, 0xd8, 0x06, 0xd4, 0x1e, 0xe8, 0x26, 0x92, 0x70, 0x1d, 0xaa, 0xc6,
+	0x04, 0x55, 0xf3, 0xaa, 0xad, 0x6d, 0xc9, 0xbf, 0xf9, 0x53, 0x57, 0xea, 0x35, 0x60, 0x8d, 0xf3,
+	0xee, 0xb5, 0x00, 0xf2, 0xb0, 0xab, 0xff, 0x91, 0x61, 0x83, 0x87, 0x38, 0x4f, 0xe9, 0x08, 0x30,
+	0xb7, 0xd1, 0xd0, 0x5e, 0x79, 0x93, 0x76, 0x4f, 0xff, 0xef, 0xf3, 0xcb, 0x5a, 0xe1, 0xcb, 0xbf,
+	0x08, 0x03, 0x8f, 0xc6, 0xc7, 0x74, 0x19, 0x15, 0x1f, 0xbd, 0xe0, 0x80, 0xce, 0xaf, 0x67, 0x0d,
+	0x75, 0xa7, 0x2f, 0x96, 0xcb, 0xdf, 0x18, 0xcd, 0x56, 0x34, 0xff, 0x6f, 0xce, 0x5f, 0x2a, 0xbe,
+	0x94, 0xc8, 0x62, 0xa2, 0x64, 0x39, 0xcc, 0x8a, 0x5d, 0x58, 0x92, 0x62, 0xe7, 0xc2, 0x2b, 0x2a,
+	0xef, 0x1b, 0xc8, 0xa8, 0x6f, 0xa0, 0x52, 0xbe, 0x07, 0x28, 0x63, 0xb1, 0xcf, 0xb1, 0x69, 0xb2,
+	0x65, 0x39, 0x28, 0x96, 0xe0, 0xd0, 0x6c, 0xb7, 0x14, 0x2a, 0x8a, 0x25, 0xab, 0xa1, 0x14, 0xfa,
+	0x2e, 0xb4, 0x93, 0x01, 0x8c, 0xb7, 0xba, 0xa8, 0x83, 0x38, 0xae, 0x25, 0x94, 0xf7, 0xb8, 0xee,
+	0xae, 0xdc, 0x94, 0x50, 0xf5, 0xae, 0xdc, 0xac, 0xa3, 0xc6, 0x5d, 0xb9, 0xa9, 0x20, 0xb8, 0x2b,
+	0x37, 0x5b, 0xa8, 0x7d, 0x57, 0x6e, 0x6e, 0x22, 0x44, 0xf2, 0x56, 0x47, 0x56, 0x5a, 0x0c, 0x59,
+	0xad, 0x6d, 0xb2, 0x5a, 0x57, 0xc5, 0x3c, 0xbe, 0x05, 0x90, 0x9f, 0x01, 0x0b, 0x7d, 0x70, 0x78,
+	0x18, 0x51, 0xd1, 0x3f, 0xcf, 0x91, 0x44, 0x62, 0xfa, 0x39, 0xf5, 0x8f, 0xe2, 0x63, 0x1e, 0xb5,
+	0x36, 0x49, 0x24, 0x75, 0x09, 0xb8, 0x9c, 0xb1, 0x7b, 0x8e, 0x1b, 0xbe, 0xce, 0x97, 0xfa, 0x16,
+	0x28, 0x59, 0x4e, 0xf2, 0xbd, 0x4a, 0xf3, 0x5c, 0x79, 0xcd, 0x64, 0x9e, 0xcb, 0x1d, 0x54, 0x1f,
+	0x36, 0xc5, 0x50, 0x90, 0x57, 0x4a, 0x96, 0x56, 0xd2, 0x2b, 0xd2, 0xaa, 0x9a, 0xa7, 0xd5, 0x0d,
+	0x68, 0xa4, 0xc1, 0x11, 0x43, 0xcb, 0xdb, 0xaf, 0x68, 0x08, 0xe2, 0x44, 0x48, 0x8a, 0x54, 0x23,
+	0xd8, 0x5c, 0xb1, 0xe1, 0x2e, 0xc0, 0x7e, 0xb0, 0xf4, 0x0f, 0x9c, 0x64, 0x38, 0x96, 0xb6, 0xd7,
+	0x48, 0x41, 0xc3, 0xf8, 0xcc, 0x83, 0xcf, 0x68, 0x98, 0xa6, 0x39, 0x17, 0x98, 0x76, 0xb9, 0x58,
+	0xd0, 0x30, 0x49, 0x74, 0x21, 0xe4, 0xdc, 0xe5, 0x02, 0x77, 0x75, 0x0e, 0xe7, 0x57, 0x5e, 0x92,
+	0x1f, 0x6e, 0xa9, 0x2d, 0x55, 0x57, 0xda, 0x12, 0xfe, 0xe8, 0xf4, 0xb9, 0xbe, 0xbd, 0x3a, 0xc3,
+	0xe5, 0x83, 0x56, 0xe1, 0x48, 0xff, 0x2e, 0x43, 0xfb, 0xd3, 0x25, 0x0d, 0x9f, 0xa4, 0xe3, 0x28,
+	0xfe, 0x10, 0xea, 0x51, 0xec, 0xc4, 0xcb, 0x28, 0x99, 0x92, 0xba, 0xf9, 0x3a, 0x25, 0xe0, 0x8e,
+	0xc9, 0x51, 0x24, 0x41, 0xe3, 0x9f, 0x01, 0x50, 0x36, 0x9f, 0xf2, 0xcb, 0xc5, 0xe9, 0x41, 0xbf,
+	0xec, 0xcb, 0x27, 0x59, 0x3e, 0x5f, 0x29, 0x34, 0x7d, 0x64, 0xe7, 0xc1, 0x05, 0x7e, 0x4a, 0x0a,
+	0x11, 0x02, 0xde, 0x61, 0x7c, 0x42, 0xd7, 0x3f, 0xe2, 0xc7, 0x54, 0xaa, 0x62, 0x93, 0xeb, 0x07,
+	0x4e, 0xec, 0xec, 0x56, 0x48, 0x82, 0x62, 0xf8, 0x47, 0x74, 0x16, 0x07, 0x21, 0x6f, 0x53, 0x25,
+	0xfc, 0x3d, 0xae, 0x4f, 0xf1, 0x02, 0xc5, 0xd7, 0x9f, 0x39, 0x73, 0x27, 0xe4, 0xdf, 0xe8, 0xf2,
+	0xfa, 0x5c, 0x9f, 0xad, 0xcf, 0x25, 0x86, 0xf7, 0x9c, 0x38, 0x74, 0x1f, 0xf3, 0x1e, 0x57, 0xc2,
+	0x8f, 0xb9, 0x3e, 0xc5, 0x0b, 0x14, 0xde, 0x82, 0xe6, 0x67, 0x4e, 0xe8, 0xbb, 0xfe, 0x91, 0xe8,
+	0x43, 0x0a, 0xc9, 0x64, 0xf6, 0xc6, 0xae, 0x7f, 0x18, 0x88, 0xcf, 0xb0, 0x42, 0x84, 0xa0, 0xbe,
+	0x07, 0x75, 0x71, 0xb6, 0xec, 0x13, 0xa2, 0x13, 0x32, 0x21, 0x62, 0x20, 0x34, 0xa7, 0xfd, 0xbe,
+	0x6e, 0x9a, 0x48, 0x12, 0xdf, 0x13, 0xf5, 0xf7, 0x12, 0x28, 0xd9, 0x41, 0xb2, 0x49, 0xcf, 0x98,
+	0x18, 0xba, 0x80, 0x5a, 0xc3, 0xb1, 0x3e, 0x99, 0x5a, 0x48, 0x62, 0x63, 0x5f, 0x5f, 0x33, 0xfa,
+	0xfa, 0x48, 0x1f, 0x88, 0xf1, 0x51, 0xff, 0xb9, 0xde, 0x9f, 0x5a, 0xc3, 0x89, 0x81, 0x6a, 0xcc,
+	0xd8, 0xd3, 0x06, 0xf6, 0x40, 0xb3, 0x34, 0x24, 0x33, 0x69, 0xc8, 0x26, 0x4e, 0x43, 0x1b, 0xa1,
+	0x35, 0xbc, 0x09, 0xeb, 0x53, 0x43, 0xbb, 0xa7, 0x0d, 0x47, 0x5a, 0x6f, 0xa4, 0xa3, 0x3a, 0xf3,
+	0x35, 0x26, 0x96, 0x7d, 0x7b, 0x32, 0x35, 0x06, 0xa8, 0xc1, 0x46, 0x4f, 0x26, 0x6a, 0xfd, 0xbe,
+	0xbe, 0x67, 0x71, 0x48, 0x33, 0xf9, 0xce, 0xd5, 0x41, 0x66, 0x53, 0xb4, 0xaa, 0x03, 0xe4, 0x11,
+	0x2a, 0x0f, 0xe9, 0xca, 0x59, 0xd3, 0xde, 0xe9, 0x9e, 0xa1, 0xfe, 0x5a, 0x02, 0xc8, 0x23, 0x87,
+	0x3f, 0xcc, 0x2f, 0x2b, 0x62, 0xda, 0xbc, 0xb8, 0x1a, 0x60, 0x91, 0xee, 0x49, 0x63, 0xcf, 0x2e,
+	0x2e, 0x1f, 0x97, 0xae, 0x21, 0xd5, 0xd5, 0x26, 0x20, 0x5c, 0xcb, 0xcd, 0xa7, 0x52, 0xba, 0x92,
+	0xd8, 0xd0, 0x2a, 0xae, 0xcf, 0x9a, 0xa3, 0x98, 0xfc, 0x39, 0x0f, 0x85, 0x24, 0xd2, 0x9b, 0x8f,
+	0xb5, 0xbf, 0x95, 0x60, 0x73, 0x85, 0xc6, 0x99, 0x9b, 0x94, 0x1a, 0x69, 0xf5, 0x35, 0x1a, 0x69,
+	0xa5, 0x50, 0xf5, 0xaf, 0x43, 0x86, 0x05, 0x2f, 0x4b, 0xff, 0x57, 0xdf, 0xb0, 0x5e, 0x27, 0x78,
+	0x3d, 0x80, 0xbc, 0x2a, 0xf0, 0x0f, 0xa1, 0x5e, 0xfa, 0xad, 0x70, 0x71, 0xb5, 0x76, 0x92, 0x1f,
+	0x0b, 0x82, 0x70, 0x82, 0x55, 0xff, 0x28, 0x41, 0xab, 0x68, 0x3e, 0xf3, 0x50, 0xde, 0xff, 0xda,
+	0x7b, 0xec, 0x6a, 0x52, 0xf4, 0x4a, 0x49, 0x21, 0xbe, 0x0c, 0xef, 0x9c, 0x75, 0x8e, 0xac, 0x0f,
+	0x9f, 0xce, 0x8b, 0x6b, 0x7f, 0xa9, 0x02, 0xe4, 0x37, 0x73, 0x7c, 0x0e, 0xda, 0xc9, 0x50, 0x68,
+	0xf7, 0xb5, 0xa9, 0xc9, 0x0a, 0x72, 0x0b, 0x2e, 0x12, 0x7d, 0x6f, 0x34, 0xec, 0x6b, 0xa6, 0x3d,
+	0x18, 0x0e, 0x6c, 0x56, 0x37, 0x63, 0xcd, 0xea, 0xef, 0x22, 0x09, 0xbf, 0x05, 0xe7, 0xac, 0xc9,
+	0xc4, 0x1e, 0x6b, 0xc6, 0x03, 0xbb, 0x3f, 0x9a, 0x9a, 0x96, 0x4e, 0x4c, 0x54, 0x2d, 0x55, 0x66,
+	0x8d, 0x2d, 0x30, 0x34, 0xee, 0xe8, 0x26, 0x2b, 0x5b, 0x9b, 0x68, 0x96, 0x6e, 0x8f, 0x86, 0xe3,
+	0xa1, 0xa5, 0x0f, 0x90, 0x8c, 0x3b, 0x70, 0x81, 0xe8, 0x9f, 0x4e, 0x75, 0xd3, 0x2a, 0x5b, 0xd6,
+	0x58, 0x85, 0x0e, 0x0d, 0xd3, 0x62, 0xd5, 0x2f, 0xb4, 0xa8, 0x8e, 0xbf, 0x05, 0xe7, 0x4d, 0x9d,
+	0xdc, 0x1b, 0xf6, 0x75, 0xbb, 0x58, 0xdd, 0x0d, 0x7c, 0x01, 0x90, 0x65, 0x0e, 0x7a, 0x25, 0x6d,
+	0x93, 0xd1, 0x60, 0xec, 0x7a, 0x53, 0xf3, 0x01, 0x52, 0xd8, 0x56, 0xfd, 0x21, 0xe9, 0x4f, 0x87,
+	0x96, 0xdd, 0x23, 0xba, 0xf6, 0x89, 0x4e, 0xec, 0xc9, 0x9e, 0x6e, 0x20, 0xc0, 0x17, 0x01, 0x8f,
+	0x75, 0x6b, 0x77, 0x22, 0xde, 0x4d, 0x1b, 0x8d, 0x26, 0xf7, 0xf5, 0x01, 0x5a, 0xc7, 0x08, 0x5a,
+	0x96, 0x6e, 0x68, 0x86, 0x95, 0x10, 0x68, 0xf5, 0x7e, 0xf2, 0xec, 0x45, 0xb7, 0xf2, 0xc5, 0x8b,
+	0x6e, 0xe5, 0xab, 0x17, 0x5d, 0xe9, 0x57, 0x27, 0x5d, 0xe9, 0xcf, 0x27, 0x5d, 0xe9, 0xe9, 0x49,
+	0x57, 0x7a, 0x76, 0xd2, 0x95, 0xfe, 0x79, 0xd2, 0x95, 0xbe, 0x3c, 0xe9, 0x56, 0xbe, 0x3a, 0xe9,
+	0x4a, 0xbf, 0x7b, 0xd9, 0xad, 0x3c, 0x7b, 0xd9, 0xad, 0x7c, 0xf1, 0xb2, 0x5b, 0xf9, 0x45, 0x23,
+	0xf9, 0x9b, 0xb5, 0x5f, 0xe7, 0x3f, 0xad, 0x6e, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x15, 0xa1,
+	0xd5, 0x77, 0x42, 0x13, 0x00, 0x00,
 }
 
 func (x ErrorCause) String() string {
@@ -2181,7 +2181,7 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(&that1.Labels[i]) {
+		if !this.Labels[i].Equal(that1.Labels[i]) {
 			return false
 		}
 	}
@@ -2189,7 +2189,7 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Samples {
-		if !this.Samples[i].Equal(&that1.Samples[i]) {
+		if !this.Samples[i].Equal(that1.Samples[i]) {
 			return false
 		}
 	}
@@ -2197,7 +2197,7 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Exemplars {
-		if !this.Exemplars[i].Equal(&that1.Exemplars[i]) {
+		if !this.Exemplars[i].Equal(that1.Exemplars[i]) {
 			return false
 		}
 	}
@@ -2205,7 +2205,7 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Histograms {
-		if !this.Histograms[i].Equal(&that1.Histograms[i]) {
+		if !this.Histograms[i].Equal(that1.Histograms[i]) {
 			return false
 		}
 	}
@@ -2294,7 +2294,7 @@ func (this *Metric) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(&that1.Labels[i]) {
+		if !this.Labels[i].Equal(that1.Labels[i]) {
 			return false
 		}
 	}
@@ -2323,7 +2323,7 @@ func (this *Exemplar) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(&that1.Labels[i]) {
+		if !this.Labels[i].Equal(that1.Labels[i]) {
 			return false
 		}
 	}
@@ -3189,32 +3189,16 @@ func (this *TimeSeries) GoString() string {
 	s := make([]string, 0, 8)
 	s = append(s, "&mimirpb.TimeSeries{")
 	if this.Labels != nil {
-		vs := make([]*mimirpb_custom.LabelAdapter, len(this.Labels))
-		for i := range vs {
-			vs[i] = &this.Labels[i]
-		}
-		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
 	}
 	if this.Samples != nil {
-		vs := make([]*Sample, len(this.Samples))
-		for i := range vs {
-			vs[i] = &this.Samples[i]
-		}
-		s = append(s, "Samples: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Samples: "+fmt.Sprintf("%#v", this.Samples)+",\n")
 	}
 	if this.Exemplars != nil {
-		vs := make([]*Exemplar, len(this.Exemplars))
-		for i := range vs {
-			vs[i] = &this.Exemplars[i]
-		}
-		s = append(s, "Exemplars: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Exemplars: "+fmt.Sprintf("%#v", this.Exemplars)+",\n")
 	}
 	if this.Histograms != nil {
-		vs := make([]*Histogram, len(this.Histograms))
-		for i := range vs {
-			vs[i] = &this.Histograms[i]
-		}
-		s = append(s, "Histograms: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Histograms: "+fmt.Sprintf("%#v", this.Histograms)+",\n")
 	}
 	s = append(s, "}")
 	return strings.Join(s, "")
@@ -3250,11 +3234,7 @@ func (this *Metric) GoString() string {
 	s := make([]string, 0, 5)
 	s = append(s, "&mimirpb.Metric{")
 	if this.Labels != nil {
-		vs := make([]*mimirpb_custom.LabelAdapter, len(this.Labels))
-		for i := range vs {
-			vs[i] = &this.Labels[i]
-		}
-		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
 	}
 	s = append(s, "}")
 	return strings.Join(s, "")
@@ -3266,11 +3246,7 @@ func (this *Exemplar) GoString() string {
 	s := make([]string, 0, 7)
 	s = append(s, "&mimirpb.Exemplar{")
 	if this.Labels != nil {
-		vs := make([]*mimirpb_custom.LabelAdapter, len(this.Labels))
-		for i := range vs {
-			vs[i] = &this.Labels[i]
-		}
-		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
 	}
 	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
 	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
@@ -5636,24 +5612,24 @@ func (this *TimeSeries) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForLabels := "[]LabelAdapter{"
+	repeatedStringForLabels := "[]*LabelAdapter{"
 	for _, f := range this.Labels {
-		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+		repeatedStringForLabels += strings.Replace(fmt.Sprintf("%v", f), "LabelAdapter", "mimirpb_custom.LabelAdapter", 1) + ","
 	}
 	repeatedStringForLabels += "}"
-	repeatedStringForSamples := "[]Sample{"
+	repeatedStringForSamples := "[]*Sample{"
 	for _, f := range this.Samples {
-		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
+		repeatedStringForSamples += strings.Replace(f.String(), "Sample", "Sample", 1) + ","
 	}
 	repeatedStringForSamples += "}"
-	repeatedStringForExemplars := "[]Exemplar{"
+	repeatedStringForExemplars := "[]*Exemplar{"
 	for _, f := range this.Exemplars {
-		repeatedStringForExemplars += strings.Replace(strings.Replace(f.String(), "Exemplar", "Exemplar", 1), `&`, ``, 1) + ","
+		repeatedStringForExemplars += strings.Replace(f.String(), "Exemplar", "Exemplar", 1) + ","
 	}
 	repeatedStringForExemplars += "}"
-	repeatedStringForHistograms := "[]Histogram{"
+	repeatedStringForHistograms := "[]*Histogram{"
 	for _, f := range this.Histograms {
-		repeatedStringForHistograms += strings.Replace(strings.Replace(f.String(), "Histogram", "Histogram", 1), `&`, ``, 1) + ","
+		repeatedStringForHistograms += strings.Replace(f.String(), "Histogram", "Histogram", 1) + ","
 	}
 	repeatedStringForHistograms += "}"
 	s := strings.Join([]string{`&TimeSeries{`,
@@ -5693,9 +5669,9 @@ func (this *Metric) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForLabels := "[]LabelAdapter{"
+	repeatedStringForLabels := "[]*LabelAdapter{"
 	for _, f := range this.Labels {
-		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+		repeatedStringForLabels += strings.Replace(fmt.Sprintf("%v", f), "LabelAdapter", "mimirpb_custom.LabelAdapter", 1) + ","
 	}
 	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&Metric{`,
@@ -5708,9 +5684,9 @@ func (this *Exemplar) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForLabels := "[]LabelAdapter{"
+	repeatedStringForLabels := "[]*LabelAdapter{"
 	for _, f := range this.Labels {
-		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+		repeatedStringForLabels += strings.Replace(fmt.Sprintf("%v", f), "LabelAdapter", "mimirpb_custom.LabelAdapter", 1) + ","
 	}
 	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&Exemplar{`,
@@ -6112,7 +6088,6 @@ func (m *WriteRequest) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			m.Timeseries = append(m.Timeseries, PreallocTimeseries{})
-			m.Timeseries[len(m.Timeseries)-1].skipUnmarshalingExemplars = m.skipUnmarshalingExemplars
 			if err := m.Timeseries[len(m.Timeseries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6417,7 +6392,7 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, mimirpb_custom.LabelAdapter{})
+			m.Labels = append(m.Labels, &mimirpb_custom.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6451,7 +6426,7 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Samples = append(m.Samples, Sample{})
+			m.Samples = append(m.Samples, &Sample{})
 			if err := m.Samples[len(m.Samples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6485,11 +6460,9 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if !m.SkipUnmarshalingExemplars {
-				m.Exemplars = append(m.Exemplars, Exemplar{})
-				if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-					return err
-				}
+			m.Exemplars = append(m.Exemplars, &Exemplar{})
+			if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 4:
@@ -6521,7 +6494,7 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Histograms = append(m.Histograms, Histogram{})
+			m.Histograms = append(m.Histograms, &Histogram{})
 			if err := m.Histograms[len(m.Histograms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6859,7 +6832,7 @@ func (m *Metric) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, mimirpb_custom.LabelAdapter{})
+			m.Labels = append(m.Labels, &mimirpb_custom.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6946,7 +6919,7 @@ func (m *Exemplar) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, mimirpb_custom.LabelAdapter{})
+			m.Labels = append(m.Labels, &mimirpb_custom.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/mimirpb/mimir.pb.go.expdiff b/pkg/mimirpb/mimir.pb.go.expdiff
index 0ac49f36b50..22b589814f2 100644
--- a/pkg/mimirpb/mimir.pb.go.expdiff
+++ b/pkg/mimirpb/mimir.pb.go.expdiff
@@ -13,9 +13,9 @@ index 2fcc5ccde1..0688358568 100644
  
  func (m *WriteRequest) Reset()      { *m = WriteRequest{} }
 @@ -392,9 +389,6 @@ type TimeSeries struct {
- 	Samples    []Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
- 	Exemplars  []Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars"`
- 	Histograms []Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms"`
+ 	Samples    []*Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples,omitempty"`
+    Exemplars  []*Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars,omitempty"`
+    Histograms []*Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms,omitempty"`
 -
 -	// Skip unmarshaling of exemplars.
 -	SkipUnmarshalingExemplars bool
diff --git a/pkg/mimirpb/mimir.proto b/pkg/mimirpb/mimir.proto
index 3e2e058928b..952a3d969ea 100644
--- a/pkg/mimirpb/mimir.proto
+++ b/pkg/mimirpb/mimir.proto
@@ -59,11 +59,11 @@ message ErrorDetails {
 }
 
 message TimeSeries {
-  repeated cortexpb_custom.LabelAdapter labels = 1 [(gogoproto.nullable) = false];
+  repeated cortexpb_custom.LabelAdapter labels = 1;
   // Sorted by time, oldest sample first.
-  repeated Sample samples = 2 [(gogoproto.nullable) = false];
-  repeated Exemplar exemplars = 3 [(gogoproto.nullable) = false];
-  repeated Histogram histograms = 4 [(gogoproto.nullable) = false];
+  repeated Sample samples = 2;
+  repeated Exemplar exemplars = 3;
+  repeated Histogram histograms = 4;
 }
 
 //message LabelPair {
@@ -96,12 +96,12 @@ message MetricMetadata {
 }
 
 message Metric {
-  repeated cortexpb_custom.LabelAdapter labels = 1 [(gogoproto.nullable) = false];
+  repeated cortexpb_custom.LabelAdapter labels = 1;
 }
 
 message Exemplar {
   // Exemplar labels, different than series labels
-  repeated cortexpb_custom.LabelAdapter labels = 1 [(gogoproto.nullable) = false];
+  repeated cortexpb_custom.LabelAdapter labels = 1;
   double value = 2;
   int64 timestamp_ms = 3;
 }
diff --git a/pkg/mimirpb/split_test.go b/pkg/mimirpb/split_test.go
index 5ddf7d0bd14..0974a537e30 100644
--- a/pkg/mimirpb/split_test.go
+++ b/pkg/mimirpb/split_test.go
@@ -21,13 +21,13 @@ func TestSplitWriteRequestByMaxMarshalSize(t *testing.T) {
 		Timeseries: []PreallocTimeseries{
 			{TimeSeries: &TimeSeries{
 				Labels:     FromLabelsToLabelAdapters(labels.FromStrings(labels.MetricName, "series_1", "pod", "test-application-123456")),
-				Samples:    []Sample{{TimestampMs: 20}},
-				Exemplars:  []Exemplar{{TimestampMs: 30}},
-				Histograms: []Histogram{{Timestamp: 10}},
+				Samples:    []*Sample{{TimestampMs: 20}},
+				Exemplars:  []*Exemplar{{TimestampMs: 30}},
+				Histograms: []*Histogram{{Timestamp: 10}},
 			}},
 			{TimeSeries: &TimeSeries{
 				Labels:  FromLabelsToLabelAdapters(labels.FromStrings(labels.MetricName, "series_2", "pod", "test-application-123456")),
-				Samples: []Sample{{TimestampMs: 30}},
+				Samples: []*Sample{{TimestampMs: 30}},
 			}},
 		},
 		Metadata: []*MetricMetadata{
@@ -298,9 +298,9 @@ func generateWriteRequest(numSeries, numLabelsPerSeries, numSamplesPerSeries, nu
 		curr.Labels = FromLabelsToLabelAdapters(builder.Labels())
 
 		// Generate samples.
-		curr.Samples = make([]Sample, 0, numSamplesPerSeries)
+		curr.Samples = make([]*Sample, 0, numSamplesPerSeries)
 		for s := 0; s < numSamplesPerSeries; s++ {
-			curr.Samples = append(curr.Samples, Sample{
+			curr.Samples = append(curr.Samples, &Sample{
 				TimestampMs: int64(s),
 				Value:       float64(s),
 			})
@@ -309,7 +309,7 @@ func generateWriteRequest(numSeries, numLabelsPerSeries, numSamplesPerSeries, nu
 		// Add an exemplar.
 		builder.Reset()
 		builder.Add("trace_id", fmt.Sprintf("the-trace-id-for-%d", i))
-		curr.Exemplars = []Exemplar{{
+		curr.Exemplars = []*Exemplar{{
 			Labels:      FromLabelsToLabelAdapters(builder.Labels()),
 			TimestampMs: int64(i),
 			Value:       float64(i),
diff --git a/pkg/mimirpb/timeseries.go b/pkg/mimirpb/timeseries.go
index 7415c9c85fa..f752c0644ad 100644
--- a/pkg/mimirpb/timeseries.go
+++ b/pkg/mimirpb/timeseries.go
@@ -35,9 +35,9 @@ var (
 	timeSeriesPool = sync.Pool{
 		New: func() interface{} {
 			return &TimeSeries{
-				Labels:     make([]mimirpb_custom.LabelAdapter, 0, minPreallocatedLabels),
-				Samples:    make([]Sample, 0, minPreallocatedSamplesPerSeries),
-				Exemplars:  make([]Exemplar, 0, minPreallocatedExemplarsPerSeries),
+				Labels:     make([]*mimirpb_custom.LabelAdapter, 0, minPreallocatedLabels),
+				Samples:    make([]*Sample, 0, minPreallocatedSamplesPerSeries),
+				Exemplars:  make([]*Exemplar, 0, minPreallocatedExemplarsPerSeries),
 				Histograms: nil,
 			}
 		},
@@ -107,7 +107,7 @@ func (p *PreallocTimeseries) RemoveLabel(labelName string) {
 	}
 }
 
-func (p *PreallocTimeseries) SetLabels(lbls []mimirpb_custom.LabelAdapter) {
+func (p *PreallocTimeseries) SetLabels(lbls []*mimirpb_custom.LabelAdapter) {
 	p.Labels = lbls
 
 	// We can't reuse raw unmarshalled data for the timeseries after setting new labels.
@@ -147,7 +147,7 @@ func (p *PreallocTimeseries) SortLabelsIfNeeded() {
 		return
 	}
 
-	slices.SortFunc(p.Labels, func(a, b mimirpb_custom.LabelAdapter) int {
+	slices.SortFunc(p.Labels, func(a, b *mimirpb_custom.LabelAdapter) int {
 		switch {
 		case a.Name < b.Name:
 			return -1
@@ -384,7 +384,7 @@ func DeepCopyTimeseries(dst, src PreallocTimeseries, keepHistograms, keepExempla
 
 	// Copy the samples.
 	if cap(dstTs.Samples) < len(srcTs.Samples) {
-		dstTs.Samples = make([]Sample, len(srcTs.Samples))
+		dstTs.Samples = make([]*Sample, len(srcTs.Samples))
 	} else {
 		dstTs.Samples = dstTs.Samples[:len(srcTs.Samples)]
 	}
@@ -393,7 +393,7 @@ func DeepCopyTimeseries(dst, src PreallocTimeseries, keepHistograms, keepExempla
 	// Copy the histograms.
 	if keepHistograms {
 		if cap(dstTs.Histograms) < len(srcTs.Histograms) {
-			dstTs.Histograms = make([]Histogram, len(srcTs.Histograms))
+			dstTs.Histograms = make([]*Histogram, len(srcTs.Histograms))
 		} else {
 			dstTs.Histograms = dstTs.Histograms[:len(srcTs.Histograms)]
 		}
@@ -407,18 +407,20 @@ func DeepCopyTimeseries(dst, src PreallocTimeseries, keepHistograms, keepExempla
 	// Prepare the slice of exemplars.
 	if keepExemplars {
 		if cap(dstTs.Exemplars) < len(srcTs.Exemplars) {
-			dstTs.Exemplars = make([]Exemplar, len(srcTs.Exemplars))
+			dstTs.Exemplars = make([]*Exemplar, len(srcTs.Exemplars))
 		} else {
 			dstTs.Exemplars = dstTs.Exemplars[:len(srcTs.Exemplars)]
 		}
 
 		for exemplarIdx := range srcTs.Exemplars {
+			dstExemplar := &Exemplar{}
 			// Copy the exemplar labels by using the prepared buffer.
-			dstTs.Exemplars[exemplarIdx].Labels, buf = copyToYoloLabels(buf, dstTs.Exemplars[exemplarIdx].Labels, srcTs.Exemplars[exemplarIdx].Labels)
+			dstExemplar.Labels, buf = copyToYoloLabels(buf, dstExemplar.Labels, srcTs.Exemplars[exemplarIdx].Labels)
 
 			// Copy the other exemplar properties.
-			dstTs.Exemplars[exemplarIdx].Value = srcTs.Exemplars[exemplarIdx].Value
-			dstTs.Exemplars[exemplarIdx].TimestampMs = srcTs.Exemplars[exemplarIdx].TimestampMs
+			dstExemplar.Value = srcTs.Exemplars[exemplarIdx].Value
+			dstExemplar.TimestampMs = srcTs.Exemplars[exemplarIdx].TimestampMs
+			dstTs.Exemplars[exemplarIdx] = dstExemplar
 		}
 	} else {
 		dstTs.Exemplars = dstTs.Exemplars[:0]
@@ -461,16 +463,18 @@ func countTotalLabelLen(ts *TimeSeries, includeExemplars bool) int {
 
 // copyToYoloLabels copies the values of src to dst, it uses the given buffer to store all the string values in it.
 // The returned buffer is the remainder of the given buffer, which remains unused after the copying is complete.
-func copyToYoloLabels(buf []byte, dst, src []mimirpb_custom.LabelAdapter) ([]mimirpb_custom.LabelAdapter, []byte) {
+func copyToYoloLabels(buf []byte, dst, src []*mimirpb_custom.LabelAdapter) ([]*mimirpb_custom.LabelAdapter, []byte) {
 	if cap(dst) < len(src) {
-		dst = make([]mimirpb_custom.LabelAdapter, len(src))
+		dst = make([]*mimirpb_custom.LabelAdapter, len(src))
 	} else {
 		dst = dst[:len(src)]
 	}
 
 	for labelIdx := range src {
-		dst[labelIdx].Name, buf = copyToYoloString(buf, src[labelIdx].Name)
-		dst[labelIdx].Value, buf = copyToYoloString(buf, src[labelIdx].Value)
+		dstLabel := &mimirpb_custom.LabelAdapter{}
+		dstLabel.Name, buf = copyToYoloString(buf, src[labelIdx].Name)
+		dstLabel.Value, buf = copyToYoloString(buf, src[labelIdx].Value)
+		dst[labelIdx] = dstLabel
 	}
 
 	return dst, buf
@@ -486,7 +490,7 @@ func copyToYoloString(buf []byte, src string) (string, []byte) {
 
 // copyHistogram copies the given histogram by value.
 // The returned histogram does not share any memory with the given one.
-func copyHistogram(src Histogram) Histogram {
+func copyHistogram(src *Histogram) *Histogram {
 	var (
 		dstCount     isHistogram_Count
 		dstZeroCount isHistogram_ZeroCount
@@ -507,7 +511,7 @@ func copyHistogram(src Histogram) Histogram {
 		dstZeroCount = &Histogram_ZeroCountFloat{ZeroCountFloat: src.GetZeroCountFloat()}
 	}
 
-	return Histogram{
+	return &Histogram{
 		Count:          dstCount,
 		Sum:            src.Sum,
 		Schema:         src.Schema,
diff --git a/pkg/mimirpb/timeseries_test.go b/pkg/mimirpb/timeseries_test.go
index b3c8de15d59..39de9a2e6a6 100644
--- a/pkg/mimirpb/timeseries_test.go
+++ b/pkg/mimirpb/timeseries_test.go
@@ -69,8 +69,8 @@ func TestTimeseriesFromPool(t *testing.T) {
 
 	t.Run("instance is cleaned before reusing", func(t *testing.T) {
 		ts := TimeseriesFromPool()
-		ts.Labels = []mimirpb_custom.LabelAdapter{{Name: "foo", Value: "bar"}}
-		ts.Samples = []Sample{{Value: 1, TimestampMs: 2}}
+		ts.Labels = []*mimirpb_custom.LabelAdapter{{Name: "foo", Value: "bar"}}
+		ts.Samples = []*Sample{{Value: 1, TimestampMs: 2}}
 		ReuseTimeseries(ts)
 
 		reused := TimeseriesFromPool()
@@ -115,15 +115,15 @@ func TestCopyToYoloString(t *testing.T) {
 func TestDeepCopyTimeseries(t *testing.T) {
 	src := PreallocTimeseries{
 		TimeSeries: &TimeSeries{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "sampleLabel1", Value: "sampleValue1"},
 				{Name: "sampleLabel2", Value: "sampleValue2"},
 			},
-			Samples: []Sample{
+			Samples: []*Sample{
 				{Value: 1, TimestampMs: 2},
 				{Value: 3, TimestampMs: 4},
 			},
-			Histograms: []Histogram{
+			Histograms: []*Histogram{
 				{
 					Timestamp:      4*time.Minute.Milliseconds() - 1,
 					Count:          &Histogram_CountInt{CountInt: 35},
@@ -137,10 +137,10 @@ func TestDeepCopyTimeseries(t *testing.T) {
 					ResetHint:      Histogram_UNKNOWN,
 				},
 			},
-			Exemplars: []Exemplar{{
+			Exemplars: []*Exemplar{{
 				Value:       1,
 				TimestampMs: 2,
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "exemplarLabel1", Value: "exemplarValue1"},
 					{Name: "exemplarLabel2", Value: "exemplarValue2"},
 				},
@@ -246,11 +246,11 @@ func TestDeepCopyTimeseries(t *testing.T) {
 func TestDeepCopyTimeseriesExemplars(t *testing.T) {
 	src := PreallocTimeseries{
 		TimeSeries: &TimeSeries{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "sampleLabel1", Value: "sampleValue1"},
 				{Name: "sampleLabel2", Value: "sampleValue2"},
 			},
-			Samples: []Sample{
+			Samples: []*Sample{
 				{Value: 1, TimestampMs: 2},
 				{Value: 3, TimestampMs: 4},
 			},
@@ -258,10 +258,10 @@ func TestDeepCopyTimeseriesExemplars(t *testing.T) {
 	}
 
 	for i := 0; i < 100; i++ {
-		src.Exemplars = append(src.Exemplars, Exemplar{
+		src.Exemplars = append(src.Exemplars, &Exemplar{
 			Value:       1,
 			TimestampMs: 2,
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "exemplarLabel1", Value: "exemplarValue1"},
 				{Name: "exemplarLabel2", Value: "exemplarValue2"},
 			},
@@ -288,11 +288,11 @@ func TestPreallocTimeseries_Unmarshal(t *testing.T) {
 	{
 		src := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "sampleLabel1", Value: "sampleValue1"},
 					{Name: "sampleLabel2", Value: "sampleValue2"},
 				},
-				Samples: []Sample{
+				Samples: []*Sample{
 					{Value: 1, TimestampMs: 2},
 					{Value: 3, TimestampMs: 4},
 				},
@@ -382,7 +382,7 @@ func TestPreallocTimeseries_SortLabelsIfNeeded(t *testing.T) {
 	t.Run("sorted", func(t *testing.T) {
 		sorted := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "bar", Value: "baz"},
 					{Name: "cluster", Value: "cluster"},
@@ -401,7 +401,7 @@ func TestPreallocTimeseries_SortLabelsIfNeeded(t *testing.T) {
 	t.Run("unsorted", func(t *testing.T) {
 		unsorted := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "sample", Value: "1"},
 					{Name: "cluster", Value: "cluster"},
@@ -424,7 +424,7 @@ func TestPreallocTimeseries_RemoveLabel(t *testing.T) {
 	t.Run("with label", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "bar", Value: "baz"},
 				},
@@ -433,14 +433,14 @@ func TestPreallocTimeseries_RemoveLabel(t *testing.T) {
 		}
 		p.RemoveLabel("bar")
 
-		require.Equal(t, []mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}}, p.Labels)
+		require.Equal(t, []*mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}}, p.Labels)
 		require.Nil(t, p.marshalledData)
 	})
 
 	t.Run("with no matching label", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "bar", Value: "baz"},
 				},
@@ -449,7 +449,7 @@ func TestPreallocTimeseries_RemoveLabel(t *testing.T) {
 		}
 		p.RemoveLabel("foo")
 
-		require.Equal(t, []mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
+		require.Equal(t, []*mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
 		require.NotNil(t, p.marshalledData)
 	})
 }
@@ -458,7 +458,7 @@ func TestPreallocTimeseries_RemoveEmptyLabelValues(t *testing.T) {
 	t.Run("with empty labels", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "empty1", Value: ""},
 					{Name: "bar", Value: "baz"},
@@ -469,14 +469,14 @@ func TestPreallocTimeseries_RemoveEmptyLabelValues(t *testing.T) {
 		}
 		p.RemoveEmptyLabelValues()
 
-		require.Equal(t, []mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
+		require.Equal(t, []*mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
 		require.Nil(t, p.marshalledData)
 	})
 
 	t.Run("without empty labels", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Labels: []mimirpb_custom.LabelAdapter{
+				Labels: []*mimirpb_custom.LabelAdapter{
 					{Name: "__name__", Value: "foo"},
 					{Name: "bar", Value: "baz"},
 				},
@@ -485,7 +485,7 @@ func TestPreallocTimeseries_RemoveEmptyLabelValues(t *testing.T) {
 		}
 		p.RemoveLabel("foo")
 
-		require.Equal(t, []mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
+		require.Equal(t, []*mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "foo"}, {Name: "bar", Value: "baz"}}, p.Labels)
 		require.NotNil(t, p.marshalledData)
 	})
 }
@@ -493,14 +493,14 @@ func TestPreallocTimeseries_RemoveEmptyLabelValues(t *testing.T) {
 func TestPreallocTimeseries_SetLabels(t *testing.T) {
 	p := PreallocTimeseries{
 		TimeSeries: &TimeSeries{
-			Labels: []mimirpb_custom.LabelAdapter{
+			Labels: []*mimirpb_custom.LabelAdapter{
 				{Name: "__name__", Value: "foo"},
 				{Name: "bar", Value: "baz"},
 			},
 		},
 		marshalledData: []byte{1, 2, 3},
 	}
-	expected := []mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "hello"}, {Name: "lbl", Value: "world"}}
+	expected := []*mimirpb_custom.LabelAdapter{{Name: "__name__", Value: "hello"}, {Name: "lbl", Value: "world"}}
 	p.SetLabels(expected)
 
 	require.Equal(t, expected, p.Labels)
@@ -511,13 +511,13 @@ func TestPreallocTimeseries_ResizeExemplars(t *testing.T) {
 	t.Run("should resize Exemplars when size is bigger than target size", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Exemplars: make([]Exemplar, 10),
+				Exemplars: make([]*Exemplar, 10),
 			},
 			marshalledData: []byte{1, 2, 3},
 		}
 
 		for i := range p.Exemplars {
-			p.Exemplars[i] = Exemplar{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: int64(i)}
+			p.Exemplars[i] = &Exemplar{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: int64(i)}
 		}
 		p.ResizeExemplars(5)
 		require.Len(t, p.Exemplars, 5)
@@ -531,16 +531,16 @@ func BenchmarkPreallocTimeseries_SortLabelsIfNeeded(b *testing.B) {
 	for _, lbCount := range bcs {
 		b.Run(fmt.Sprintf("num_labels=%d", lbCount), func(b *testing.B) {
 			// Generate labels set in reverse order for worst case.
-			unorderedLabels := make([]mimirpb_custom.LabelAdapter, 0, lbCount)
+			unorderedLabels := make([]*mimirpb_custom.LabelAdapter, 0, lbCount)
 			for i := 0; i < lbCount; i++ {
 				lbName := fmt.Sprintf("lbl_%d", lbCount-i)
 				lbValue := fmt.Sprintf("val_%d", lbCount-i)
-				unorderedLabels = append(unorderedLabels, mimirpb_custom.LabelAdapter{Name: lbName, Value: lbValue})
+				unorderedLabels = append(unorderedLabels, &mimirpb_custom.LabelAdapter{Name: lbName, Value: lbValue})
 			}
 
 			b.Run("unordered", benchmarkSortLabelsIfNeeded(unorderedLabels))
 
-			slices.SortFunc(unorderedLabels, func(a, b mimirpb_custom.LabelAdapter) int {
+			slices.SortFunc(unorderedLabels, func(a, b *mimirpb_custom.LabelAdapter) int {
 				switch {
 				case a.Name < b.Name:
 					return -1
@@ -555,12 +555,12 @@ func BenchmarkPreallocTimeseries_SortLabelsIfNeeded(b *testing.B) {
 	}
 }
 
-func benchmarkSortLabelsIfNeeded(inputLabels []mimirpb_custom.LabelAdapter) func(b *testing.B) {
+func benchmarkSortLabelsIfNeeded(inputLabels []*mimirpb_custom.LabelAdapter) func(b *testing.B) {
 	return func(b *testing.B) {
 		// Copy unordered labels set for each benchmark iteration.
-		benchmarkUnorderedLabels := make([][]mimirpb_custom.LabelAdapter, b.N)
+		benchmarkUnorderedLabels := make([][]*mimirpb_custom.LabelAdapter, b.N)
 		for i := 0; i < b.N; i++ {
-			benchmarkLabels := make([]mimirpb_custom.LabelAdapter, len(inputLabels))
+			benchmarkLabels := make([]*mimirpb_custom.LabelAdapter, len(inputLabels))
 			copy(benchmarkLabels, inputLabels)
 			benchmarkUnorderedLabels[i] = benchmarkLabels
 		}
@@ -580,14 +580,14 @@ func benchmarkSortLabelsIfNeeded(inputLabels []mimirpb_custom.LabelAdapter) func
 
 func TestClearExemplars(t *testing.T) {
 	t.Run("should reset TimeSeries.Exemplars keeping the slices if there are <= 10 entries", func(t *testing.T) {
-		ts := &TimeSeries{Exemplars: []Exemplar{
-			{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 2},
-			{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "2"}, {Name: "service", Value: "B"}}, Value: 2, TimestampMs: 3},
+		ts := &TimeSeries{Exemplars: []*Exemplar{
+			{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 2},
+			{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "2"}, {Name: "service", Value: "B"}}, Value: 2, TimestampMs: 3},
 		}}
 
 		ClearExemplars(ts)
 
-		assert.Equal(t, &TimeSeries{Exemplars: []Exemplar{}}, ts)
+		assert.Equal(t, &TimeSeries{Exemplars: []*Exemplar{}}, ts)
 		assert.Equal(t, 2, cap(ts.Exemplars))
 
 		ts.Exemplars = ts.Exemplars[:2]
@@ -597,9 +597,9 @@ func TestClearExemplars(t *testing.T) {
 	})
 
 	t.Run("should reset TimeSeries.Exemplars releasing the slices if there are > 10 entries", func(t *testing.T) {
-		ts := &TimeSeries{Exemplars: make([]Exemplar, 11)}
+		ts := &TimeSeries{Exemplars: make([]*Exemplar, 11)}
 		for i := range ts.Exemplars {
-			ts.Exemplars[i] = Exemplar{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 2}
+			ts.Exemplars[i] = &Exemplar{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 2}
 		}
 
 		ClearExemplars(ts)
@@ -613,9 +613,9 @@ func TestSortExemplars(t *testing.T) {
 	t.Run("should sort TimeSeries.Exemplars in order", func(t *testing.T) {
 		p := PreallocTimeseries{
 			TimeSeries: &TimeSeries{
-				Exemplars: []Exemplar{
-					{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 3},
-					{Labels: []mimirpb_custom.LabelAdapter{{Name: "trace", Value: "2"}, {Name: "service", Value: "B"}}, Value: 2, TimestampMs: 2},
+				Exemplars: []*Exemplar{
+					{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "1"}, {Name: "service", Value: "A"}}, Value: 1, TimestampMs: 3},
+					{Labels: []*mimirpb_custom.LabelAdapter{{Name: "trace", Value: "2"}, {Name: "service", Value: "B"}}, Value: 2, TimestampMs: 2},
 				},
 			},
 			marshalledData: []byte{1, 2, 3},