Merge remote-tracking branch 'upstream/narthex' into feat/narthex-instant-eval-pr

# Conflicts:
#	src/promql/src/lib.rs

Cargo.lock

@@ -11370,6 +11370,8 @@ dependencies = [
  "lazy_static",
  "prometheus 0.14.0",
  "prost 0.14.1",
+ "rand 0.9.4",
+ "regex",
  "snafu 0.8.6",
  "tokio",
 ]

config/config.md

@@ -140,6 +140,7 @@
 | `procedure.retry_delay` | String | `500ms` | Initial retry delay of procedures, increases exponentially |
 | `procedure.max_running_procedures` | Integer | `128` | Max running procedures.<br/>The maximum number of procedures that can be running at the same time.<br/>If the number of running procedures exceeds this limit, the procedure will be rejected. |
 | `query` | -- | -- | The query engine options. |
+| `query.experimental_native_promql` | Bool | `false` | Whether to enable experimental native PromQL execution.<br/>Default: false |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
 | `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
@@ -383,6 +384,7 @@
 | `meta_client.metadata_cache_ttl` | String | `10m` | TTL of the metadata cache. |
 | `meta_client.metadata_cache_tti` | String | `5m` | -- |
 | `query` | -- | -- | The query engine options. |
+| `query.experimental_native_promql` | Bool | `false` | Whether to enable experimental native PromQL execution.<br/>Default: false |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
 | `query.allow_query_fallback` | Bool | `false` | Whether to allow query fallback when push down optimize fails.<br/>Default to false, meaning when push down optimize failed, return error msg |
 | `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "4GB", "8GB") or percentage of system memory (e.g., "30%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans (only applies to datanodes). |
@@ -613,6 +615,7 @@
 | `wal.max_unpersisted_age` | String | `8s` | The age of the oldest unpersisted entry at which new appends stall until an upload completes, in `enqueued` mode.<br/>**It's only used when the provider is `experimental_object_store` and `ack_mode` is `enqueued`**. |
 | `wal.on_corrupted_segment` | String | `skip` | What a read does with a segment that still does not decode after a second fetch, because its checksum does not match or its content disagrees with its footer entry.<br/>- `skip`: the segment is skipped and recorded as a WAL hole of its region, a metric is incremented and a warning is logged; the other regions of the object are unaffected (the default).<br/>- `fail`: the read fails, so the region does not open.<br/>**It's only used when the provider is `experimental_object_store`**. |
 | `query` | -- | -- | The query engine options. |
+| `query.experimental_native_promql` | Bool | `false` | Whether to enable experimental native PromQL execution.<br/>Default: false |
 | `query.parallelism` | Integer | `0` | Parallelism of the query engine.<br/>Default to 0, which means the number of CPU cores. |
 | `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "2GB", "4GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |
@@ -799,6 +802,7 @@
 | `tracing` | -- | -- | The tracing options. Only effect when compiled with `tokio-console` feature. |
 | `tracing.tokio_console_addr` | String | Unset | The tokio console address. |
 | `query` | -- | -- | -- |
+| `query.experimental_native_promql` | Bool | `false` | Whether to enable experimental native PromQL execution.<br/>Default: false |
 | `query.parallelism` | Integer | `1` | Parallelism of the query engine for query sent by flownode.<br/>Default to 1, so it won't use too much cpu or memory |
 | `query.memory_pool_size` | String | 0 | Memory pool size for query execution operators (aggregation, sorting, join).<br/>Supports absolute size (e.g., "1GB", "2GB") or percentage of system memory (e.g., "20%").<br/>Setting it to 0 disables the limit. Defaults to 0 (unlimited); this example sets it to `50%`.<br/>When this limit is reached, queries will fail with ResourceExhausted error.<br/>NOTE: This does NOT limit memory used by table scans. |
 | `query.experimental_memory_pool_policy` | String | `greedy` | Experimental memory pool allocation policy:<br/>- "greedy" (default): first-come-first-served allocation; preserves current behavior.<br/>- "fair": divides available memory among spillable operators and may spill earlier.<br/>Only effective when `memory_pool_size` is bounded (>0). |

config/datanode.example.toml

@@ -326,6 +326,10 @@ overwrite_entry_start_id = false
 
 ## The query engine options.
 [query]
+
+## Whether to enable experimental native PromQL execution.
+## Default: false
+#+ experimental_native_promql = false
 ## Parallelism of the query engine.
 ## Default to 0, which means the number of CPU cores.
 parallelism = 0

config/flownode.example.toml

@@ -151,6 +151,10 @@ default_ratio = 1.0
 #+ tokio_console_addr = "127.0.0.1"
 
 [query]
+
+## Whether to enable experimental native PromQL execution.
+## Default: false
+#+ experimental_native_promql = false
 ## Parallelism of the query engine for query sent by flownode.
 ## Default to 1, so it won't use too much cpu or memory
 parallelism = 1

config/frontend.example.toml

@@ -359,6 +359,10 @@ metadata_cache_tti = "5m"
 
 ## The query engine options.
 [query]
+
+## Whether to enable experimental native PromQL execution.
+## Default: false
+#+ experimental_native_promql = false
 ## Parallelism of the query engine.
 ## Default to 0, which means the number of CPU cores.
 parallelism = 0

config/standalone.example.toml

@@ -537,6 +537,10 @@ max_running_procedures = 128
 
 ## The query engine options.
 [query]
+
+## Whether to enable experimental native PromQL execution.
+## Default: false
+#+ experimental_native_promql = false
 ## Parallelism of the query engine.
 ## Default to 0, which means the number of CPU cores.
 parallelism = 0

src/common/query/src/series_frame.rs

@@ -29,9 +29,11 @@ use std::task::{Context, Poll};
 use common_error::ext::BoxedError;
 use common_recordbatch::{DfRecordBatch, DfSendableRecordBatchStream};
 use datafusion_common::DataFusionError;
+use datatypes::arrow::datatypes::{Schema as ArrowSchema, SchemaRef as ArrowSchemaRef};
 use datatypes::error::InvalidSeriesSnafu;
 use datatypes::series::frame::{
     RawLabelMode, RawSeriesChunkCursor, RawSeriesFrameBuilder, RawSeriesFrameDecoder,
+    raw_series_frame_schema,
 };
 use datatypes::series::raw::RawSeriesChunk;
 use datatypes::series::samples::SeriesSchema;
@@ -42,6 +44,48 @@ use store_api::region_engine::{RawLabelSource, RawSeriesStream, SendableRawSerie
 #[cfg(test)]
 mod tests;
 
+const ORDERING_KEY: &str = "greptime.series.ordering";
+
+/// Builds the canonical raw frame schema with the producer's guaranteed ordering.
+///
+/// Ordering records a producer guarantee; it is not inferred from frame contents. `Interleaved`
+/// has no v1 wire representation and is rejected before the schema is assembled.
+pub fn raw_series_frame_schema_with_ordering(
+    schema: &SeriesSchema,
+    mode: RawLabelMode,
+    ordering: SeriesOrdering,
+) -> datafusion_common::Result<ArrowSchemaRef> {
+    let ordering = match ordering {
+        SeriesOrdering::Contiguous => "contiguous",
+        SeriesOrdering::KeyThenTime => "read_key_then_time",
+        SeriesOrdering::Interleaved => {
+            return Err(invalid(
+                "interleaved raw series ordering has no wire representation",
+            ));
+        }
+    };
+    let schema = raw_series_frame_schema(schema, mode).map_err(codec_error)?;
+    let mut metadata = schema.metadata().clone();
+    metadata.insert(ORDERING_KEY.to_string(), ordering.to_string());
+    Ok(Arc::new(ArrowSchema::new_with_metadata(
+        schema.fields().clone(),
+        metadata,
+    )))
+}
+
+/// Reads the declared producer ordering, conservatively treating legacy frames as contiguous.
+///
+/// Only the two orderings representable on the wire can be returned.
+pub fn raw_series_frame_ordering(
+    schema: &ArrowSchema,
+) -> datafusion_common::Result<SeriesOrdering> {
+    match schema.metadata().get(ORDERING_KEY).map(String::as_str) {
+        None | Some("contiguous") => Ok(SeriesOrdering::Contiguous),
+        Some("read_key_then_time") => Ok(SeriesOrdering::KeyThenTime),
+        Some(_) => Err(invalid("unknown raw series ordering")),
+    }
+}
+
 /// Packs a storage raw-series stream into DataFusion record batches incrementally.
 ///
 /// Only [`SeriesOrdering::Contiguous`] and [`SeriesOrdering::KeyThenTime`] streams are
@@ -59,6 +103,9 @@ pub fn pack_raw_series(
     let schema = source.schema().clone();
     let label_source = source.label_source().clone();
     let mode = label_mode(&label_source);
+    // The declared frame schema carries the producer ordering; the shared builder's schema
+    // intentionally omits it, so every ready batch is declared before it is yielded.
+    let frame_schema = raw_series_frame_schema_with_ordering(&schema, mode, ordering)?;
     let builder = RawSeriesFrameBuilder::try_new(
         &schema,
         mode,
@@ -66,7 +113,6 @@ pub fn pack_raw_series(
         RawSeriesFrameBuilder::DEFAULT_MAX_BYTES,
     )
     .map_err(codec_error)?;
-    let frame_schema = builder.schema().clone();
     Ok(Box::pin(PackStream {
         source: Some(source),
         schema,
@@ -265,6 +311,22 @@ impl PackStream {
             None => Ok(None),
         }
     }
+
+    /// Publishes one ready builder batch under the declared frame schema, which is the shared
+    /// builder's schema plus the producer's ordering metadata. A batch whose fields cannot be
+    /// declared releases the stream instead of yielding rows with an undeclared layout.
+    fn declare_batch(
+        &mut self,
+        batch: DfRecordBatch,
+    ) -> Poll<Option<datafusion_common::Result<DfRecordBatch>>> {
+        match batch.with_schema(self.frame_schema.clone()) {
+            Ok(batch) => Poll::Ready(Some(Ok(batch))),
+            Err(error) => {
+                self.finish();
+                Poll::Ready(Some(Err(DataFusionError::from(error))))
+            }
+        }
+    }
 }
 
 impl Stream for PackStream {
@@ -274,7 +336,7 @@ impl Stream for PackStream {
         let this = &mut *self;
         loop {
             match this.advance_cursor() {
-                Ok(Some(batch)) => return Poll::Ready(Some(Ok(batch))),
+                Ok(Some(batch)) => return this.declare_batch(batch),
                 Ok(None) => {}
                 Err(error) => {
                     this.finish();
@@ -289,7 +351,7 @@ impl Stream for PackStream {
                 Poll::Pending => {
                     let flushed = this.flush_buffered();
                     return match flushed {
-                        Ok(Some(batch)) => Poll::Ready(Some(Ok(batch))),
+                        Ok(Some(batch)) => this.declare_batch(batch),
                         Ok(None) => Poll::Pending,
                         Err(error) => {
                             this.finish();
@@ -305,7 +367,7 @@ impl Stream for PackStream {
                     let flushed = this.flush_buffered();
                     this.finish();
                     return match flushed {
-                        Ok(Some(batch)) => Poll::Ready(Some(Ok(batch))),
+                        Ok(Some(batch)) => this.declare_batch(batch),
                         Ok(None) => Poll::Ready(None),
                         Err(error) => Poll::Ready(Some(Err(codec_error(error)))),
                     };

src/common/query/src/series_frame/tests.rs

@@ -14,7 +14,7 @@
 
 mod lifecycle;
 
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
 use std::io::Cursor;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -34,6 +34,7 @@ use datatypes::arrow::record_batch::RecordBatch;
 use datatypes::series::Label;
 use datatypes::series::MetricName;
 use datatypes::series::SeriesOrdering;
+use datatypes::series::frame::{RawLabelMode, raw_series_frame_schema};
 use datatypes::series::histogram::{BucketSideView, CounterResetHint, HistogramBatchBuilder};
 use datatypes::series::raw::{RawSeriesChunk, RawTimestamps};
 use datatypes::series::samples::{
@@ -44,7 +45,7 @@ use store_api::region_engine::{
     BoundTag, RawLabelSource, RawSeriesStream, SendableRawSeriesStream,
 };
 
-use super::{pack_raw_series, unpack_raw_series};
+use super::{pack_raw_series, raw_series_frame_ordering, unpack_raw_series};
 
 fn schema() -> Arc<SeriesSchema> {
     Arc::new(SeriesSchema {
@@ -2383,9 +2384,20 @@ async fn public_chunk_with_empty_times_is_rejected_without_panic() {
 }
 
 /// `Interleaved` is rejected by the constructor before any source poll, for a pack source and for
-/// an empty unpack stream; no adjacent-only fallback is installed.
+/// an empty unpack stream; the wire-schema helper rejects it before assembling a schema, since no
+/// v1 metadata value represents it. No adjacent-only fallback is installed.
 #[tokio::test]
 async fn interleaved_ordering_is_rejected_before_any_poll() {
+    assert!(
+        super::raw_series_frame_schema_with_ordering(
+            &schema(),
+            datatypes::series::frame::RawLabelMode::Explicit,
+            SeriesOrdering::Interleaved,
+        )
+        .is_err(),
+        "interleaved cannot be declared on the wire schema"
+    );
+
     let (source, polls, drops) = raw_never_polled(SeriesOrdering::Interleaved);
     let error = match pack_raw_series(source) {
         Ok(_) => panic!("interleaved pack stream must be rejected"),
@@ -2493,3 +2505,126 @@ async fn unpack_rejects_unrelated_metadata_drift_and_empty_schema_changes() {
         assert!(unpacked.next().await.is_none(), "{label}");
     }
 }
+
+#[test]
+fn raw_series_ordering_metadata_fixture() {
+    #[derive(serde::Deserialize)]
+    struct Case {
+        name: String,
+        metadata: HashMap<String, String>,
+        ordering: Option<String>,
+    }
+
+    let cases: Vec<Case> = serde_json::from_str(include_str!(
+        "../../../../../tests/compatibility/wire/raw_series_ordering/v1_metadata.json"
+    ))
+    .unwrap();
+    for case in cases {
+        let literal_ordering = match case.ordering.as_deref() {
+            Some("contiguous") => Some(SeriesOrdering::Contiguous),
+            Some("read_key_then_time") => Some(SeriesOrdering::KeyThenTime),
+            Some(value) => panic!("{} has invalid fixture ordering {value}", case.name),
+            None => None,
+        };
+        let frame_schema = raw_series_frame_schema(&schema(), RawLabelMode::Explicit).unwrap();
+        let frame_schema = frame_schema.as_ref().clone().with_metadata(case.metadata);
+        match literal_ordering {
+            Some(expected) => assert_eq!(
+                raw_series_frame_ordering(&frame_schema)
+                    .unwrap_or_else(|error| panic!("{}: {error}", case.name)),
+                expected,
+                "{}",
+                case.name
+            ),
+            None => assert!(
+                raw_series_frame_ordering(&frame_schema).is_err(),
+                "{}",
+                case.name
+            ),
+        }
+    }
+}
+
+#[tokio::test]
+async fn pack_declares_ordering_on_every_batch_and_ipc_roundtrips_it() {
+    for ordering in [SeriesOrdering::Contiguous, SeriesOrdering::KeyThenTime] {
+        for chunks in [
+            vec![
+                chunk_with(b"a", &[1], vec![Some(1.0)], Some(metric()), false),
+                chunk_with(b"a", &[2], vec![None], Some(metric()), true),
+                chunk_with(b"b", &[3], vec![Some(3.0)], Some(metric()), true),
+            ],
+            vec![],
+        ] {
+            let is_empty = chunks.is_empty();
+            // The bounded multi-row builder coalesces these three rows into one batch; the
+            // replaced single-row packing emitted one batch per chunk.
+            let expected_batch_count = if is_empty { 0 } else { 1 };
+            let canonical_schema =
+                raw_series_frame_schema(&schema(), RawLabelMode::Explicit).unwrap();
+            let mut expected_metadata = canonical_schema.metadata().clone();
+            expected_metadata.insert(
+                "greptime.series.ordering".to_string(),
+                match ordering {
+                    SeriesOrdering::Contiguous => "contiguous",
+                    SeriesOrdering::KeyThenTime => "read_key_then_time",
+                    // The v1 wire carries exactly these two spellings, so the loop above
+                    // admits only the two representable modes; `Interleaved` is rejected
+                    // before any poll (see `interleaved_ordering_is_rejected_before_any_poll`).
+                    SeriesOrdering::Interleaved => {
+                        unreachable!("interleaved raw series ordering has no wire spelling")
+                    }
+                }
+                .to_string(),
+            );
+            let (input, _, _) = raw(chunks, ordering);
+            let mut packed = pack_raw_series(input).unwrap();
+            let declared = packed.schema();
+            assert_eq!(declared.fields(), canonical_schema.fields());
+            assert_eq!(declared.metadata(), &expected_metadata);
+            assert_eq!(raw_series_frame_ordering(&declared).unwrap(), ordering);
+            let mut batches = Vec::new();
+            while let Some(batch) = packed.next().await {
+                let batch = batch.unwrap();
+                assert_eq!(batch.schema(), declared);
+                batches.push(batch);
+            }
+
+            let mut ipc = Vec::new();
+            {
+                let mut writer = StreamWriter::try_new(&mut ipc, &declared).unwrap();
+                for batch in &batches {
+                    writer.write(batch).unwrap();
+                }
+                writer.finish().unwrap();
+            }
+            let reader = StreamReader::try_new(Cursor::new(ipc), None).unwrap();
+            assert_eq!(reader.schema(), declared);
+            assert_eq!(
+                raw_series_frame_ordering(&reader.schema()).unwrap(),
+                ordering
+            );
+            let ipc_batches = reader.map(Result::unwrap).collect::<Vec<_>>();
+            assert_eq!(ipc_batches.len(), batches.len());
+            assert_eq!(ipc_batches.len(), expected_batch_count);
+            assert!(ipc_batches.iter().all(|batch| batch.schema() == declared));
+            let (source, _, _) = df_source(ipc_batches, declared);
+            let mut decoded =
+                unpack_raw_series(source, schema(), RawLabelSource::Explicit, ordering).unwrap();
+            if is_empty {
+                assert!(decoded.next().await.is_none());
+            } else {
+                for (key, time, value, last) in [
+                    (b"a".as_slice(), 1, Some(1.0), false),
+                    (b"a".as_slice(), 2, None, true),
+                    (b"b".as_slice(), 3, Some(3.0), true),
+                ] {
+                    let actual = decoded.next().await.unwrap().unwrap();
+                    assert_chunk(&actual, key, &[time], &[value], last);
+                    assert_metric(&actual, None);
+                }
+                assert!(decoded.next().await.is_none());
+            }
+        }
+    }
+}

src/mito-codec/src/labels.rs

@@ -0,0 +1,264 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use api::v1::SemanticType;
+use common_telemetry::debug;
+use datatypes::series::{Label, MetricName};
+use datatypes::value::Value;
+use snafu::OptionExt;
+use store_api::codec::PrimaryKeyEncoding;
+use store_api::metadata::RegionMetadataRef;
+use store_api::metric_engine_consts::is_metric_engine_internal_column;
+use store_api::region_engine::RawLabelSource;
+use store_api::storage::{
+    ColumnId,
+    consts::{ReservedColumnId, is_internal_column},
+};
+
+use crate::error::{
+    InvalidDensePrimaryKeySnafu, InvalidSparsePrimaryKeySnafu, Result, UnsupportedOperationSnafu,
+};
+use crate::row_converter::dense::DensePrimaryKeyCodec;
+use crate::row_converter::sparse::{SparseOffsetsCache, SparsePrimaryKeyView};
+
+/// Selects labels materialized from a primary key.
+///
+/// `All` produces a complete metric name and label set. `Only` produces a projected
+/// label vector, including `__name__` only when explicitly requested. Unexplained sparse
+/// column IDs are errors with `All`; `Only` skips them after checking their framing.
+#[derive(Clone, Debug, Default)]
+pub enum LabelProjection {
+    #[default]
+    All,
+    Only(Arc<[Arc<str>]>),
+}
+
+/// Decoded labels: either a complete metric name or a possibly partial label vector.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DecodedLabels {
+    Complete(MetricName),
+    Projected(Vec<Label>),
+}
+
+enum Layout {
+    Sparse(SparseOffsetsCache),
+    Dense {
+        codec: DensePrimaryKeyCodec,
+        offsets: Vec<usize>,
+    },
+}
+
+struct BoundLabel {
+    id: ColumnId,
+    name: Arc<str>,
+    position: usize,
+}
+
+/// Decodes labels on demand using the metadata snapshot bound to a raw-label source.
+pub struct PrimaryKeyLabelDecoder {
+    metric_name: Arc<str>,
+    physical_metadata: RegionMetadataRef,
+    complete: bool,
+    include_name: bool,
+    labels: Vec<BoundLabel>,
+    value_scratch: Vec<u8>,
+    layout: Layout,
+}
+
+impl PrimaryKeyLabelDecoder {
+    /// Binds a decoder to a primary-key source snapshot and projection.
+    ///
+    /// Explicit sources already contain complete labels and are rejected. Dense decoding
+    /// requires the full key layout described by the bound snapshot; compatibility with
+    /// older key layouts must be normalized upstream.
+    pub fn new(source: &RawLabelSource, projection: LabelProjection) -> Result<Self> {
+        let RawLabelSource::PrimaryKey {
+            metric_name,
+            physical_metadata,
+            logical_tags,
+        } = source
+        else {
+            return UnsupportedOperationSnafu {
+                err_msg: "explicit raw labels are already complete",
+            }
+            .fail();
+        };
+        let metadata = physical_metadata.as_ref();
+        let mut labels = Vec::with_capacity(logical_tags.len());
+        let mut names = HashSet::new();
+        let mut ids = HashSet::new();
+        for tag in logical_tags.iter() {
+            let column = metadata.column_by_id(tag.column_id);
+            if !names.insert(tag.name.clone())
+                || !ids.insert(tag.column_id)
+                || tag.name.as_ref() == "__name__"
+                || is_internal_column(&tag.name)
+                || is_metric_engine_internal_column(&tag.name)
+                || ReservedColumnId::is_reserved(tag.column_id)
+                || !column.is_some_and(|column| {
+                    column.semantic_type == SemanticType::Tag
+                        && column.column_schema.name.as_str() == tag.name.as_ref()
+                        && metadata.primary_key.contains(&tag.column_id)
+                })
+            {
+                return InvalidSparsePrimaryKeySnafu {
+                    reason: format!("invalid logical tag binding {}", tag.name),
+                }
+                .fail();
+            }
+            let position = metadata.primary_key_index(tag.column_id).context(
+                InvalidSparsePrimaryKeySnafu {
+                    reason: format!("logical tag {} is not a primary-key column", tag.name),
+                },
+            )?;
+            labels.push(BoundLabel {
+                id: tag.column_id,
+                name: tag.name.clone(),
+                position,
+            });
+        }
+        labels.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+        let complete = matches!(&projection, LabelProjection::All);
+        let include_name = match &projection {
+            LabelProjection::All => false,
+            LabelProjection::Only(requested) => {
+                requested.iter().any(|name| name.as_ref() == "__name__")
+            }
+        };
+        if let LabelProjection::Only(requested) = &projection {
+            let requested: HashSet<_> = requested.iter().map(AsRef::as_ref).collect();
+            labels.retain(|label| requested.contains(label.name.as_ref()));
+        }
+        let layout = match metadata.primary_key_encoding {
+            PrimaryKeyEncoding::Sparse => Layout::Sparse(SparseOffsetsCache::new()),
+            PrimaryKeyEncoding::Dense => Layout::Dense {
+                codec: DensePrimaryKeyCodec::new(metadata),
+                offsets: Vec::new(),
+            },
+        };
+        let encoding = match metadata.primary_key_encoding {
+            PrimaryKeyEncoding::Sparse => "sparse",
+            PrimaryKeyEncoding::Dense => "dense",
+        };
+        let projection_mode = if complete { "all" } else { "only" };
+        debug!(
+            encoding,
+            projection_mode,
+            logical_tag_count = logical_tags.len(),
+            selected_tag_count = labels.len(),
+            "Constructed primary key label decoder"
+        );
+        Ok(Self {
+            metric_name: metric_name.clone(),
+            physical_metadata: physical_metadata.clone(),
+            complete,
+            include_name,
+            labels,
+            value_scratch: Vec::new(),
+            layout,
+        })
+    }
+
+    /// Decodes labels without modifying or consuming `read_key`.
+    ///
+    /// `All` returns a complete [`MetricName`]; `Only` returns a partial vector. Dense
+    /// keys are fully checked against the exact snapshot layout even when decoding only
+    /// selected fields. Sparse keys receive a full structural audit before values are read.
+    pub fn decode(&mut self, read_key: &[u8]) -> Result<DecodedLabels> {
+        let mut values = Vec::with_capacity(self.labels.len() + usize::from(self.include_name));
+        let Self {
+            layout,
+            labels,
+            physical_metadata,
+            complete,
+            value_scratch,
+            ..
+        } = self;
+        match layout {
+            Layout::Sparse(cache) => {
+                let mut view = SparsePrimaryKeyView::new(read_key, cache)?;
+                view.visit_label_ids(|id| {
+                    if *complete
+                        && !physical_metadata.column_by_id(id).is_some_and(|column| {
+                            column.semantic_type == SemanticType::Tag
+                                && physical_metadata.primary_key.contains(&id)
+                        })
+                    {
+                        return InvalidSparsePrimaryKeySnafu {
+                            reason: format!("unrecognized sparse tag id {id}"),
+                        }
+                        .fail();
+                    }
+                    Ok(())
+                })?;
+                for label in labels.iter() {
+                    if let Some(value) = view.label(label.id, value_scratch)? {
+                        values.push(Label {
+                            name: label.name.clone(),
+                            value: Arc::from(value),
+                        });
+                    }
+                }
+            }
+            Layout::Dense { codec, offsets } => {
+                offsets.clear();
+                let mut total = 0;
+                for pos in 0..codec.num_fields() {
+                    let encoded = codec.encoded_value_at(read_key, pos, offsets)?;
+                    total += encoded.len();
+                }
+                if total != read_key.len() {
+                    return InvalidDensePrimaryKeySnafu {
+                        reason: "trailing bytes after dense primary key",
+                    }
+                    .fail();
+                }
+                for label in labels.iter() {
+                    let value = codec.decode_value_at(read_key, label.position, offsets)?;
+                    if !matches!(value, Value::Null) {
+                        values.push(Label {
+                            name: label.name.clone(),
+                            value: Arc::from(value.to_string()),
+                        });
+                    }
+                }
+            }
+        }
+        if *complete {
+            Ok(DecodedLabels::Complete(
+                MetricName::try_new(Some(self.metric_name.clone()), values).map_err(|error| {
+                    InvalidSparsePrimaryKeySnafu {
+                        reason: error.to_string(),
+                    }
+                    .build()
+                })?,
+            ))
+        } else {
+            if self.include_name {
+                values.push(Label {
+                    name: Arc::from("__name__"),
+                    value: self.metric_name.clone(),
+                });
+                values.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+            }
+            Ok(DecodedLabels::Projected(values))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

src/mito-codec/src/labels/tests.rs

@@ -0,0 +1,603 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use api::v1::SemanticType;
+use common_time::timestamp::TimeUnit;
+use common_time::{Date, Timestamp};
+use datatypes::data_type::ConcreteDataType;
+use datatypes::prelude::Value;
+use datatypes::schema::ColumnSchema;
+use store_api::codec::PrimaryKeyEncoding;
+use store_api::metadata::{ColumnMetadata, RegionMetadata, RegionMetadataBuilder};
+use store_api::region_engine::BoundTag;
+use store_api::storage::RegionId;
+
+use crate::row_converter::{
+    DensePrimaryKeyCodec, PrimaryKeyCodec, SortField, SparsePrimaryKeyCodec,
+};
+
+use super::*;
+
+fn metadata(
+    tags: &[(u32, &str, ConcreteDataType)],
+    encoding: PrimaryKeyEncoding,
+) -> Arc<RegionMetadata> {
+    let mut builder = RegionMetadataBuilder::new(RegionId::new(7, 1));
+    builder.push_column_metadata(ColumnMetadata {
+        column_schema: ColumnSchema::new(
+            "ts",
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            false,
+        ),
+        semantic_type: SemanticType::Timestamp,
+        column_id: 0,
+    });
+    let mut primary_key = Vec::new();
+    for (id, name, data_type) in tags {
+        builder.push_column_metadata(ColumnMetadata {
+            column_schema: ColumnSchema::new(*name, data_type.clone(), true),
+            semantic_type: SemanticType::Tag,
+            column_id: *id,
+        });
+        primary_key.push(*id);
+    }
+    builder.push_column_metadata(ColumnMetadata {
+        column_schema: ColumnSchema::new("field", ConcreteDataType::int64_datatype(), true),
+        semantic_type: SemanticType::Field,
+        column_id: 99,
+    });
+    builder.primary_key(primary_key);
+    builder.primary_key_encoding(encoding);
+    Arc::new(builder.build().unwrap())
+}
+
+fn source(
+    metadata: Arc<RegionMetadata>,
+    metric: &str,
+    logical_tags: &[(u32, &str)],
+) -> RawLabelSource {
+    RawLabelSource::PrimaryKey {
+        metric_name: Arc::from(metric),
+        physical_metadata: metadata,
+        logical_tags: logical_tags
+            .iter()
+            .map(|(column_id, name)| BoundTag {
+                column_id: *column_id,
+                name: Arc::from(*name),
+            })
+            .collect::<Vec<_>>()
+            .into(),
+    }
+}
+
+fn encoded(encoding: PrimaryKeyEncoding, values: &[(u32, Value)]) -> Vec<u8> {
+    let fields = values
+        .iter()
+        .map(|(id, value)| (*id, SortField::new(value.data_type())))
+        .collect::<Vec<_>>();
+    let mut bytes = Vec::new();
+    match encoding {
+        PrimaryKeyEncoding::Dense => DensePrimaryKeyCodec::with_fields(fields)
+            .encode_values(values, &mut bytes)
+            .unwrap(),
+        PrimaryKeyEncoding::Sparse => {
+            let codec = SparsePrimaryKeyCodec::with_fields(fields);
+            codec.encode_internal(42, 9, &mut bytes).unwrap();
+            codec.encode_values(values, &mut bytes).unwrap();
+        }
+    }
+    bytes
+}
+
+fn string_metadata(encoding: PrimaryKeyEncoding) -> Arc<RegionMetadata> {
+    metadata(
+        &[
+            (8, "zeta", ConcreteDataType::string_datatype()),
+            (2, "private", ConcreteDataType::string_datatype()),
+            (41, "alpha", ConcreteDataType::string_datatype()),
+        ],
+        encoding,
+    )
+}
+
+fn values() -> Vec<(u32, Value)> {
+    vec![
+        (8, Value::String("last".into())),
+        (2, Value::String("hidden".into())),
+        (41, Value::String("first".into())),
+    ]
+}
+
+#[test]
+fn dense_and_sparse_decode_complete_or_projected_labels() {
+    for encoding in [PrimaryKeyEncoding::Dense, PrimaryKeyEncoding::Sparse] {
+        let source = source(
+            string_metadata(encoding),
+            "requests_total",
+            &[(8, "zeta"), (41, "alpha")],
+        );
+        let key = encoded(encoding, &values());
+        let mut all = PrimaryKeyLabelDecoder::new(&source, LabelProjection::All).unwrap();
+        let complete = all.decode(&key).unwrap();
+        let DecodedLabels::Complete(metric) = complete else {
+            panic!("All must return a complete metric identity")
+        };
+        assert_eq!(metric.name(), Some("requests_total"));
+        assert_eq!(metric.get("alpha"), Some("first"));
+        assert_eq!(metric.get("zeta"), Some("last"));
+        assert_eq!(metric.get("private"), None);
+
+        let mut projected = PrimaryKeyLabelDecoder::new(
+            &source,
+            LabelProjection::Only(Arc::from([
+                Arc::<str>::from("zeta"),
+                Arc::from("alpha"),
+                Arc::from("__name__"),
+                Arc::from("missing"),
+                Arc::from("alpha"),
+            ])),
+        )
+        .unwrap();
+        assert_eq!(
+            projected.decode(&key).unwrap(),
+            DecodedLabels::Projected(vec![
+                Label {
+                    name: Arc::from("__name__"),
+                    value: Arc::from("requests_total")
+                },
+                Label {
+                    name: Arc::from("alpha"),
+                    value: Arc::from("first")
+                },
+                Label {
+                    name: Arc::from("zeta"),
+                    value: Arc::from("last")
+                },
+            ])
+        );
+        assert_eq!(
+            projected.decode(&key).unwrap(),
+            DecodedLabels::Projected(vec![
+                Label {
+                    name: Arc::from("__name__"),
+                    value: Arc::from("requests_total")
+                },
+                Label {
+                    name: Arc::from("alpha"),
+                    value: Arc::from("first")
+                },
+                Label {
+                    name: Arc::from("zeta"),
+                    value: Arc::from("last")
+                },
+            ])
+        );
+
+        let mut without_name = PrimaryKeyLabelDecoder::new(
+            &source,
+            LabelProjection::Only(Arc::from([Arc::<str>::from("alpha")])),
+        )
+        .unwrap();
+        assert_eq!(
+            without_name.decode(&key).unwrap(),
+            DecodedLabels::Projected(vec![Label {
+                name: Arc::from("alpha"),
+                value: Arc::from("first")
+            }])
+        );
+
+        let mut empty_projection =
+            PrimaryKeyLabelDecoder::new(&source, LabelProjection::Only(Arc::from([]))).unwrap();
+        assert_eq!(
+            empty_projection.decode(&key).unwrap(),
+            DecodedLabels::Projected(vec![])
+        );
+    }
+}
+
+#[test]
+fn projection_is_bound_to_snapshot_and_distinguishes_missing_and_empty() {
+    let original = metadata(
+        &[
+            (21, "old", ConcreteDataType::string_datatype()),
+            (4, "added_later", ConcreteDataType::string_datatype()),
+        ],
+        PrimaryKeyEncoding::Sparse,
+    );
+    let old_source = source(
+        original.clone(),
+        "old_metric",
+        &[(21, "old"), (4, "added_later")],
+    );
+    let weak_metadata = Arc::downgrade(&original);
+    let replacement = metadata(
+        &[(21, "renamed", ConcreteDataType::string_datatype())],
+        PrimaryKeyEncoding::Sparse,
+    );
+    let new_source = source(replacement, "new_metric", &[(21, "renamed")]);
+    assert!(PrimaryKeyLabelDecoder::new(&new_source, LabelProjection::All).is_ok());
+
+    let codec = SparsePrimaryKeyCodec::with_fields(vec![(
+        21,
+        SortField::new(ConcreteDataType::string_datatype()),
+    )]);
+    let mut key = Vec::new();
+    codec.encode_internal(42, 9, &mut key).unwrap();
+    codec
+        .encode_values(&[(21, Value::String("".into()))], &mut key)
+        .unwrap();
+    let mut decoder = PrimaryKeyLabelDecoder::new(
+        &old_source,
+        LabelProjection::Only(Arc::from([
+            Arc::<str>::from("old"),
+            Arc::from("added_later"),
+        ])),
+    )
+    .unwrap();
+    let mut all = PrimaryKeyLabelDecoder::new(&old_source, LabelProjection::All).unwrap();
+    drop(old_source);
+    drop(original);
+    assert!(weak_metadata.upgrade().is_some());
+    assert_eq!(
+        decoder.decode(&key).unwrap(),
+        DecodedLabels::Projected(vec![Label {
+            name: Arc::from("old"),
+            value: Arc::from("")
+        },])
+    );
+
+    let mut absent = Vec::new();
+    codec.encode_internal(42, 9, &mut absent).unwrap();
+    assert_eq!(
+        decoder.decode(&absent).unwrap(),
+        DecodedLabels::Projected(vec![])
+    );
+    let DecodedLabels::Complete(absent_tags) = all.decode(&absent).unwrap() else {
+        panic!("All must return complete identity")
+    };
+    assert_eq!(absent_tags.get("old"), None);
+    let DecodedLabels::Complete(empty_tag) = all.decode(&key).unwrap() else {
+        panic!("All must return complete identity")
+    };
+    assert_eq!(empty_tag.get("old"), Some(""));
+    let mut complete = PrimaryKeyLabelDecoder::new(
+        &source(
+            metadata(
+                &[(21, "old", ConcreteDataType::string_datatype())],
+                PrimaryKeyEncoding::Sparse,
+            ),
+            "",
+            &[(21, "old")],
+        ),
+        LabelProjection::All,
+    )
+    .unwrap();
+    let DecodedLabels::Complete(empty_name) = complete.decode(&absent).unwrap() else {
+        panic!("All must return complete identity")
+    };
+    assert_eq!(empty_name.name(), Some(""));
+    let named_source = source(
+        metadata(
+            &[(21, "old", ConcreteDataType::string_datatype())],
+            PrimaryKeyEncoding::Sparse,
+        ),
+        "old_metric",
+        &[(21, "old")],
+    );
+    let mut complete = PrimaryKeyLabelDecoder::new(&named_source, LabelProjection::All).unwrap();
+    let DecodedLabels::Complete(named) = complete.decode(&absent).unwrap() else {
+        panic!("All must return complete identity")
+    };
+    assert_eq!(named.name(), Some("old_metric"));
+    // A null value is represented by its sparse column ID and null marker.
+    let mut null = Vec::new();
+    codec.encode_internal(42, 9, &mut null).unwrap();
+    null.extend_from_slice(&21_u32.to_be_bytes());
+    null.push(0);
+    assert_eq!(
+        decoder.decode(&null).unwrap(),
+        DecodedLabels::Projected(vec![])
+    );
+    drop(decoder);
+    drop(all);
+    assert!(weak_metadata.upgrade().is_none());
+}
+
+#[test]
+fn projection_does_not_hide_bad_framing_or_materialize_unselected_values() {
+    let meta = metadata(
+        &[
+            (11, "wanted", ConcreteDataType::string_datatype()),
+            (35, "unwanted", ConcreteDataType::string_datatype()),
+        ],
+        PrimaryKeyEncoding::Sparse,
+    );
+    let bound = source(meta, "m", &[(11, "wanted"), (35, "unwanted")]);
+    let codec = SparsePrimaryKeyCodec::with_fields(vec![
+        (11, SortField::new(ConcreteDataType::string_datatype())),
+        (35, SortField::new(ConcreteDataType::string_datatype())),
+    ]);
+    let mut key = Vec::new();
+    codec.encode_internal(42, 9, &mut key).unwrap();
+    codec
+        .encode_raw_tag_value(
+            [(11, b"ok".as_slice()), (35, &[0xff])].into_iter(),
+            &mut key,
+        )
+        .unwrap();
+
+    let mut only = PrimaryKeyLabelDecoder::new(
+        &bound,
+        LabelProjection::Only(Arc::from([Arc::<str>::from("wanted")])),
+    )
+    .unwrap();
+    assert_eq!(
+        only.decode(&key).unwrap(),
+        DecodedLabels::Projected(vec![Label {
+            name: Arc::from("wanted"),
+            value: Arc::from("ok")
+        },])
+    );
+    let mut all = PrimaryKeyLabelDecoder::new(&bound, LabelProjection::All).unwrap();
+    assert!(all.decode(&key).is_err());
+    let mut malformed = key.clone();
+    malformed.pop();
+    assert!(only.decode(&malformed).is_err());
+    assert!(all.decode(&malformed).is_err());
+    let mut empty_projection =
+        PrimaryKeyLabelDecoder::new(&bound, LabelProjection::Only(Arc::from([]))).unwrap();
+    assert!(empty_projection.decode(&malformed).is_err());
+}
+
+#[test]
+fn dense_projection_still_rejects_short_and_extra_key_bytes() {
+    let meta = metadata(
+        &[(17, "label", ConcreteDataType::string_datatype())],
+        PrimaryKeyEncoding::Dense,
+    );
+    let bound = source(meta, "m", &[(17, "label")]);
+    let key = encoded(
+        PrimaryKeyEncoding::Dense,
+        &[(17, Value::String("ok".into()))],
+    );
+    let mut decoder =
+        PrimaryKeyLabelDecoder::new(&bound, LabelProjection::Only(Arc::from([]))).unwrap();
+    assert!(decoder.decode(&key[..key.len() - 1]).is_err());
+    let mut extra = key;
+    extra.push(0);
+    assert!(decoder.decode(&extra).is_err());
+}
+
+#[test]
+fn dense_unselected_invalid_utf8_is_not_materialized() {
+    let meta = metadata(
+        &[
+            (17, "wanted", ConcreteDataType::string_datatype()),
+            (18, "unwanted", ConcreteDataType::string_datatype()),
+        ],
+        PrimaryKeyEncoding::Dense,
+    );
+    let bound = source(meta, "m", &[(17, "wanted"), (18, "unwanted")]);
+    let first_value = encoded(
+        PrimaryKeyEncoding::Dense,
+        &[(17, Value::String("ok".into()))],
+    );
+    let mut key = encoded(
+        PrimaryKeyEncoding::Dense,
+        &[
+            (17, Value::String("ok".into())),
+            (18, Value::String("x".into())),
+        ],
+    );
+    key[first_value.len() + 2] = 0xff;
+    let mut only = PrimaryKeyLabelDecoder::new(
+        &bound,
+        LabelProjection::Only(Arc::from([Arc::<str>::from("wanted")])),
+    )
+    .unwrap();
+    assert_eq!(
+        only.decode(&key).unwrap(),
+        DecodedLabels::Projected(vec![Label {
+            name: Arc::from("wanted"),
+            value: Arc::from("ok")
+        }])
+    );
+    let mut selected_invalid = PrimaryKeyLabelDecoder::new(
+        &bound,
+        LabelProjection::Only(Arc::from([Arc::<str>::from("unwanted")])),
+    )
+    .unwrap();
+    assert!(selected_invalid.decode(&key).is_err());
+    let mut all = PrimaryKeyLabelDecoder::new(&bound, LabelProjection::All).unwrap();
+    assert!(all.decode(&key).is_err());
+}
+
+#[test]
+fn unknown_sparse_ids_are_skipped_only_for_projection_and_full_keys_stay_distinct() {
+    let meta = metadata(
+        &[(11, "wanted", ConcreteDataType::string_datatype())],
+        PrimaryKeyEncoding::Sparse,
+    );
+    let bound = source(meta, "m", &[(11, "wanted")]);
+    let codec = SparsePrimaryKeyCodec::with_fields(vec![(
+        11,
+        SortField::new(ConcreteDataType::string_datatype()),
+    )]);
+    let mut first = Vec::new();
+    codec.encode_internal(42, 9, &mut first).unwrap();
+    codec
+        .encode_raw_tag_value(
+            [
+                (10, b"before".as_slice()),
+                (11, b"one".as_slice()),
+                (12, b"between".as_slice()),
+                (90, b"after".as_slice()),
+            ]
+            .into_iter(),
+            &mut first,
+        )
+        .unwrap();
+    let original_first = first.clone();
+    let mut second = Vec::new();
+    codec.encode_internal(42, 9, &mut second).unwrap();
+    codec
+        .encode_raw_tag_value(
+            [
+                (10, b"before".as_slice()),
+                (11, b"two".as_slice()),
+                (12, b"between".as_slice()),
+                (90, b"after".as_slice()),
+            ]
+            .into_iter(),
+            &mut second,
+        )
+        .unwrap();
+
+    let mut only = PrimaryKeyLabelDecoder::new(
+        &bound,
+        LabelProjection::Only(Arc::from([Arc::<str>::from("wanted")])),
+    )
+    .unwrap();
+    assert_eq!(
+        only.decode(&first).unwrap(),
+        DecodedLabels::Projected(vec![Label {
+            name: Arc::from("wanted"),
+            value: Arc::from("one")
+        },])
+    );
+    assert_eq!(
+        only.decode(&second).unwrap(),
+        DecodedLabels::Projected(vec![Label {
+            name: Arc::from("wanted"),
+            value: Arc::from("two")
+        },])
+    );
+    assert_ne!(first, second);
+    assert_eq!(first, original_first);
+    let original_second = second.clone();
+
+    let mut all = PrimaryKeyLabelDecoder::new(&bound, LabelProjection::All).unwrap();
+    assert!(all.decode(&first).is_err());
+    assert_eq!(first, original_first);
+    assert_eq!(second, original_second);
+}
+
+#[test]
+fn unknown_sparse_ids_before_between_and_after_known_tags_are_projected() {
+    let meta = metadata(
+        &[
+            (11, "wanted", ConcreteDataType::string_datatype()),
+            (13, "other", ConcreteDataType::string_datatype()),
+        ],
+        PrimaryKeyEncoding::Sparse,
+    );
+    let bound = source(meta, "m", &[(11, "wanted"), (13, "other")]);
+    let codec = SparsePrimaryKeyCodec::schemaless();
+    let cases: [&[(u32, &[u8])]; 3] = [
+        &[(10, b"before"), (11, b"one"), (12, b"two")],
+        &[(11, b"one"), (12, b"between"), (13, b"two")],
+        &[(11, b"one"), (13, b"two"), (90, b"after")],
+    ];
+    for tags in cases {
+        let mut key = Vec::new();
+        codec.encode_internal(42, 9, &mut key).unwrap();
+        codec
+            .encode_raw_tag_value(tags.iter().copied(), &mut key)
+            .unwrap();
+        let mut only = PrimaryKeyLabelDecoder::new(
+            &bound,
+            LabelProjection::Only(Arc::from([Arc::<str>::from("wanted")])),
+        )
+        .unwrap();
+        assert_eq!(
+            only.decode(&key).unwrap(),
+            DecodedLabels::Projected(vec![Label {
+                name: Arc::from("wanted"),
+                value: Arc::from("one")
+            }])
+        );
+        let mut all = PrimaryKeyLabelDecoder::new(&bound, LabelProjection::All).unwrap();
+        assert!(all.decode(&key).is_err());
+    }
+}
+
+#[test]
+fn constructor_rejects_invalid_bindings_but_accepts_valid_control() {
+    let meta = metadata(
+        &[
+            (11, "wanted", ConcreteDataType::string_datatype()),
+            (35, "other", ConcreteDataType::string_datatype()),
+        ],
+        PrimaryKeyEncoding::Sparse,
+    );
+    for bindings in [
+        vec![(11, "wrong")],
+        vec![(11, "same"), (35, "same")],
+        vec![(11, "wanted"), (11, "wanted")],
+        vec![(0, "ts")],
+        vec![(90, "not_a_tag")],
+        vec![(99, "field")],
+        vec![(11, "__name__")],
+        vec![(u32::MAX, "internal")],
+    ] {
+        let invalid = source(meta.clone(), "m", &bindings);
+        assert!(PrimaryKeyLabelDecoder::new(&invalid, LabelProjection::All).is_err());
+    }
+    let valid = source(meta, "m", &[(11, "wanted"), (35, "other")]);
+    assert!(PrimaryKeyLabelDecoder::new(&valid, LabelProjection::All).is_ok());
+    assert!(PrimaryKeyLabelDecoder::new(&RawLabelSource::Explicit, LabelProjection::All).is_err());
+}
+
+#[test]
+fn dense_typed_values_keep_exact_integer_string_representation() {
+    let cases = [
+        (
+            "count",
+            ConcreteDataType::int64_datatype(),
+            Value::Int64(9_007_199_254_740_993),
+        ),
+        (
+            "binary",
+            ConcreteDataType::binary_datatype(),
+            Value::Binary(vec![0xab, 0xcd].into()),
+        ),
+        (
+            "date",
+            ConcreteDataType::date_datatype(),
+            Value::Date(Date::new(0)),
+        ),
+        (
+            "timestamp",
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            Value::Timestamp(Timestamp::new(1234, TimeUnit::Millisecond)),
+        ),
+    ];
+    for (name, data_type, value) in cases {
+        let expected = value.to_string();
+        let meta = metadata(&[(17, name, data_type)], PrimaryKeyEncoding::Dense);
+        let bound = source(meta, "typed", &[(17, name)]);
+        let key = encoded(PrimaryKeyEncoding::Dense, &[(17, value)]);
+        let mut decoder = PrimaryKeyLabelDecoder::new(&bound, LabelProjection::All).unwrap();
+        let DecodedLabels::Complete(metric) = decoder.decode(&key).unwrap() else {
+            panic!("All must return a complete metric identity")
+        };
+        assert_eq!(metric.get(name), Some(expected.as_str()));
+    }
+    assert_eq!(
+        Value::Int64(9_007_199_254_740_993).to_string(),
+        "9007199254740993"
+    );
+}

src/mito-codec/src/lib.rs

@@ -17,6 +17,7 @@
 pub mod error;
 pub mod index;
 pub mod key_values;
+pub mod labels;
 pub mod primary_key_filter;
 pub mod row_converter;
 

src/mito-codec/src/row_converter/sparse/checked.rs

@@ -67,26 +67,53 @@ impl<'a, 'b> SparsePrimaryKeyView<'a, 'b> {
         if let Some(offset) = self.cache.get(column_id) {
             return encoded_label(&self.pk[offset..]).map(Some);
         }
-        while !self.cache.finished && self.cache.cursor < self.pk.len() {
-            let bytes = &self.pk[self.cache.cursor..];
-            let id = bytes.first_chunk::<COLUMN_ID_ENCODE_SIZE>().context(
-                InvalidSparsePrimaryKeySnafu {
-                    reason: "truncated label column id",
-                },
-            )?;
-            let id = u32::from_be_bytes(*id);
-            let offset = self.cache.cursor + COLUMN_ID_ENCODE_SIZE;
-            let value = encoded_label(&self.pk[offset..])?;
-            self.cache.insert(id, offset);
-            self.cache.cursor = offset + value.len();
+        while let Some((id, value)) = self.next_label()? {
             if id == column_id {
                 return Ok(Some(value));
             }
         }
-        self.cache.finished = true;
         Ok(None)
     }
 
+    /// Visits every ordinary label id in encoded order, validating the complete tail.
+    /// Resets offset discovery for this key before traversing it.
+    pub fn visit_label_ids(&mut self, mut visit: impl FnMut(ColumnId) -> Result<()>) -> Result<()> {
+        self.cache.clear();
+        while let Some((id, _)) = self.next_label()? {
+            visit(id)?;
+        }
+        Ok(())
+    }
+
+    /// Parses and caches the next ordinary label, advancing the per-key cursor.
+    fn next_label(&mut self) -> Result<Option<(ColumnId, &'a [u8])>> {
+        if self.cache.finished || self.cache.cursor == self.pk.len() {
+            self.cache.finished = true;
+            return Ok(None);
+        }
+        let bytes = &self.pk[self.cache.cursor..];
+        let id =
+            bytes
+                .first_chunk::<COLUMN_ID_ENCODE_SIZE>()
+                .context(InvalidSparsePrimaryKeySnafu {
+                    reason: "truncated label column id",
+                })?;
+        let id = u32::from_be_bytes(*id);
+        let offset = self.cache.cursor + COLUMN_ID_ENCODE_SIZE;
+        ensure!(
+            id != RESERVED_COLUMN_ID_TABLE_ID
+                && id != RESERVED_COLUMN_ID_TSID
+                && self.cache.get(id).is_none(),
+            InvalidSparsePrimaryKeySnafu {
+                reason: "duplicate or reserved label column id"
+            }
+        );
+        let value = encoded_label(&self.pk[offset..])?;
+        self.cache.insert(id, offset);
+        self.cache.cursor = offset + value.len();
+        Ok(Some((id, value)))
+    }
+
     /// Extracts a UTF-8 label into a reusable buffer, validating it once.
     /// Missing and null labels return `None` without modifying the buffer;
     /// an empty label returns `Some("")`. Reserved numeric columns are rejected.
@@ -230,6 +257,144 @@ mod tests {
         }
     }
 
+    #[test]
+    fn visits_all_label_ids_in_order_and_resets_cache_for_each_key() {
+        let codec = SparsePrimaryKeyCodec::schemaless();
+        let mut cache = SparseOffsetsCache::new();
+        let mut first = Vec::new();
+        codec.encode_internal(1, 2, &mut first).unwrap();
+        codec
+            .encode_raw_tag_value(
+                [(8, b"a".as_slice()), (3, b"b"), (12, b"c")].into_iter(),
+                &mut first,
+            )
+            .unwrap();
+        let mut second = Vec::new();
+        codec.encode_internal(1, 2, &mut second).unwrap();
+        codec
+            .encode_raw_tag_value([(99, b"z".as_slice())].into_iter(), &mut second)
+            .unwrap();
+
+        let mut view = SparsePrimaryKeyView::new(&first, &mut cache).unwrap();
+        assert!(view.encoded_value(8).unwrap().is_some());
+        let mut visited = Vec::new();
+        view.visit_label_ids(|id| {
+            visited.push(id);
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(visited, [8, 3, 12]);
+        let mut view = SparsePrimaryKeyView::new(&second, &mut cache).unwrap();
+        visited.clear();
+        view.visit_label_ids(|id| {
+            visited.push(id);
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(visited, [99]);
+    }
+
+    #[test]
+    fn visits_unknown_ids_before_and_after_known_lookup() {
+        let codec = SparsePrimaryKeyCodec::schemaless();
+        let mut pk = Vec::new();
+        codec.encode_internal(1, 2, &mut pk).unwrap();
+        codec
+            .encode_raw_tag_value(
+                [(1, b"one".as_slice()), (5, b"five"), (9, b"nine")].into_iter(),
+                &mut pk,
+            )
+            .unwrap();
+        let mut cache = SparseOffsetsCache::new();
+        let mut view = SparsePrimaryKeyView::new(&pk, &mut cache).unwrap();
+        assert!(view.encoded_value(5).unwrap().is_some());
+        let mut visited = Vec::new();
+        view.visit_label_ids(|id| {
+            visited.push(id);
+            Ok(())
+        })
+        .unwrap();
+        assert_eq!(visited, [1, 5, 9]);
+        assert!(view.encoded_value(100).unwrap().is_none());
+    }
+
+    #[test]
+    fn full_visit_catches_malformed_tail_after_early_lookup() {
+        let codec = SparsePrimaryKeyCodec::schemaless();
+        let mut pk = Vec::new();
+        codec.encode_internal(1, 2, &mut pk).unwrap();
+        codec
+            .encode_raw_tag_value([(1, b"ok".as_slice())].into_iter(), &mut pk)
+            .unwrap();
+        pk.extend_from_slice(&2_u32.to_be_bytes());
+        pk.extend_from_slice(&[1, 1, 1]);
+        let mut cache = SparseOffsetsCache::new();
+        let mut view = SparsePrimaryKeyView::new(&pk, &mut cache).unwrap();
+        assert!(view.encoded_value(1).unwrap().is_some());
+        assert!(view.visit_label_ids(|_| Ok(())).is_err());
+    }
+
+    #[test]
+    fn visit_rejects_duplicate_reserved_truncated_and_bad_framing_tail() {
+        let codec = SparsePrimaryKeyCodec::schemaless();
+        let mut cache = SparseOffsetsCache::new();
+        let mut duplicate_tail = Vec::new();
+        codec
+            .encode_raw_tag_value(
+                [(1, b"duplicate".as_slice())].into_iter(),
+                &mut duplicate_tail,
+            )
+            .unwrap();
+        let cases = [
+            (duplicate_tail, "duplicate or reserved label column id"),
+            (
+                [
+                    RESERVED_COLUMN_ID_TABLE_ID.to_be_bytes().as_slice(),
+                    &[1, 1, b'x', 0],
+                ]
+                .concat(),
+                "duplicate or reserved label column id",
+            ),
+            (
+                [
+                    RESERVED_COLUMN_ID_TSID.to_be_bytes().as_slice(),
+                    &[1, 1, b'x', 0],
+                ]
+                .concat(),
+                "duplicate or reserved label column id",
+            ),
+            (
+                [2_u32.to_be_bytes().as_slice(), &[1, 1, b'x']].concat(),
+                "unexpected end of input",
+            ),
+            (
+                [2_u32.to_be_bytes().as_slice(), &[2]].concat(),
+                "invalid tag encoding: 2",
+            ),
+        ];
+        for (tail, expected_reason) in cases {
+            let mut pk = Vec::new();
+            codec.encode_internal(1, 2, &mut pk).unwrap();
+            codec
+                .encode_raw_tag_value([(1, b"ok".as_slice())].into_iter(), &mut pk)
+                .unwrap();
+            pk.extend_from_slice(&tail);
+            let mut view = SparsePrimaryKeyView::new(&pk, &mut cache).unwrap();
+            let error = view.visit_label_ids(|_| Ok(())).unwrap_err();
+            assert!(
+                error.to_string().contains(expected_reason),
+                "expected {expected_reason:?}, got {error}"
+            );
+        }
+
+        let mut truncated_id = Vec::new();
+        codec.encode_internal(1, 2, &mut truncated_id).unwrap();
+        truncated_id.push(1);
+        let mut view = SparsePrimaryKeyView::new(&truncated_id, &mut cache).unwrap();
+        let error = view.visit_label_ids(|_| Ok(())).unwrap_err();
+        assert!(error.to_string().contains("truncated label column id"));
+    }
+
     #[test]
     fn reserved_ids_preserve_unsigned_values() {
         let codec = SparsePrimaryKeyCodec::schemaless();

src/promql/Cargo.toml

@@ -24,6 +24,7 @@ greptime-proto.workspace = true
 lazy_static.workspace = true
 prometheus.workspace = true
 prost.workspace = true
+regex.workspace = true
 snafu.workspace = true
 
 [dev-dependencies]
@@ -32,6 +33,7 @@ criterion.workspace = true
 datafusion-common.workspace = true
 datafusion-expr.workspace = true
 datatypes.workspace = true
+rand.workspace = true
 tokio.workspace = true
 
 [[bench]]

src/promql/src/functions.rs

@@ -32,6 +32,7 @@ mod vector_matching;
 
 use std::sync::Arc;
 
+pub(crate) use aggr_over_time::extremum;
 pub use aggr_over_time::{
     AbsentOverTime, AvgOverTime, CountOverTime, LastOverTime, MaxOverTime, MinOverTime,
     PresentOverTime, StddevOverTime, StdvarOverTime, SumOverTime,
@@ -47,8 +48,11 @@ use datatypes::arrow::array::Array;
 use datatypes::arrow::datatypes::{DataType, Int64Type};
 pub use deriv::Deriv;
 pub use double_exponential_smoothing::DoubleExponentialSmoothing;
+pub(crate) use edge_count::{EdgeKind, count_edges};
+pub(crate) use extrapolate_rate::add_counter_resets;
 pub use extrapolate_rate::{Delta, Increase, Rate};
 pub use idelta::IDelta;
+pub(crate) use idelta::instant_delta;
 pub use ieee_float::{IeeeComparison, IeeeSqrt};
 pub use native_histogram::{
     MixedRange, NativeHistogramAbsentOverTime, NativeHistogramAdd, NativeHistogramAggAvg,
@@ -145,6 +149,16 @@ pub(crate) fn compensated_sum_inc(inc: f64, sum: f64, mut compensation: f64) ->
     (new_sum, compensation)
 }
 
+/// Prometheus `kahansum.Inc`: [`compensated_sum_inc`] that also drops the compensation once the
+/// sum is infinite.
+pub(crate) fn kahan_inc(inc: f64, sum: f64, c: f64) -> (f64, f64) {
+    let t = sum + inc;
+    if t.is_infinite() {
+        return (t, 0.0);
+    }
+    compensated_sum_inc(inc, sum, c)
+}
+
 /// linear_regression performs a least-square linear regression analysis on the
 /// times and values. It return the slope and intercept based on times and values.
 /// Prometheus's implementation: <https://github.com/prometheus/prometheus/blob/90b2f7a540b8a70d8d81372e6692dcbb67ccbaaa/promql/functions.go#L793-L837>

src/promql/src/functions/aggr_over_time.rs

@@ -443,13 +443,18 @@ impl SlidingExtrema {
 
 /// Folds one window on its own, the way the per-window scan used to.
 fn scan_extremum(values: &Float64Array, start: usize, end: usize, is_min: bool) -> Option<f64> {
-    let mut extremum: Option<f64> = None;
-    for index in start..end {
-        if values.is_null(index) {
-            continue;
-        }
+    extremum(
+        (start..end)
+            .filter(|&index| values.is_valid(index))
+            .map(|index| values.value(index)),
+        is_min,
+    )
+}
 
-        let value = values.value(index);
+/// The minimum (`is_min`) or maximum of `values`, `None` when there are none.
+pub(crate) fn extremum(values: impl IntoIterator<Item = f64>, is_min: bool) -> Option<f64> {
+    let mut extremum: Option<f64> = None;
+    for value in values {
         let replace = match extremum {
             None => true,
             // A NaN only holds the slot until any other sample arrives.

src/promql/src/functions/edge_count.rs

@@ -25,8 +25,9 @@ use datatypes::arrow::datatypes::DataType;
 use crate::functions::extract_range_array;
 use crate::range_array::RangeArray;
 
+/// The transitions `changes` and `resets` count between consecutive samples.
 #[derive(Clone, Copy)]
-pub(super) enum EdgeKind {
+pub(crate) enum EdgeKind {
     Changes,
     Resets,
 }
@@ -96,7 +97,7 @@ fn calc(
             0 => None,
             _ if has_nulls => count_edges_skipping_nulls(values, offset, end, kind),
             1 => Some(0),
-            _ if direct => Some(count_edges(raw_values.as_ref(), offset, end, kind)),
+            _ if direct => Some(count_edges(&raw_values[offset..end], kind)),
             _ => {
                 let prefix = prefix.as_ref().unwrap();
                 Some(prefix[end - 1] - prefix[offset])
@@ -169,9 +170,10 @@ fn build_prefix(values: &[f64], kind: EdgeKind) -> Vec<u64> {
     prefix
 }
 
-fn count_edges(values: &[f64], offset: usize, end: usize, kind: EdgeKind) -> u64 {
+/// Counts `kind` edges between consecutive `values`.
+pub(crate) fn count_edges(values: &[f64], kind: EdgeKind) -> u64 {
     let mut count = 0;
-    for index in offset + 1..end {
+    for index in 1..values.len() {
         count += u64::from(is_edge(values[index - 1], values[index], kind));
     }
     count

src/promql/src/functions/extrapolate_rate.rs

@@ -314,7 +314,7 @@ impl<const IS_COUNTER: bool, const IS_RATE: bool> ExtrapolatedRate<IS_COUNTER, I
 /// their own, and the two are not interchangeable in f64: a reset large enough to swallow a
 /// later one in an isolated sum still leaves it visible once the first difference is folded
 /// in first.
-fn add_counter_resets(result: f64, values: &[f64]) -> f64 {
+pub(crate) fn add_counter_resets(result: f64, values: &[f64]) -> f64 {
     values
         .windows(2)
         .filter(|pair| pair[1] < pair[0])

src/promql/src/functions/idelta.rs

@@ -140,30 +140,16 @@ impl<const IS_RATE: bool> IDelta<IS_RATE> {
 
             let last_offset = ts_offset + last_position;
             let prev_offset = ts_offset + prev_position;
-            let sampled_interval_ms = ts_values[last_offset] - ts_values[prev_offset];
-            // Sub-millisecond samples round to the same ms; skip instead of dividing by zero.
-            if sampled_interval_ms == 0 {
-                result_builder.append_null();
-                continue;
-            }
-            let sampled_interval = sampled_interval_ms as f64 / 1000.0;
-
-            let last_value = value_values[value_offset + last_position];
-            let prev_value = value_values[value_offset + prev_position];
-
-            if !IS_RATE {
-                result_builder.append_value(last_value - prev_value);
-                continue;
-            }
-
-            let result_value = if last_value < prev_value {
-                // counter reset
-                last_value
-            } else {
-                last_value - prev_value
-            };
-
-            result_builder.append_value(result_value / sampled_interval);
+            result_builder.append_option(instant_delta::<IS_RATE>(
+                (
+                    ts_values[prev_offset],
+                    value_values[value_offset + prev_position],
+                ),
+                (
+                    ts_values[last_offset],
+                    value_values[value_offset + last_position],
+                ),
+            ));
         }
 
         let result = ColumnarValue::Array(Arc::new(result_builder.finish()));
@@ -171,6 +157,29 @@ impl<const IS_RATE: bool> IDelta<IS_RATE> {
     }
 }
 
+/// `irate` (`IS_RATE`) or `idelta` of the last two samples of a window, as
+/// `(timestamp, value)` pairs.
+pub(crate) fn instant_delta<const IS_RATE: bool>(
+    (prev_ts, prev_value): (i64, f64),
+    (last_ts, last_value): (i64, f64),
+) -> Option<f64> {
+    let sampled_interval_ms = last_ts - prev_ts;
+    // Sub-millisecond samples round to the same ms; skip instead of dividing by zero.
+    if sampled_interval_ms == 0 {
+        return None;
+    }
+    if !IS_RATE {
+        return Some(last_value - prev_value);
+    }
+    let result_value = if last_value < prev_value {
+        // counter reset
+        last_value
+    } else {
+        last_value - prev_value
+    };
+    Some(result_value / (sampled_interval_ms as f64 / 1000.0))
+}
+
 /// Locates the last two samples inside `[offset, offset + len)`, returning their positions
 /// relative to `offset`. Returns `None` when the window holds fewer than two samples.
 fn last_two_samples(values: &Float64Array, offset: usize, len: usize) -> Option<(usize, usize)> {

src/promql/src/go_sort.rs

@@ -0,0 +1,342 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A port of Go's `sort.Sort` / `slices.SortFunc` (pattern-defeating quicksort, Go 1.19+).
+//!
+//! Prometheus orders results with these, and with comparators that are not total orders
+//! (NaN ranks first in `Less` against everything, `natsort.Compare` holds both ways for "1"
+//! and "01"). The order of such elements is part of the result, and Rust's sorts may panic on
+//! such comparators, so the exact algorithm is reproduced.
+
+/// Sorts `v` the way Go's `sort.Sort` does with `less` as `Less`.
+pub(crate) fn sort_by<T>(v: &mut [T], mut less: impl FnMut(&T, &T) -> bool) {
+    let n = v.len();
+    if n <= 1 {
+        return;
+    }
+    let limit = bit_len(n);
+    let mut sorter = Sorter { v, less: &mut less };
+    sorter.pdqsort(0, n, limit);
+}
+
+fn bit_len(n: usize) -> usize {
+    (usize::BITS - n.leading_zeros()) as usize
+}
+
+#[derive(PartialEq, Eq)]
+enum Hint {
+    Unknown,
+    Increasing,
+    Decreasing,
+}
+
+struct Sorter<'a, T, F> {
+    v: &'a mut [T],
+    less: &'a mut F,
+}
+
+impl<T, F: FnMut(&T, &T) -> bool> Sorter<'_, T, F> {
+    fn less(&mut self, i: usize, j: usize) -> bool {
+        (self.less)(&self.v[i], &self.v[j])
+    }
+
+    fn swap(&mut self, i: usize, j: usize) {
+        self.v.swap(i, j);
+    }
+
+    fn insertion_sort(&mut self, a: usize, b: usize) {
+        for i in a + 1..b {
+            let mut j = i;
+            while j > a && self.less(j, j - 1) {
+                self.swap(j, j - 1);
+                j -= 1;
+            }
+        }
+    }
+
+    fn sift_down(&mut self, lo: usize, hi: usize, first: usize) {
+        let mut root = lo;
+        loop {
+            let mut child = 2 * root + 1;
+            if child >= hi {
+                break;
+            }
+            if child + 1 < hi && self.less(first + child, first + child + 1) {
+                child += 1;
+            }
+            if !self.less(first + root, first + child) {
+                return;
+            }
+            self.swap(first + root, first + child);
+            root = child;
+        }
+    }
+
+    fn heap_sort(&mut self, a: usize, b: usize) {
+        let first = a;
+        let hi = b - a;
+        for i in (0..=(hi - 1) / 2).rev() {
+            self.sift_down(i, hi, first);
+        }
+        for i in (0..hi).rev() {
+            self.swap(first, first + i);
+            self.sift_down(0, i, first);
+        }
+    }
+
+    fn pdqsort(&mut self, mut a: usize, mut b: usize, mut limit: usize) {
+        const MAX_INSERTION: usize = 12;
+        let mut was_balanced = true;
+        let mut was_partitioned = true;
+        loop {
+            let length = b - a;
+            if length <= MAX_INSERTION {
+                self.insertion_sort(a, b);
+                return;
+            }
+            if limit == 0 {
+                self.heap_sort(a, b);
+                return;
+            }
+            if !was_balanced {
+                self.break_patterns(a, b);
+                limit -= 1;
+            }
+
+            let (mut pivot, mut hint) = self.choose_pivot(a, b);
+            if hint == Hint::Decreasing {
+                self.reverse_range(a, b);
+                pivot = (b - 1) - (pivot - a);
+                hint = Hint::Increasing;
+            }
+            if was_balanced
+                && was_partitioned
+                && hint == Hint::Increasing
+                && self.partial_insertion_sort(a, b)
+            {
+                return;
+            }
+            if a > 0 && !self.less(a - 1, pivot) {
+                a = self.partition_equal(a, b, pivot);
+                continue;
+            }
+
+            let (mid, already_partitioned) = self.partition(a, b, pivot);
+            was_partitioned = already_partitioned;
+            let (left_len, right_len) = (mid - a, b - mid);
+            let balance_threshold = length / 8;
+            if left_len < right_len {
+                was_balanced = left_len >= balance_threshold;
+                self.pdqsort(a, mid, limit);
+                a = mid + 1;
+            } else {
+                was_balanced = right_len >= balance_threshold;
+                self.pdqsort(mid + 1, b, limit);
+                b = mid;
+            }
+        }
+    }
+
+    // Indices stay signed here: `j` can step to `a` - 1 when nothing is below the pivot.
+    fn partition(&mut self, a: usize, b: usize, pivot: usize) -> (usize, bool) {
+        self.swap(a, pivot);
+        let (mut i, mut j) = (a as isize + 1, b as isize - 1);
+        let at = |k: isize| k as usize;
+        while i <= j && self.less(at(i), a) {
+            i += 1;
+        }
+        while i <= j && !self.less(at(j), a) {
+            j -= 1;
+        }
+        if i > j {
+            self.swap(at(j), a);
+            return (at(j), true);
+        }
+        self.swap(at(i), at(j));
+        i += 1;
+        j -= 1;
+        loop {
+            while i <= j && self.less(at(i), a) {
+                i += 1;
+            }
+            while i <= j && !self.less(at(j), a) {
+                j -= 1;
+            }
+            if i > j {
+                break;
+            }
+            self.swap(at(i), at(j));
+            i += 1;
+            j -= 1;
+        }
+        self.swap(at(j), a);
+        (at(j), false)
+    }
+
+    fn partition_equal(&mut self, a: usize, b: usize, pivot: usize) -> usize {
+        self.swap(a, pivot);
+        let (mut i, mut j) = (a as isize + 1, b as isize - 1);
+        let at = |k: isize| k as usize;
+        loop {
+            while i <= j && !self.less(a, at(i)) {
+                i += 1;
+            }
+            while i <= j && self.less(a, at(j)) {
+                j -= 1;
+            }
+            if i > j {
+                break;
+            }
+            self.swap(at(i), at(j));
+            i += 1;
+            j -= 1;
+        }
+        at(i)
+    }
+
+    fn partial_insertion_sort(&mut self, a: usize, b: usize) -> bool {
+        const MAX_STEPS: usize = 5;
+        const SHORTEST_SHIFTING: usize = 50;
+        let mut i = a + 1;
+        for _ in 0..MAX_STEPS {
+            while i < b && !self.less(i, i - 1) {
+                i += 1;
+            }
+            if i == b {
+                return true;
+            }
+            if b - a < SHORTEST_SHIFTING {
+                return false;
+            }
+            self.swap(i, i - 1);
+            if i - a >= 2 {
+                let mut j = i - 1;
+                while j >= 1 {
+                    if !self.less(j, j - 1) {
+                        break;
+                    }
+                    self.swap(j, j - 1);
+                    j -= 1;
+                }
+            }
+            if b - i >= 2 {
+                for j in i + 1..b {
+                    if !self.less(j, j - 1) {
+                        break;
+                    }
+                    self.swap(j, j - 1);
+                }
+            }
+        }
+        false
+    }
+
+    fn break_patterns(&mut self, a: usize, b: usize) {
+        let length = b - a;
+        if length >= 8 {
+            let mut random = length as u64;
+            let modulus = 1usize << bit_len(length);
+            for idx in a + (length / 4) * 2 - 1..=a + (length / 4) * 2 + 1 {
+                random ^= random << 13;
+                random ^= random >> 7;
+                random ^= random << 17;
+                let mut other = (random as usize) & (modulus - 1);
+                if other >= length {
+                    other -= length;
+                }
+                self.swap(idx, a + other);
+            }
+        }
+    }
+
+    fn choose_pivot(&mut self, a: usize, b: usize) -> (usize, Hint) {
+        const SHORTEST_NINTHER: usize = 50;
+        const MAX_SWAPS: usize = 4 * 3;
+        let l = b - a;
+        let mut swaps = 0;
+        let mut i = a + l / 4;
+        let mut j = a + l / 4 * 2;
+        let mut k = a + l / 4 * 3;
+        if l >= 8 {
+            if l >= SHORTEST_NINTHER {
+                i = self.median(i - 1, i, i + 1, &mut swaps);
+                j = self.median(j - 1, j, j + 1, &mut swaps);
+                k = self.median(k - 1, k, k + 1, &mut swaps);
+            }
+            j = self.median(i, j, k, &mut swaps);
+        }
+        match swaps {
+            0 => (j, Hint::Increasing),
+            MAX_SWAPS => (j, Hint::Decreasing),
+            _ => (j, Hint::Unknown),
+        }
+    }
+
+    fn order2(&mut self, a: usize, b: usize, swaps: &mut usize) -> (usize, usize) {
+        if self.less(b, a) {
+            *swaps += 1;
+            return (b, a);
+        }
+        (a, b)
+    }
+
+    fn median(&mut self, a: usize, b: usize, c: usize, swaps: &mut usize) -> usize {
+        let (a, b) = self.order2(a, b, swaps);
+        let (b, _) = self.order2(b, c, swaps);
+        let (_, b) = self.order2(a, b, swaps);
+        b
+    }
+
+    fn reverse_range(&mut self, a: usize, b: usize) {
+        let (mut i, mut j) = (a, b - 1);
+        while i < j {
+            self.swap(i, j);
+            i += 1;
+            j -= 1;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    /// Orders produced by Go's `sort.Sort` (and identically `slices.SortFunc`), generated by
+    /// promql-compat `cmd/narthex-golden-gosort`; line format: `kind keys | ids`.
+    #[test]
+    fn matches_go_sort_on_comparators_that_are_not_total_orders() {
+        let text = include_str!("go_sort_cases.txt");
+        let mut cases = 0;
+        for line in text.lines() {
+            let (head, expected) = line.split_once(" | ").unwrap();
+            let (kind, keys) = head.split_once(' ').unwrap();
+            let kind: u8 = kind.parse().unwrap();
+            let parse = |list: &str| -> Vec<usize> {
+                list.split(',')
+                    .filter(|item| !item.is_empty())
+                    .map(|item| item.trim().parse().unwrap())
+                    .collect()
+            };
+            let mut items: Vec<(usize, usize)> = parse(keys).into_iter().zip(0..).collect();
+            super::sort_by(&mut items, |&(a, a_id), &(b, b_id)| match kind {
+                0 => a < b,
+                1 => a == 0 || a < b,
+                2 => a % 3 < b % 3,
+                _ => (a_id * 31 + b_id * 17) % 5 < 2,
+            });
+            let actual: Vec<usize> = items.iter().map(|&(_, id)| id).collect();
+            assert_eq!(actual, parse(expected), "{line}");
+            cases += 1;
+        }
+        assert!(cases >= 200);
+    }
+}

src/promql/src/go_sort_cases.txt

@@ -0,0 +1,208 @@
+0  | 
+0  | 
+0  | 
+0  | 
+1  | 
+1  | 
+1  | 
+1  | 
+2  | 
+2  | 
+2  | 
+2  | 
+3  | 
+3  | 
+3  | 
+3  | 
+0 0 | 0
+0 0 | 0
+0 1 | 0
+0 0 | 0
+1 0 | 0
+1 0 | 0
+1 1 | 0
+1 0 | 0
+2 0 | 0
+2 0 | 0
+2 1 | 0
+2 0 | 0
+3 0 | 0
+3 0 | 0
+3 1 | 0
+3 0 | 0
+0 1,0 | 1,0
+0 0,1 | 0,1
+0 2,1 | 1,0
+0 0,1 | 0,1
+1 1,0 | 1,0
+1 0,1 | 0,1
+1 2,1 | 1,0
+1 0,1 | 0,1
+2 0,0 | 0,1
+2 0,1 | 0,1
+2 2,1 | 1,0
+2 0,1 | 0,1
+3 0,1 | 1,0
+3 0,1 | 1,0
+3 2,1 | 1,0
+3 0,1 | 1,0
+0 0,2,1,2,0 | 0,4,2,1,3
+0 0,1,2,3,4 | 0,1,2,3,4
+0 5,4,3,2,1 | 4,3,2,1,0
+0 0,1,2,3,4 | 0,1,2,3,4
+1 2,2,2,2,0 | 4,0,1,2,3
+1 0,1,2,3,4 | 0,1,2,3,4
+1 5,4,3,2,1 | 4,3,2,1,0
+1 0,1,2,3,4 | 0,1,2,3,4
+2 2,1,0,1,1 | 2,1,3,4,0
+2 0,1,2,3,4 | 0,3,1,4,2
+2 5,4,3,2,1 | 2,1,4,0,3
+2 0,1,2,3,4 | 0,3,1,4,2
+3 1,0,0,1,0 | 1,0,2,4,3
+3 0,1,2,3,4 | 1,0,2,4,3
+3 5,4,3,2,1 | 1,0,2,4,3
+3 0,1,2,3,4 | 1,0,2,4,3
+0 6,4,3,6,0,0,5,4,6,3,6,0 | 4,5,11,2,9,1,7,6,0,3,8,10
+0 0,1,2,3,4,5,6,7,8,9,10,11 | 0,1,2,3,4,5,6,7,8,9,10,11
+0 12,11,10,9,8,7,6,5,4,3,2,1 | 11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4 | 0,7,1,8,2,9,3,10,4,11,5,6
+1 6,1,1,4,6,4,6,0,5,0,1,4 | 9,7,1,2,10,3,5,11,8,0,4,6
+1 0,1,2,3,4,5,6,7,8,9,10,11 | 0,1,2,3,4,5,6,7,8,9,10,11
+1 12,11,10,9,8,7,6,5,4,3,2,1 | 11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4 | 7,0,1,8,2,9,3,10,4,11,5,6
+2 2,3,5,6,5,0,1,3,5,4,0,1 | 1,3,5,7,10,6,9,11,0,2,4,8
+2 0,1,2,3,4,5,6,7,8,9,10,11 | 0,3,6,9,1,4,7,10,2,5,8,11
+2 12,11,10,9,8,7,6,5,4,3,2,1 | 0,3,6,9,2,5,8,11,1,4,7,10
+2 0,1,2,3,4,5,6,0,1,2,3,4 | 0,3,6,7,10,1,4,8,11,2,5,9
+3 5,2,1,0,1,2,3,4,0,0,6,5 | 1,0,2,4,5,3,6,7,9,10,8,11
+3 0,1,2,3,4,5,6,7,8,9,10,11 | 1,0,2,4,5,3,6,7,9,10,8,11
+3 12,11,10,9,8,7,6,5,4,3,2,1 | 1,0,2,4,5,3,6,7,9,10,8,11
+3 0,1,2,3,4,5,6,0,1,2,3,4 | 1,0,2,4,5,3,6,7,9,10,8,11
+0 0,1,0,3,5,3,4,6,1,5,6,3,6 | 2,0,8,1,3,11,5,6,9,4,7,10,12
+0 0,1,2,3,4,5,6,7,8,9,10,11,12 | 0,1,2,3,4,5,6,7,8,9,10,11,12
+0 13,12,11,10,9,8,7,6,5,4,3,2,1 | 12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5 | 7,0,1,8,2,9,3,10,4,11,5,12,6
+1 5,3,4,6,6,6,2,6,3,5,3,5,3 | 6,1,12,10,8,2,9,0,11,7,5,4,3
+1 0,1,2,3,4,5,6,7,8,9,10,11,12 | 0,1,2,3,4,5,6,7,8,9,10,11,12
+1 13,12,11,10,9,8,7,6,5,4,3,2,1 | 12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5 | 0,7,1,8,2,9,3,10,4,11,5,12,6
+2 0,1,0,5,4,0,6,1,5,5,6,2,0 | 10,2,0,5,6,12,1,4,7,3,9,11,8
+2 0,1,2,3,4,5,6,7,8,9,10,11,12 | 6,3,0,9,12,1,4,7,10,2,5,8,11
+2 13,12,11,10,9,8,7,6,5,4,3,2,1 | 4,1,10,7,6,0,3,9,12,5,8,2,11
+2 0,1,2,3,4,5,6,0,1,2,3,4,5 | 6,3,0,7,10,1,4,8,11,2,5,9,12
+3 3,2,6,4,6,5,6,6,4,0,4,3,4 | 10,5,9,0,4,3,6,7,8,1,11,12,2
+3 0,1,2,3,4,5,6,7,8,9,10,11,12 | 10,5,9,0,4,3,6,7,8,1,11,12,2
+3 13,12,11,10,9,8,7,6,5,4,3,2,1 | 10,5,9,0,4,3,6,7,8,1,11,12,2
+3 0,1,2,3,4,5,6,0,1,2,3,4,5 | 10,5,9,0,4,3,6,7,8,1,11,12,2
+0 9,8,10,6,6,4,0,9,2,3,3,1,6,7,4,4,6,7,6,0 | 6,19,11,8,10,9,5,14,15,16,3,12,4,18,13,17,1,0,7,2
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19
+0 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5 | 14,0,7,1,15,8,9,2,16,10,3,17,11,4,18,12,5,19,6,13
+1 4,9,1,1,3,5,7,2,8,3,6,4,0,6,9,2,7,2,2,4 | 12,2,3,18,7,17,15,4,9,19,0,11,5,13,10,16,6,8,14,1
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19
+1 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5 | 7,0,14,1,15,8,9,2,16,10,3,17,11,4,18,12,5,19,6,13
+2 8,9,7,5,10,4,2,2,2,8,6,6,4,9,0,5,8,2,9,5 | 10,1,18,14,13,11,5,12,2,4,6,0,7,9,3,15,16,17,8,19
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 | 9,18,15,3,12,0,6,10,7,4,13,16,1,19,8,5,11,14,2,17
+2 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 8,17,2,14,11,5,10,16,19,1,7,4,13,12,3,15,0,9,18,6
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5 | 10,17,0,3,14,13,6,7,15,8,11,4,1,18,9,12,5,2,16,19
+3 9,1,5,6,6,10,10,8,10,7,1,5,4,1,5,4,8,2,7,3 | 1,16,11,6,5,15,0,10,9,8,12,7,13,3,17,2,18,4,14,19
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 | 1,16,11,6,5,15,0,10,9,8,12,7,13,3,17,2,18,4,14,19
+3 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 1,16,11,6,5,15,0,10,9,8,12,7,13,3,17,2,18,4,14,19
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5 | 1,16,11,6,5,15,0,10,9,8,12,7,13,3,17,2,18,4,14,19
+0 3,13,18,6,19,7,7,2,0,6,3,20,17,18,20,21,11,7,20,10,22,4,11,10,20,4,4,14,10,1,6,7,16,0,14,12,8,11,4,10,9,15,19,14,15,12,15,0,9 | 33,47,8,29,7,0,10,21,26,25,38,9,30,3,17,5,31,6,36,48,40,23,19,39,28,22,16,37,35,45,1,27,34,43,41,44,46,32,12,13,2,42,4,24,18,14,11,15,20
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48
+0 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6 | 7,0,28,14,35,42,21,36,8,22,1,43,15,29,44,30,16,2,37,23,9,24,31,10,38,17,45,3,25,4,39,11,32,18,46,40,5,47,33,12,19,26,34,13,27,41,20,6,48
+1 23,10,18,21,15,24,19,20,11,13,22,19,20,24,12,24,18,6,23,2,20,22,21,17,1,15,7,4,17,4,6,21,5,11,18,3,16,9,17,8,8,3,3,24,9,0,24,6,12 | 45,24,19,35,41,42,29,27,32,30,47,17,26,39,40,37,44,1,33,8,14,48,9,25,4,36,38,28,23,16,2,34,6,11,7,20,12,3,31,22,10,21,0,18,13,43,15,5,46
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48
+1 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6 | 21,42,35,14,28,0,7,36,8,22,1,43,15,29,44,30,16,2,37,23,9,24,31,10,38,17,45,3,25,4,39,11,32,18,46,40,5,47,33,12,19,26,34,13,27,41,20,6,48
+2 11,17,14,8,9,21,23,24,12,7,24,14,6,21,8,3,16,1,2,12,11,1,5,12,14,23,12,5,9,3,9,11,2,18,20,21,3,15,20,6,5,1,9,16,6,20,5,9,2 | 36,37,47,44,4,5,42,7,8,39,10,26,12,13,35,15,33,30,29,19,28,23,17,21,43,9,41,16,3,14,20,31,32,22,27,24,0,11,38,18,40,25,6,1,34,45,46,2,48
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48 | 24,18,48,3,45,42,6,39,36,9,33,30,12,27,0,15,21,37,10,19,46,16,22,4,1,43,25,13,28,40,7,31,34,41,29,35,8,26,38,11,32,14,5,17,44,23,20,47,2
+2 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 16,1,46,43,4,40,37,7,34,31,10,28,25,13,22,19,24,33,18,15,48,21,45,3,0,12,42,27,39,6,30,9,36,41,26,35,32,29,38,8,11,17,5,23,44,14,2,47,20
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6 | 21,48,45,3,42,41,6,7,38,0,10,35,34,13,14,31,28,17,27,24,20,36,11,1,46,25,43,18,4,29,39,15,32,8,22,12,16,37,33,30,40,5,9,26,44,2,19,47,23
+3 17,3,0,18,5,8,6,15,8,9,17,23,12,23,22,3,8,2,21,23,13,6,24,6,15,6,7,2,2,4,8,5,11,12,12,4,21,18,23,6,15,22,20,19,6,24,24,20,19 | 12,7,42,32,47,27,2,17,22,37,38,33,8,13,43,28,3,48,18,23,24,35,1,19,4,46,26,16,44,29,6,31,14,11,34,21,36,41,9,39,20,0,25,45,15,5,30,10,40
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48 | 12,7,42,32,47,27,2,17,22,37,38,33,8,13,43,28,3,48,18,23,24,35,1,19,4,46,26,16,44,29,6,31,14,11,34,21,36,41,9,39,20,0,25,45,15,5,30,10,40
+3 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 12,7,42,32,47,27,2,17,22,37,38,33,8,13,43,28,3,48,18,23,24,35,1,19,4,46,26,16,44,29,6,31,14,11,34,21,36,41,9,39,20,0,25,45,15,5,30,10,40
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6 | 12,7,42,32,47,27,2,17,22,37,38,33,8,13,43,28,3,48,18,23,24,35,1,19,4,46,26,16,44,29,6,31,14,11,34,21,36,41,9,39,20,0,25,45,15,5,30,10,40
+0 23,25,24,5,17,14,17,14,3,12,1,13,3,17,25,13,15,13,17,22,2,9,15,12,7,3,19,9,12,7,0,24,14,17,18,20,5,20,12,0,15,18,21,6,25,7,1,11,12,24 | 30,39,46,10,20,12,25,8,3,36,43,45,29,24,27,21,47,38,9,23,28,48,11,17,15,5,32,7,16,22,40,13,18,4,6,33,41,34,26,37,35,42,19,0,31,2,49,14,44,1
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49
+0 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 35,21,0,49,28,14,42,7,15,22,1,36,8,29,43,9,16,30,44,2,23,37,24,17,3,10,38,45,31,46,4,18,32,39,11,25,12,5,19,33,40,47,26,20,13,27,6,41,48,34
+1 24,19,4,9,21,6,22,5,5,1,1,6,6,2,13,16,1,0,4,17,4,20,13,20,25,9,16,23,12,25,14,19,0,17,11,20,19,12,24,6,12,18,21,24,1,0,3,3,21,14 | 17,32,45,9,44,10,16,13,47,46,20,18,2,8,7,39,12,11,5,25,3,34,28,37,40,22,14,49,30,26,15,19,33,41,36,1,31,21,35,23,48,4,42,6,27,38,43,0,24,29
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49
+1 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 7,42,14,28,49,0,21,35,15,22,1,36,8,29,43,9,16,30,44,2,23,37,24,17,3,10,38,45,31,46,4,18,32,39,11,25,12,5,19,33,40,47,26,20,13,27,6,41,48,34
+2 23,8,5,18,5,6,15,24,2,10,12,23,8,20,1,4,24,19,13,3,19,9,0,24,17,17,3,4,3,12,8,24,11,15,17,20,2,9,8,14,6,9,7,24,4,21,22,1,19,2 | 16,22,31,3,37,5,6,7,33,29,10,28,43,26,40,41,45,23,21,19,20,18,14,15,17,48,42,27,44,9,46,47,24,32,34,35,36,30,38,39,25,0,13,12,11,8,4,2,1,49
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49 | 18,48,45,3,42,39,6,36,33,9,30,27,12,0,24,15,21,25,4,19,49,16,22,1,46,13,43,40,28,37,10,31,7,34,17,26,32,29,38,5,35,11,8,41,44,2,14,47,23,20
+2 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 17,47,2,44,41,5,38,35,8,32,29,11,26,23,14,20,25,34,49,19,1,46,22,13,43,16,4,40,28,10,37,31,7,0,42,9,36,30,6,39,27,12,33,24,3,45,21,15,48,18
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 24,49,48,3,45,42,6,7,41,38,10,35,34,13,14,31,28,17,27,0,20,21,25,11,22,1,46,18,4,29,43,15,32,8,39,36,5,2,9,12,40,33,44,23,37,16,26,47,30,19
+3 12,11,5,17,3,6,23,16,22,15,25,22,21,6,16,12,25,2,11,21,2,23,0,18,9,11,3,18,24,4,14,5,10,10,4,24,4,16,10,10,7,16,6,1,15,13,1,15,1,6 | 36,1,46,26,41,31,16,6,11,21,15,0,20,5,25,40,30,45,10,35,34,49,22,47,24,17,14,27,2,29,44,12,32,42,19,9,4,37,7,39,38,8,33,43,13,3,28,23,48,18
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49 | 36,1,46,26,41,31,16,6,11,21,15,0,20,5,25,40,30,45,10,35,34,49,22,47,24,17,14,27,2,29,44,12,32,42,19,9,4,37,7,39,38,8,33,43,13,3,28,23,48,18
+3 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 36,1,46,26,41,31,16,6,11,21,15,0,20,5,25,40,30,45,10,35,34,49,22,47,24,17,14,27,2,29,44,12,32,42,19,9,4,37,7,39,38,8,33,43,13,3,28,23,48,18
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 36,1,46,26,41,31,16,6,11,21,15,0,20,5,25,40,30,45,10,35,34,49,22,47,24,17,14,27,2,29,44,12,32,42,19,9,4,37,7,39,38,8,33,43,13,3,28,23,48,18
+0 7,12,11,20,8,3,9,20,12,12,15,1,7,2,18,9,12,9,9,23,25,20,0,8,8,18,13,1,0,10,16,18,22,16,15,14,16,6,13,2,25,6,0,2,25,0,8,13,11,16,11 | 28,45,22,42,27,11,39,43,13,5,37,41,0,12,24,23,4,46,15,17,18,6,29,2,48,50,1,9,8,16,26,47,38,35,10,34,33,30,36,49,14,31,25,3,7,21,32,19,40,44,20
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50
+0 51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 42,21,0,28,49,14,35,7,15,29,8,22,36,43,1,50,16,30,9,23,2,44,37,24,10,3,45,38,31,17,11,25,32,4,46,18,39,26,47,12,40,19,33,5,6,13,34,27,48,20,41
+1 8,1,0,0,19,11,24,7,3,0,14,15,14,21,5,14,10,16,8,4,23,18,5,25,23,25,17,11,2,25,19,23,2,3,9,9,5,20,24,25,7,17,2,14,21,6,15,21,21,11,6 | 9,2,3,1,28,32,42,33,8,19,36,22,14,50,45,7,40,0,18,34,35,16,49,27,5,12,15,43,10,11,46,17,26,41,21,4,30,37,13,44,47,48,20,24,31,38,6,39,23,25,29
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50
+1 51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 7,35,14,49,28,0,21,42,15,29,8,22,36,43,1,50,16,30,9,23,2,44,37,24,10,3,45,38,31,17,11,25,32,4,46,18,39,26,47,12,40,19,33,5,6,13,34,27,48,20,41
+2 18,23,0,11,6,16,0,17,12,13,4,1,25,1,5,4,11,7,23,10,25,25,5,13,0,21,19,0,24,24,16,22,25,10,16,16,5,1,20,2,16,13,9,24,22,17,13,2,6,10,10 | 24,48,2,43,4,42,6,29,8,28,27,25,0,12,32,15,50,17,49,19,20,21,46,23,13,11,26,10,9,44,30,31,5,33,34,35,41,37,40,39,38,36,14,3,7,45,22,47,1,18,16
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50 | 18,48,45,3,42,39,6,36,33,9,30,27,12,0,24,15,21,25,4,19,49,16,22,1,46,13,43,40,28,37,10,31,7,34,17,26,32,29,38,5,11,41,35,44,8,2,14,47,23,20,50
+2 51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 18,48,45,3,42,39,6,36,33,9,30,27,12,24,0,15,21,23,17,50,20,47,2,14,44,41,26,11,5,29,38,35,32,8,34,43,7,37,10,28,40,25,4,31,13,22,46,16,1,49,19
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 24,49,48,3,45,42,6,7,41,38,10,35,34,13,14,31,28,17,27,0,20,21,25,29,22,50,1,18,46,39,4,15,32,43,8,11,36,37,9,23,40,12,5,33,44,30,16,47,2,26,19
+3 11,3,19,10,13,24,14,2,18,5,10,5,14,7,18,21,21,23,18,0,25,22,4,23,4,9,7,0,16,20,23,3,0,0,0,25,11,17,7,14,13,23,21,15,0,24,14,18,18,16,2 | 41,31,21,46,16,36,6,1,26,11,45,15,30,50,40,5,25,20,0,10,35,42,48,23,3,18,43,8,28,38,33,13,27,17,47,37,32,12,22,2,7,9,19,39,44,4,24,29,34,49,14
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50 | 41,31,21,46,16,36,6,1,26,11,45,15,30,50,40,5,25,20,0,10,35,42,48,23,3,18,43,8,28,38,33,13,27,17,47,37,32,12,22,2,7,9,19,39,44,4,24,29,34,49,14
+3 51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 41,31,21,46,16,36,6,1,26,11,45,15,30,50,40,5,25,20,0,10,35,42,48,23,3,18,43,8,28,38,33,13,27,17,47,37,32,12,22,2,7,9,19,39,44,4,24,29,34,49,14
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 41,31,21,46,16,36,6,1,26,11,45,15,30,50,40,5,25,20,0,10,35,42,48,23,3,18,43,8,28,38,33,13,27,17,47,37,32,12,22,2,7,9,19,39,44,4,24,29,34,49,14
+0 0,5,13,1,12,30,1,25,26,18,15,21,15,0,4,21,3,16,3,5,9,24,4,21,14,18,11,0,1,5,2,13,28,6,1,22,12,23,21,29,4,15,1,5,10,9,31,17,11,14,16,0,5,6,19,23,18,26,29,2,27,17,26,10 | 27,0,51,13,6,28,3,42,34,59,30,18,16,40,14,22,52,29,1,19,43,53,33,20,45,63,44,26,48,36,4,2,31,49,24,12,41,10,50,17,61,47,56,9,25,54,23,15,11,38,35,55,37,21,7,8,57,62,60,32,58,39,5,46
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
+0 64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 56,28,49,21,63,42,0,7,14,35,8,57,50,43,1,15,22,29,36,9,37,2,16,23,51,58,44,30,24,10,52,31,45,59,38,3,17,32,46,39,4,60,11,53,18,25,19,5,40,61,47,26,33,12,54,55,27,13,6,34,41,20,62,48
+1 14,24,10,27,16,19,18,1,21,5,21,3,22,3,20,2,1,14,10,5,1,22,22,13,0,0,21,12,9,7,21,24,1,4,8,26,19,3,15,21,24,7,20,8,24,20,32,3,6,11,1,14,21,14,30,12,14,14,17,11,11,29,26,26 | 24,25,50,32,7,20,16,15,13,47,37,11,33,9,19,48,41,29,43,34,28,2,18,49,59,60,55,27,23,51,57,0,17,56,53,38,4,58,6,5,36,45,14,42,8,30,39,10,26,52,21,12,22,31,1,44,40,62,35,63,3,61,54,46
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
+1 64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 56,7,0,42,14,35,21,49,28,63,29,57,8,43,50,15,22,36,1,9,37,2,16,23,51,58,44,30,24,10,52,31,45,59,38,3,17,32,46,39,4,60,11,53,18,25,19,5,40,61,47,26,33,12,54,55,27,13,6,34,41,20,62,48
+2 27,13,32,1,15,10,27,9,22,21,16,3,32,6,15,15,21,24,2,31,4,26,10,24,10,17,1,17,27,26,11,12,31,14,11,28,18,2,12,16,2,12,26,5,19,22,1,27,17,17,13,13,2,6,4,3,14,5,29,8,2,19,14,32 | 23,4,6,7,9,55,53,47,41,38,11,36,0,13,14,15,16,17,31,28,32,51,22,20,24,61,26,1,19,54,3,50,5,46,45,35,44,8,10,39,52,33,42,43,2,34,21,12,48,49,37,18,56,30,29,27,40,57,58,59,60,25,62,63
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63 | 24,63,60,3,57,54,6,51,48,9,45,42,12,39,36,15,33,0,18,30,27,21,31,43,22,25,1,61,28,58,19,4,55,16,34,52,7,37,49,13,40,46,10,53,5,11,41,47,8,38,50,14,35,44,32,23,56,17,29,59,2,20,62,26
+2 64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 22,1,61,58,4,55,52,7,49,46,10,43,40,13,37,34,16,31,28,19,25,33,6,63,24,60,3,27,18,57,30,54,21,0,15,51,36,48,9,39,12,45,42,53,17,41,38,47,14,8,50,35,32,44,5,11,56,29,26,59,20,2,62,23
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 28,63,62,3,59,56,6,7,55,52,10,49,48,13,14,0,45,17,42,41,20,21,38,35,24,34,31,27,15,46,1,60,32,4,25,57,36,29,22,39,8,53,18,43,50,11,37,40,12,16,44,51,9,19,54,47,5,23,58,33,26,61,2,30
+3 6,3,27,8,19,1,0,31,30,21,21,12,10,25,24,23,27,26,24,23,25,19,17,7,27,13,25,24,6,13,22,6,10,13,22,31,30,15,24,2,19,29,17,2,28,9,9,15,16,20,0,27,26,12,4,0,4,30,32,30,5,13,2,25 | 41,6,31,36,61,46,11,26,56,1,21,51,16,2,22,47,62,57,7,17,52,42,12,27,37,32,53,63,28,3,30,23,0,33,60,35,20,58,38,5,40,18,15,43,8,45,55,13,48,25,50,10,9,49,54,14,44,39,19,59,34,4,29,24
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63 | 41,6,31,36,61,46,11,26,56,1,21,51,16,2,22,47,62,57,7,17,52,42,12,27,37,32,53,63,28,3,30,23,0,33,60,35,20,58,38,5,40,18,15,43,8,45,55,13,48,25,50,10,9,49,54,14,44,39,19,59,34,4,29,24
+3 64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 41,6,31,36,61,46,11,26,56,1,21,51,16,2,22,47,62,57,7,17,52,42,12,27,37,32,53,63,28,3,30,23,0,33,60,35,20,58,38,5,40,18,15,43,8,45,55,13,48,25,50,10,9,49,54,14,44,39,19,59,34,4,29,24
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0 | 41,6,31,36,61,46,11,26,56,1,21,51,16,2,22,47,62,57,7,17,52,42,12,27,37,32,53,63,28,3,30,23,0,33,60,35,20,58,38,5,40,18,15,43,8,45,55,13,48,25,50,10,9,49,54,14,44,39,19,59,34,4,29,24
+0 19,7,7,31,49,38,37,49,50,48,20,6,43,43,13,41,27,45,2,16,31,30,5,31,31,42,47,29,43,34,21,50,36,14,45,14,22,44,11,11,26,9,31,35,24,42,1,3,22,39,41,2,3,21,9,25,0,30,50,26,30,45,20,17,19,4,44,39,16,30,17,19,35,47,37,22,11,37,6,46,13,24,23,15,46,42,24,41,31,8,15,48,8,26,45,31,8,34,11,34 | 56,46,18,51,47,52,65,22,78,11,1,2,96,92,89,54,41,38,76,98,39,14,80,33,35,90,83,19,68,70,63,71,0,64,62,10,53,30,36,75,48,82,81,44,86,55,40,93,59,16,27,60,57,69,21,42,95,24,3,20,88,23,97,29,99,43,72,32,6,74,77,5,49,67,87,50,15,45,85,25,12,13,28,37,66,34,94,61,17,79,84,26,73,91,9,7,4,31,58,8
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99
+0 100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 21,56,63,49,70,98,42,7,35,77,28,84,0,91,14,29,99,57,1,64,85,15,22,50,43,92,71,36,8,78,44,86,79,58,30,2,51,37,23,65,72,93,16,9,24,87,31,66,73,94,52,80,45,38,10,59,3,17,25,39,60,4,95,11,53,88,18,67,81,32,46,74,89,19,61,75,5,96,33,54,12,68,82,47,26,40,20,69,48,55,90,13,27,83,6,62,34,97,76,41
+1 35,27,50,10,46,32,25,24,16,24,36,50,16,38,19,19,47,37,32,1,12,38,30,39,14,15,44,45,11,50,29,8,48,40,49,31,21,36,47,24,26,40,48,15,27,14,33,41,18,28,11,30,28,19,18,20,46,28,11,48,47,4,8,26,5,14,42,17,23,20,38,0,30,45,2,0,30,38,50,31,9,49,42,11,9,36,39,45,41,49,3,36,35,45,1,7,5,14,46,27 | 75,71,94,19,74,90,61,96,64,95,62,31,80,84,3,28,83,58,50,20,65,45,97,24,25,43,12,8,67,48,54,14,15,53,69,55,36,68,39,9,7,6,40,63,99,1,44,52,49,57,30,22,51,72,76,79,35,5,18,46,92,0,91,37,85,10,17,77,13,21,70,23,86,41,33,88,47,66,82,26,87,93,73,27,4,98,56,38,16,60,42,32,59,89,81,34,29,2,78,11
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99
+1 100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 84,28,77,35,7,91,98,70,49,63,56,0,14,21,42,29,99,57,1,64,85,15,22,50,43,92,71,36,8,78,44,86,79,58,30,2,51,37,23,65,72,93,16,9,24,87,31,66,73,94,52,80,45,38,10,59,3,17,25,39,60,4,95,11,53,88,18,67,81,32,46,74,89,19,61,75,5,96,33,54,12,68,82,47,26,40,20,69,48,55,90,13,27,83,6,62,34,97,76,41
+2 7,34,22,28,34,45,37,8,37,33,46,7,29,0,17,37,43,15,19,41,27,48,7,48,6,45,20,50,30,32,1,17,10,5,12,3,31,19,17,31,35,34,19,11,16,22,16,0,34,4,12,18,7,44,44,36,35,44,5,8,0,35,19,5,47,20,0,12,15,40,28,27,13,39,18,2,27,11,27,34,39,2,34,12,50,37,49,25,12,22,35,33,50,15,32,14,43,25,49,10 | 51,74,93,50,91,5,88,83,80,9,78,76,73,13,71,68,67,17,66,60,20,21,55,23,24,25,47,35,28,34,10,6,32,99,98,97,96,37,2,18,3,41,42,4,44,45,46,89,36,72,87,0,52,86,85,22,82,8,79,11,49,1,62,30,48,70,39,16,15,69,26,14,63,12,64,75,59,77,65,58,57,81,56,7,84,54,53,92,19,31,90,43,40,38,94,95,61,27,29,33
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 | 36,99,96,3,93,90,6,87,84,9,81,78,12,75,72,15,69,66,18,63,60,21,57,54,24,51,0,27,48,45,30,42,39,33,49,67,34,37,1,97,40,94,31,43,4,91,46,88,28,7,85,25,52,82,10,55,79,22,58,76,13,61,73,19,64,70,16,17,8,35,65,71,14,62,74,20,59,77,11,56,80,23,53,83,68,50,86,26,47,89,5,29,92,44,41,95,2,32,98,38
+2 100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 34,1,97,94,4,91,88,7,85,82,10,79,76,13,73,70,16,67,64,19,61,58,22,55,52,25,49,46,28,43,40,31,37,51,84,99,36,96,3,39,30,93,42,90,6,45,27,87,48,33,69,0,24,9,54,81,78,57,21,12,60,75,72,63,18,15,66,26,68,17,65,71,62,14,74,20,59,77,56,11,80,23,53,83,50,8,86,47,44,89,29,5,92,41,38,95,32,2,98,35
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 45,98,97,3,94,91,6,7,90,87,10,84,83,13,14,80,77,17,76,73,20,21,70,69,24,66,63,27,28,62,59,31,56,55,34,35,52,0,38,49,48,41,42,50,88,43,46,99,1,39,95,4,36,53,92,8,32,57,74,85,60,11,29,81,64,15,25,67,78,18,22,71,72,19,44,75,23,16,68,79,65,26,82,12,61,30,86,9,58,89,33,5,54,93,51,37,96,2,40,47
+3 35,48,0,22,38,44,21,20,0,13,14,41,42,19,20,1,22,41,8,32,0,41,2,29,44,49,1,48,17,46,7,4,33,2,38,43,25,50,6,25,15,38,22,0,18,4,25,8,10,43,2,47,31,24,14,19,21,23,13,8,46,32,0,46,6,44,28,40,42,17,18,12,41,25,12,11,2,22,33,13,41,31,9,32,21,0,50,47,27,18,49,19,40,24,8,15,7,32,4,41 | 54,99,39,44,4,94,49,89,9,34,29,84,69,59,14,79,64,74,24,19,73,43,68,23,18,78,63,13,28,83,58,88,53,33,8,93,48,3,38,98,51,81,76,1,41,71,46,11,36,21,96,6,91,66,31,86,56,26,16,61,2,47,77,32,42,37,82,87,57,52,27,72,17,92,67,97,62,7,22,12,90,55,30,45,25,35,5,50,85,70,15,75,0,95,65,10,40,20,80,60
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 | 54,99,39,44,4,94,49,89,9,34,29,84,69,59,14,79,64,74,24,19,73,43,68,23,18,78,63,13,28,83,58,88,53,33,8,93,48,3,38,98,51,81,76,1,41,71,46,11,36,21,96,6,91,66,31,86,56,26,16,61,2,47,77,32,42,37,82,87,57,52,27,72,17,92,67,97,62,7,22,12,90,55,30,45,25,35,5,50,85,70,15,75,0,95,65,10,40,20,80,60
+3 100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 54,99,39,44,4,94,49,89,9,34,29,84,69,59,14,79,64,74,24,19,73,43,68,23,18,78,63,13,28,83,58,88,53,33,8,93,48,3,38,98,51,81,76,1,41,71,46,11,36,21,96,6,91,66,31,86,56,26,16,61,2,47,77,32,42,37,82,87,57,52,27,72,17,92,67,97,62,7,22,12,90,55,30,45,25,35,5,50,85,70,15,75,0,95,65,10,40,20,80,60
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1 | 54,99,39,44,4,94,49,89,9,34,29,84,69,59,14,79,64,74,24,19,73,43,68,23,18,78,63,13,28,83,58,88,53,33,8,93,48,3,38,98,51,81,76,1,41,71,46,11,36,21,96,6,91,66,31,86,56,26,16,61,2,47,77,32,42,37,82,87,57,52,27,72,17,92,67,97,62,7,22,12,90,55,30,45,25,35,5,50,85,70,15,75,0,95,65,10,40,20,80,60
+0 119,72,50,19,51,100,17,38,118,15,81,72,35,31,19,127,35,93,126,86,45,38,65,87,107,78,95,14,87,83,76,30,17,94,4,103,125,94,79,115,13,67,81,76,35,51,119,68,30,105,111,79,89,93,74,56,107,5,75,28,44,2,61,36,64,39,41,110,118,75,75,101,69,113,42,77,18,50,64,109,86,104,118,111,88,31,22,41,74,96,59,10,60,73,91,89,47,54,94,61,92,95,127,111,86,109,48,3,76,119,32,75,38,36,121,2,51,118,119,119,46,109,106,53,122,84,71,49,48,111,60,72,69,115,17,108,119,44,35,47,3,24,100,19,74,96,101,62,13,10,100,81,128,79,50,90,23,88,78,102,51,71,10,84,65,33,108,91,30,122,125,41,75,102,124,18,7,49,67,76,75,126,118,49,80,95,121,68,10,117,13,9,100,67,42,68,104,77,9,99,126,99,37,27,117,64,49,3,105,90,95,61,45,47,111,70,29,113,23,48,14,15,17,24,126,56,98,45,127,93,113,46,49,112,89,32,21,17,16,35,14,45,66,87,4,9,1,76,51,15,120,107,50,74,44,53,42 | 246,61,115,207,140,107,244,34,57,176,245,191,198,91,162,149,188,190,40,148,220,240,27,9,221,249,238,237,222,134,32,6,76,175,14,143,3,236,86,156,218,223,141,203,59,216,48,31,168,85,13,110,235,165,138,16,239,12,44,113,63,202,21,7,112,65,87,171,66,74,256,194,254,137,60,227,241,212,20,231,120,139,213,96,219,106,128,127,177,206,183,232,77,154,252,2,160,45,248,116,4,123,255,97,55,225,90,130,92,62,99,211,147,64,78,205,22,164,242,178,193,41,47,195,187,72,132,215,126,161,11,131,1,93,88,144,54,253,172,69,180,70,58,111,108,179,247,30,43,75,197,25,158,153,38,51,184,151,10,42,29,163,125,104,19,80,23,28,243,157,84,52,95,234,155,209,167,94,100,17,229,53,37,98,33,101,185,26,210,89,145,226,201,199,5,150,192,142,71,146,173,159,35,196,81,208,49,122,251,56,24,135,166,79,105,121,67,103,50,83,214,129,233,73,230,217,133,39,204,189,68,82,117,182,8,119,136,109,0,118,46,250,186,114,169,124,174,36,170,181,18,224,200,102,228,15,152
+0 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256
+0 257,256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+0 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4 | 168,161,14,84,70,91,98,252,63,245,105,238,112,231,119,224,56,217,7,210,126,21,0,203,133,196,49,189,28,140,77,182,147,175,42,35,154,211,218,141,155,239,162,43,148,176,183,29,134,190,50,197,22,127,204,120,169,57,225,113,232,106,36,246,64,99,253,92,15,85,8,71,1,78,128,205,149,254,156,79,142,2,9,163,72,247,86,37,135,170,51,240,44,93,177,233,30,226,184,65,100,191,16,121,58,219,198,107,114,212,23,234,178,59,108,115,199,213,24,220,192,17,122,101,185,66,227,31,52,129,206,94,171,241,10,3,136,87,164,248,38,157,80,143,73,150,255,45,165,186,256,151,74,81,249,88,144,46,158,242,4,39,11,235,67,95,228,102,137,221,18,214,172,109,207,60,32,200,130,179,116,25,53,193,123,12,222,187,145,152,26,82,250,54,194,40,89,243,117,180,131,201,124,33,159,68,110,47,208,236,138,75,173,61,5,215,229,19,166,96,103,202,174,223,104,167,97,62,48,216,230,146,132,6,13,139,209,237,34,160,111,90,20,118,244,181,195,69,83,41,55,251,125,153,27,76,188
+1 82,125,3,24,28,101,44,29,125,98,54,121,94,85,8,50,51,111,59,78,68,73,28,127,53,62,1,9,118,67,12,85,44,67,74,90,68,29,127,12,4,24,63,61,105,43,63,119,100,60,82,40,65,117,54,13,7,116,86,60,38,72,63,9,1,53,63,117,4,8,83,64,102,58,43,74,93,93,31,93,48,60,75,67,70,19,123,27,72,72,84,98,46,111,45,58,75,86,59,119,97,50,4,118,55,20,10,15,89,101,37,38,86,78,81,8,2,92,16,69,117,11,67,95,117,45,69,22,34,97,119,28,25,52,102,63,2,52,16,16,77,20,77,48,86,108,30,36,2,61,86,32,10,126,52,88,64,117,40,128,50,18,53,40,112,50,125,37,122,13,52,70,90,74,41,78,4,1,73,25,79,12,110,32,102,106,14,86,11,117,105,29,72,29,51,12,32,2,64,6,120,61,3,46,95,97,39,9,30,19,78,81,43,72,14,123,87,69,53,30,20,50,57,117,21,90,54,76,60,31,91,121,45,74,46,119,31,32,2,94,20,81,39,50,35,26,46,96,23,54,99,0,46,82,109,62,120 | 251,26,177,64,238,148,197,116,136,2,202,68,102,176,40,199,56,14,115,69,63,27,207,152,106,121,188,195,39,181,30,169,55,214,186,107,139,138,118,161,209,85,240,105,141,220,224,127,248,41,3,132,179,245,87,22,131,4,193,7,191,37,146,219,208,236,229,78,151,196,237,183,128,244,147,110,167,111,60,206,242,158,163,51,174,74,45,212,6,32,94,125,232,234,246,92,252,203,143,80,101,165,221,160,15,243,194,16,170,137,154,133,162,24,65,218,54,249,226,10,104,222,73,95,18,98,81,59,228,49,43,149,201,25,255,62,135,46,42,66,198,156,71,52,33,83,122,29,20,36,119,126,217,171,84,88,192,61,89,213,178,21,233,34,75,173,82,96,227,142,140,175,210,113,19,180,241,114,211,0,253,50,70,90,13,31,144,187,58,150,112,97,216,155,108,35,172,225,230,117,79,77,76,12,239,123,204,247,100,129,205,91,9,250,48,109,5,72,134,184,44,190,185,145,254,182,17,93,164,57,120,53,67,223,189,124,157,28,103,99,235,47,130,200,256,231,11,168,215,86,166,1,8,153,23,38,159
+1 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256
+1 257,256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+1 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4 | 42,112,105,119,196,63,14,70,49,238,147,84,154,231,28,182,189,175,7,203,217,91,140,0,98,21,133,168,210,252,245,161,56,224,77,126,35,120,218,169,155,176,57,43,148,29,141,190,134,197,50,22,204,127,211,162,36,183,225,113,232,106,239,246,64,99,253,92,15,85,8,71,1,78,128,205,149,254,156,79,142,2,9,163,72,247,86,37,135,170,51,240,44,93,177,233,30,226,184,65,100,191,16,121,58,219,198,107,114,212,23,234,178,59,108,115,199,213,24,220,192,17,122,101,185,66,227,31,52,129,206,94,171,241,10,3,136,87,164,248,38,157,80,143,73,150,255,45,165,186,256,151,74,81,249,88,144,46,158,242,4,39,11,235,67,95,228,102,137,221,18,214,172,109,207,60,32,200,130,179,116,25,53,193,123,12,222,187,145,152,26,82,250,54,194,40,89,243,117,180,131,201,124,33,159,68,110,47,208,236,138,75,173,61,5,215,229,19,166,96,103,202,174,223,104,167,97,62,48,216,230,146,132,6,13,139,209,237,34,160,111,90,20,118,244,181,195,69,83,41,55,251,125,153,27,76,188
+2 54,27,83,73,111,22,36,85,31,3,97,80,94,48,95,37,3,110,100,13,59,81,23,79,73,31,62,115,60,36,81,62,91,19,1,2,52,7,64,117,116,124,23,62,85,84,34,77,12,29,2,63,71,115,121,128,39,10,80,78,2,48,100,78,0,33,120,9,128,98,22,46,78,87,109,109,30,11,91,51,4,57,16,17,24,31,92,77,90,78,85,1,109,75,95,7,59,103,39,84,108,8,10,100,7,100,108,109,36,17,10,47,32,124,98,48,48,20,82,84,69,108,94,83,112,110,124,43,60,66,47,87,118,97,76,13,56,38,118,77,49,67,45,125,113,49,76,103,82,23,108,2,22,89,10,70,105,84,117,81,59,98,106,112,104,122,71,67,80,8,102,16,45,67,15,118,33,106,77,63,25,117,92,97,4,74,126,25,43,122,96,36,57,94,32,24,54,91,91,81,98,53,5,118,79,26,12,22,74,80,32,124,23,48,44,113,37,54,88,118,8,16,22,62,94,81,64,99,15,63,59,21,127,72,78,123,40,117,25,90,84,103,64,39,4,22,33,35,127,97,127,69,5,76,74,105,104 | 129,84,255,128,4,251,6,246,243,9,240,239,237,13,235,234,16,233,231,229,228,21,227,225,217,213,206,199,28,29,30,196,195,192,191,190,186,181,179,39,176,174,172,170,159,45,158,157,48,156,150,51,142,131,1,0,56,121,120,59,119,61,116,63,64,65,66,67,115,108,106,100,72,73,99,98,76,93,89,79,88,81,3,25,82,85,253,5,80,78,90,91,92,250,249,95,248,97,75,74,71,7,102,103,104,105,70,107,245,244,110,8,242,113,241,10,62,238,118,12,236,57,122,15,124,232,126,127,18,54,19,53,132,133,134,135,226,23,138,224,140,141,222,221,219,145,146,147,148,218,24,216,152,211,154,155,207,204,46,44,203,27,162,163,198,197,32,167,193,33,34,171,188,173,41,175,187,177,36,38,180,37,184,183,220,143,178,40,42,189,35,43,169,52,194,166,31,165,164,161,200,201,202,160,47,205,26,49,208,209,210,153,212,83,214,215,151,50,149,144,185,182,168,223,139,137,136,22,20,130,230,55,125,17,123,14,58,60,117,11,68,114,112,111,109,69,101,247,96,94,77,87,252,86,254,2,256
+2 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256 | 87,255,252,3,249,246,6,243,240,9,237,234,12,231,228,15,225,222,18,219,216,21,213,210,24,207,204,27,201,198,30,195,192,33,189,186,36,183,180,39,177,174,42,171,168,45,165,162,48,159,156,51,153,150,54,147,144,57,141,138,60,135,132,63,129,0,66,126,123,69,120,117,72,114,111,75,108,105,78,102,99,81,96,93,84,90,127,172,88,256,85,91,1,253,94,250,82,97,4,247,100,244,79,103,7,241,106,238,76,109,10,235,112,232,73,115,13,229,118,226,70,121,16,223,124,220,67,19,217,64,130,214,22,133,211,61,136,208,25,139,205,58,142,202,28,145,199,55,148,196,31,151,193,52,154,190,34,157,187,49,160,184,37,163,181,46,166,178,40,169,175,43,131,215,41,170,176,44,167,179,38,164,182,47,161,185,35,158,188,50,155,191,32,152,194,53,149,197,29,146,200,56,143,203,26,20,206,59,137,209,23,134,212,62,173,86,140,128,218,65,125,221,17,68,224,122,119,227,14,71,230,116,113,233,11,74,236,110,107,239,8,77,242,104,101,245,5,80,248,98,95,251,2,83,254,92,89
+2 257,256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 86,254,2,251,248,5,245,242,8,239,236,11,233,230,14,227,224,17,221,218,20,215,212,23,209,206,26,203,200,29,197,194,32,191,188,35,185,182,38,179,176,41,173,170,44,167,164,47,161,158,50,155,152,53,149,146,56,143,140,59,137,134,62,131,128,65,125,122,68,119,116,71,113,110,74,107,104,77,101,98,80,95,92,83,89,127,22,256,88,1,253,91,82,250,94,4,247,97,79,244,100,7,241,103,76,238,106,10,235,109,73,232,112,13,229,115,70,226,118,16,223,121,67,220,124,19,217,214,64,85,130,211,208,133,61,25,136,205,202,139,58,28,142,199,196,145,55,31,148,193,190,151,52,34,154,187,184,157,49,37,160,181,178,163,46,40,166,175,172,169,43,213,108,42,174,45,165,177,162,39,21,48,159,183,156,36,186,51,153,189,150,33,192,171,147,195,144,30,198,57,141,201,138,27,204,60,135,207,132,24,210,63,129,54,168,180,216,126,66,219,123,18,222,120,69,225,117,15,228,114,72,231,111,12,234,0,75,237,105,9,240,102,78,243,99,6,246,96,81,249,93,3,252,90,84,255,87
+2 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4 | 111,255,252,3,251,248,6,7,245,244,10,241,238,13,14,237,234,17,231,230,20,21,227,224,24,223,220,27,28,217,216,31,213,210,34,35,209,206,38,203,202,41,42,199,196,45,195,192,48,49,189,188,52,185,182,55,56,181,178,59,175,174,62,63,171,168,66,167,164,69,70,161,160,73,157,154,76,77,153,150,80,147,146,83,84,143,140,87,139,136,90,91,133,132,94,129,0,97,98,126,125,101,122,119,104,105,118,115,108,112,127,81,109,113,256,1,116,253,106,4,120,249,102,123,246,8,99,242,11,95,130,239,15,92,134,235,232,137,18,88,228,141,22,85,144,225,25,53,148,221,218,151,29,78,214,155,32,74,158,211,36,71,162,207,204,165,39,67,200,169,43,64,172,197,46,60,176,193,190,179,50,57,186,183,54,184,110,187,51,180,58,191,47,177,194,61,44,173,198,170,65,201,40,166,68,205,37,163,208,72,33,159,212,156,75,215,30,152,79,219,26,149,222,82,23,145,226,142,86,229,19,138,89,233,16,135,236,93,12,131,240,128,96,243,9,100,124,247,5,121,250,103,2,117,254,107,114
+3 18,72,21,126,57,32,93,57,0,73,124,64,90,30,1,67,121,17,65,123,63,110,29,24,34,120,102,89,66,116,8,97,99,51,101,113,48,52,60,99,62,95,103,118,36,118,47,116,128,58,104,65,73,113,79,37,122,2,41,87,82,11,3,115,11,114,107,109,120,98,74,32,61,19,96,114,16,93,38,28,125,42,122,85,43,105,6,25,120,32,25,33,64,94,80,54,21,86,118,54,53,19,54,2,83,44,34,2,30,127,78,58,8,34,112,105,107,62,65,101,16,89,46,122,114,61,69,121,115,63,119,47,61,16,107,10,123,84,0,18,95,74,48,117,93,3,27,4,2,96,64,99,116,68,54,4,58,68,90,60,94,46,76,58,9,126,37,37,89,45,103,101,61,3,40,28,127,31,125,98,123,65,6,23,41,54,76,61,95,13,102,41,24,67,119,59,14,44,105,99,11,27,90,55,81,79,38,118,65,89,116,33,123,71,94,19,64,33,42,51,94,60,102,4,103,106,77,97,78,43,88,0,53,124,109,67,56,95,2,93,2,83,118,49,48,65,48,73,87,8,58,34,32,38,43,6,116 | 51,1,106,256,111,251,6,96,116,91,121,11,126,241,86,236,16,131,81,231,136,21,141,226,76,221,26,146,71,216,151,31,246,211,156,206,36,66,181,201,161,41,61,196,191,166,46,171,186,56,101,176,242,97,62,237,22,212,102,182,202,122,17,227,207,12,2,142,217,72,177,197,147,152,57,137,157,132,232,67,127,167,222,32,82,172,52,7,27,247,87,47,252,187,112,107,37,162,42,92,117,77,192,180,104,254,4,99,249,109,9,244,239,14,114,234,94,19,229,119,224,24,89,219,124,29,214,209,34,129,204,84,39,199,134,194,44,79,189,139,184,49,179,54,144,174,74,169,59,149,164,64,69,159,154,205,100,155,190,60,145,230,255,220,200,5,110,55,50,150,210,70,235,215,140,120,75,30,195,240,45,245,10,185,250,25,165,20,170,40,95,15,125,135,130,0,35,115,65,85,225,90,80,160,105,175,103,93,208,203,38,33,83,213,88,133,198,28,218,123,43,193,138,223,188,48,23,183,228,118,78,128,18,233,68,178,53,113,238,143,173,13,58,243,98,73,168,8,248,108,148,163,63,253,153,158,3
+3 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256 | 51,1,106,256,111,251,6,96,116,91,121,11,126,241,86,236,16,131,81,231,136,21,141,226,76,221,26,146,71,216,151,31,246,211,156,206,36,66,181,201,161,41,61,196,191,166,46,171,186,56,101,176,242,97,62,237,22,212,102,182,202,122,17,227,207,12,2,142,217,72,177,197,147,152,57,137,157,132,232,67,127,167,222,32,82,172,52,7,27,247,87,47,252,187,112,107,37,162,42,92,117,77,192,180,104,254,4,99,249,109,9,244,239,14,114,234,94,19,229,119,224,24,89,219,124,29,214,209,34,129,204,84,39,199,134,194,44,79,189,139,184,49,179,54,144,174,74,169,59,149,164,64,69,159,154,205,100,155,190,60,145,230,255,220,200,5,110,55,50,150,210,70,235,215,140,120,75,30,195,240,45,245,10,185,250,25,165,20,170,40,95,15,125,135,130,0,35,115,65,85,225,90,80,160,105,175,103,93,208,203,38,33,83,213,88,133,198,28,218,123,43,193,138,223,188,48,23,183,228,118,78,128,18,233,68,178,53,113,238,143,173,13,58,243,98,73,168,8,248,108,148,163,63,253,153,158,3
+3 257,256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 | 51,1,106,256,111,251,6,96,116,91,121,11,126,241,86,236,16,131,81,231,136,21,141,226,76,221,26,146,71,216,151,31,246,211,156,206,36,66,181,201,161,41,61,196,191,166,46,171,186,56,101,176,242,97,62,237,22,212,102,182,202,122,17,227,207,12,2,142,217,72,177,197,147,152,57,137,157,132,232,67,127,167,222,32,82,172,52,7,27,247,87,47,252,187,112,107,37,162,42,92,117,77,192,180,104,254,4,99,249,109,9,244,239,14,114,234,94,19,229,119,224,24,89,219,124,29,214,209,34,129,204,84,39,199,134,194,44,79,189,139,184,49,179,54,144,174,74,169,59,149,164,64,69,159,154,205,100,155,190,60,145,230,255,220,200,5,110,55,50,150,210,70,235,215,140,120,75,30,195,240,45,245,10,185,250,25,165,20,170,40,95,15,125,135,130,0,35,115,65,85,225,90,80,160,105,175,103,93,208,203,38,33,83,213,88,133,198,28,218,123,43,193,138,223,188,48,23,183,228,118,78,128,18,233,68,178,53,113,238,143,173,13,58,243,98,73,168,8,248,108,148,163,63,253,153,158,3
+3 0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3,4 | 51,1,106,256,111,251,6,96,116,91,121,11,126,241,86,236,16,131,81,231,136,21,141,226,76,221,26,146,71,216,151,31,246,211,156,206,36,66,181,201,161,41,61,196,191,166,46,171,186,56,101,176,242,97,62,237,22,212,102,182,202,122,17,227,207,12,2,142,217,72,177,197,147,152,57,137,157,132,232,67,127,167,222,32,82,172,52,7,27,247,87,47,252,187,112,107,37,162,42,92,117,77,192,180,104,254,4,99,249,109,9,244,239,14,114,234,94,19,229,119,224,24,89,219,124,29,214,209,34,129,204,84,39,199,134,194,44,79,189,139,184,49,179,54,144,174,74,169,59,149,164,64,69,159,154,205,100,155,190,60,145,230,255,220,200,5,110,55,50,150,210,70,235,215,140,120,75,30,195,240,45,245,10,185,250,25,165,20,170,40,95,15,125,135,130,0,35,115,65,85,225,90,80,160,105,175,103,93,208,203,38,33,83,213,88,133,198,28,218,123,43,193,138,223,188,48,23,183,228,118,78,128,18,233,68,178,53,113,238,143,173,13,58,243,98,73,168,8,248,108,148,163,63,253,153,158,3

src/promql/src/grid_series.rs

@@ -0,0 +1,340 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Building evaluated series that cover only their result range on a shared grid.
+
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+use std::sync::Arc;
+
+use datafusion::arrow::array::builder::NullBufferBuilder;
+use datafusion::arrow::array::{Float64Array, UInt32Array};
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::histogram::HistogramBatchBuilder;
+use datatypes::series::samples::{
+    HistogramSamples, SampleRef, Samples, Series, SeriesFields, SeriesSchema,
+};
+use datatypes::series::time::{EvalGrid, GridRange, TimeAxis};
+
+use crate::histogram_eval::float_histogram::FloatHistogram;
+
+#[cfg(test)]
+pub(crate) mod reference;
+#[cfg(test)]
+mod tests;
+
+/// Builds one series on the schema's evaluation grid from rows pushed at absolute grid indices.
+///
+/// The output starts at the first row with a valid value in any field and ends at the last such
+/// row, so a short-lived series never holds values for the whole grid. Missing rows between
+/// valid ones become nulls; NaN is a valid value.
+pub struct GridSeriesBuilder {
+    schema: Arc<SeriesSchema>,
+    grid: Arc<EvalGrid>,
+    /// Absolute index of the first valid row.
+    start: Option<usize>,
+    /// Smallest index the next push may use.
+    next: usize,
+    /// Index after the last valid row; rows from here to the next valid row are pending nulls.
+    valid_end: usize,
+    fields: Vec<FieldBuilder>,
+}
+
+struct FieldBuilder {
+    values: Vec<f64>,
+    nulls: NullBufferBuilder,
+    /// Created at the first histogram value; holds an index per row from then on.
+    histograms: Option<HistogramColumn>,
+}
+
+struct HistogramColumn {
+    batch: HistogramBatchBuilder,
+    indices: Vec<Option<u32>>,
+}
+
+/// A value of [`GridSeriesBuilder::push_samples`].
+pub(crate) enum GridSample {
+    Float(f64),
+    Histogram(FloatHistogram),
+}
+
+impl GridSeriesBuilder {
+    /// Creates a builder for series of `schema`, which must have an evaluation grid.
+    pub fn try_new(schema: Arc<SeriesSchema>) -> Result<Self> {
+        let grid = schema.eval_grid.clone().ok_or_else(|| {
+            DataFusionError::Execution("grid series schema requires an evaluation grid".into())
+        })?;
+        Ok(Self {
+            schema,
+            grid,
+            start: None,
+            next: 0,
+            valid_end: 0,
+            fields: Vec::new(),
+        })
+    }
+
+    /// Pushes the field values at absolute grid `index`; `None` is a missing value.
+    ///
+    /// Indices must be strictly increasing; skipped indices are missing rows.
+    pub fn push(&mut self, index: usize, values: &[Option<f64>]) -> Result<()> {
+        if !self.start_row(index, values.len(), values.iter().all(Option::is_none))? {
+            return Ok(());
+        }
+        for (field, value) in self.fields.iter_mut().zip(values) {
+            field.push_float(*value);
+        }
+        Ok(())
+    }
+
+    /// Like [`GridSeriesBuilder::push`], with native histogram values.
+    pub(crate) fn push_samples(
+        &mut self,
+        index: usize,
+        values: &[Option<GridSample>],
+    ) -> Result<()> {
+        if !self.start_row(index, values.len(), values.iter().all(Option::is_none))? {
+            return Ok(());
+        }
+        for (field, value) in self.fields.iter_mut().zip(values) {
+            match value {
+                Some(GridSample::Histogram(h)) => {
+                    field.values.push(0.0);
+                    field.nulls.append(false);
+                    let rows = field.values.len() - 1;
+                    let column = field.histograms.get_or_insert_with(|| HistogramColumn {
+                        batch: HistogramBatchBuilder::new(),
+                        indices: vec![None; rows],
+                    });
+                    column.indices.push(Some(h.push_to(&mut column.batch)?));
+                }
+                Some(GridSample::Float(value)) => field.push_float(Some(*value)),
+                None => field.push_float(None),
+            }
+        }
+        Ok(())
+    }
+
+    /// Checks the row and pads the gap before it; returns whether the row has a value to write.
+    fn start_row(&mut self, index: usize, len: usize, empty: bool) -> Result<bool> {
+        if len != self.schema.fields.len() {
+            return Err(DataFusionError::Execution(format!(
+                "grid series row has {len} fields, schema has {}",
+                self.schema.fields.len()
+            )));
+        }
+        if index < self.next || index >= self.grid.timestamps().len() {
+            return Err(DataFusionError::Execution(format!(
+                "grid series index {index} is not increasing or exceeds grid length {}",
+                self.grid.timestamps().len()
+            )));
+        }
+        self.next = index + 1;
+        if empty {
+            return Ok(false);
+        }
+
+        if self.start.is_none() {
+            self.start = Some(index);
+            self.fields = (0..len)
+                .map(|_| FieldBuilder {
+                    values: Vec::new(),
+                    nulls: NullBufferBuilder::new(0),
+                    histograms: None,
+                })
+                .collect();
+        } else {
+            let gap = index - self.valid_end;
+            for field in &mut self.fields {
+                field.values.resize(field.values.len() + gap, 0.0);
+                field.nulls.append_n_nulls(gap);
+                if let Some(column) = &mut field.histograms {
+                    column.indices.resize(column.indices.len() + gap, None);
+                }
+            }
+        }
+        self.valid_end = index + 1;
+        Ok(true)
+    }
+
+    /// Finishes the current series and resets the builder for the next one.
+    ///
+    /// Returns `None` when no pushed row had a valid value.
+    pub fn finish(&mut self, metric: MetricName) -> Result<Option<Series>> {
+        let start = self.start.take();
+        let fields = std::mem::take(&mut self.fields);
+        let valid_end = std::mem::take(&mut self.valid_end);
+        self.next = 0;
+        let Some(start) = start else {
+            return Ok(None);
+        };
+
+        let samples = fields
+            .into_iter()
+            .map(|mut field| {
+                let floats = Float64Array::new(field.values.into(), field.nulls.finish());
+                let Some(column) = field.histograms else {
+                    return Ok(Samples::from_float(floats));
+                };
+                let batch = column.batch.finish().map_err(external)?;
+                let histograms =
+                    HistogramSamples::try_new(UInt32Array::from(column.indices), batch)
+                        .map_err(external)?;
+                Samples::try_from_mixed(floats, histograms).map_err(external)
+            })
+            .collect::<Result<Vec<_>>>()?;
+        let time =
+            GridRange::try_new(self.grid.clone(), start, valid_end - start).map_err(external)?;
+        let fields = SeriesFields::try_from_vec(samples).map_err(external)?;
+        Series::try_new(&self.schema, metric, TimeAxis::Grid(time), fields)
+            .map(Some)
+            .map_err(external)
+    }
+}
+
+impl FieldBuilder {
+    fn push_float(&mut self, value: Option<f64>) {
+        self.values.push(value.unwrap_or_default());
+        self.nulls.append(value.is_some());
+        if let Some(column) = &mut self.histograms {
+            column.indices.push(None);
+        }
+    }
+}
+
+/// Prometheus `schema.IsMetadataLabel`: the labels removed with the metric name.
+pub(crate) const METADATA_LABELS: [&str; 3] = ["__name__", "__type__", "__unit__"];
+
+pub(crate) type LabelSet = Vec<(Arc<str>, Arc<str>)>;
+
+/// The label set Prometheus compares, which has no empty values.
+pub(crate) fn label_set(metric: &MetricName) -> LabelSet {
+    let name = metric
+        .name()
+        .filter(|name| !name.is_empty())
+        .map(|name| (Arc::from("__name__"), Arc::from(name)));
+    name.into_iter()
+        .chain(
+            metric
+                .tags()
+                .iter()
+                .filter(|tag| !tag.value.is_empty())
+                .map(|tag| (tag.name.clone(), tag.value.clone())),
+        )
+        .collect()
+}
+
+/// Merges series that share a label set into one, as Prometheus does after a function that
+/// rewrites labels or drops `__name__`; two of them holding one field at one point fail.
+pub fn merge_same_labelset(schema: &Arc<SeriesSchema>, series: Vec<Series>) -> Result<Vec<Series>> {
+    let mut groups: HashMap<LabelSet, Vec<usize>> = HashMap::with_capacity(series.len());
+    let mut collided = false;
+    for (index, series) in series.iter().enumerate() {
+        match groups.entry(label_set(&series.metric)) {
+            Entry::Occupied(mut entry) => {
+                entry.get_mut().push(index);
+                collided = true;
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(vec![index]);
+            }
+        }
+    }
+    if !collided {
+        return Ok(series);
+    }
+
+    let mut series: Vec<Option<Series>> = series.into_iter().map(Some).collect();
+    let mut output = Vec::with_capacity(groups.len());
+    let mut builder = GridSeriesBuilder::try_new(schema.clone())?;
+    let mut rows = Vec::new();
+    let mut values = vec![None; schema.fields.len()];
+    let mut merged = vec![None; schema.fields.len()];
+    for (labels, members) in groups {
+        if let [member] = members[..] {
+            output.extend(series[member].take());
+            continue;
+        }
+        rows.clear();
+        for &member in &members {
+            let member_series = series[member]
+                .as_ref()
+                .expect("each series is in one group");
+            let TimeAxis::Grid(range) = &member_series.time else {
+                return Err(DataFusionError::Execution(
+                    "merging requires evaluated series".into(),
+                ));
+            };
+            for row in 0..range.len() {
+                if read_row(member_series, row, &mut values)? {
+                    rows.push((range.start() + row, member, row));
+                }
+            }
+        }
+        rows.sort_unstable_by_key(|&(point, _, _)| point);
+        let mut start = 0;
+        while start < rows.len() {
+            let point = rows[start].0;
+            let end = start + rows[start..].partition_point(|&(p, _, _)| p == point);
+            // Rows of one point merge field by field; only a field present twice collides.
+            merged.iter_mut().for_each(|value| *value = None);
+            for &(_, member, row) in &rows[start..end] {
+                read_row(series[member].as_ref().unwrap(), row, &mut values)?;
+                for (slot, value) in merged.iter_mut().zip(&values) {
+                    if value.is_some() {
+                        if slot.is_some() {
+                            let labels: Vec<_> = labels
+                                .iter()
+                                .map(|(name, value)| format!("{name}=\"{value}\""))
+                                .collect();
+                            return Err(DataFusionError::Execution(format!(
+                                "vector cannot contain metrics with the same labelset {{{}}}",
+                                labels.join(", ")
+                            )));
+                        }
+                        *slot = *value;
+                    }
+                }
+            }
+            builder.push(point, &merged)?;
+            start = end;
+        }
+        let metric = series[members[0]].as_ref().unwrap().metric.clone();
+        output.extend(builder.finish(metric)?);
+    }
+    Ok(output)
+}
+
+/// Reads the float fields of `row`; returns whether any is present.
+fn read_row(series: &Series, row: usize, values: &mut [Option<f64>]) -> Result<bool> {
+    let mut present = false;
+    for (value, samples) in values.iter_mut().zip(series.fields.iter()) {
+        *value = match samples.sample(row) {
+            SampleRef::Missing => None,
+            SampleRef::Float(value) => Some(value),
+            SampleRef::Histogram(_) => {
+                return Err(DataFusionError::NotImplemented(
+                    "merging histogram series with the same label set".into(),
+                ));
+            }
+        };
+        present |= value.is_some();
+    }
+    Ok(present)
+}
+
+pub(crate) fn external(error: datatypes::error::Error) -> DataFusionError {
+    DataFusionError::External(Box::new(error))
+}

src/promql/src/grid_series/reference.rs

@@ -0,0 +1,477 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Brute-force reference for operators producing grid series: results are compared as dense
+//! `[grid index][field]` matrices, so a kernel cannot pass by aligning local row numbers.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use datafusion::arrow::array::{Float64Array, UInt32Array};
+use datatypes::series::histogram::{
+    BucketSideView, CounterResetHint, HistogramBatchBuilder, HistogramView,
+};
+use datatypes::series::samples::{
+    HistogramSamples, SampleRef, Samples, Series, SeriesFields, SeriesSchema,
+};
+use datatypes::series::time::{EvalGrid, GridRange, GridSpec, TimeAxis};
+use datatypes::series::{Label, MetricName};
+use rand::Rng;
+
+use crate::grid_series::GridSeriesBuilder;
+use crate::histogram_eval::float_histogram::FloatHistogram;
+
+/// Values by absolute grid index, then by field; `None` is missing.
+pub(crate) type Dense = Vec<Vec<Option<f64>>>;
+
+/// Expands a grid series to a dense matrix over its whole grid.
+fn expand(series: &Series) -> Dense {
+    let TimeAxis::Grid(range) = &series.time else {
+        panic!("expected a grid series, got {:?}", series.time);
+    };
+    let fields = series.fields.as_slice();
+    let mut dense = vec![vec![None; fields.len()]; range.grid().timestamps().len()];
+    for (field_index, field) in fields.iter().enumerate() {
+        for (row, sample) in field.iter().enumerate() {
+            dense[range.start() + row][field_index] = match sample {
+                SampleRef::Missing => None,
+                SampleRef::Float(value) => Some(value),
+                SampleRef::Histogram(_) => panic!("unexpected histogram sample"),
+            };
+        }
+    }
+    dense
+}
+
+/// Asserts `actual` is the trimmed form of `expected`, with identical value bits and metric.
+pub(crate) fn assert_series_eq(actual: Option<&Series>, expected: &Dense, metric: &MetricName) {
+    assert_series_matches(actual, expected, metric, f64::to_bits, "");
+}
+
+/// Like [`assert_series_eq`], but any NaN equals any NaN: Prometheus' NaN payloads depend on how
+/// the Go compiler orders commutative operands, and every NaN is serialized as `NaN`.
+/// `context` names the case in failure messages.
+pub(crate) fn assert_series_eq_any_nan(
+    actual: Option<&Series>,
+    expected: &Dense,
+    metric: &MetricName,
+    context: &str,
+) {
+    let any_nan = |value: f64| {
+        if value.is_nan() {
+            f64::NAN.to_bits()
+        } else {
+            value.to_bits()
+        }
+    };
+    assert_series_matches(actual, expected, metric, any_nan, context);
+}
+
+fn assert_series_matches(
+    actual: Option<&Series>,
+    expected: &Dense,
+    metric: &MetricName,
+    bits_of: fn(f64) -> u64,
+    context: &str,
+) {
+    let valid_rows = || {
+        expected
+            .iter()
+            .enumerate()
+            .filter(|(_, row)| row.iter().any(Option::is_some))
+            .map(|(index, _)| index)
+    };
+    let Some((first, last)) = valid_rows().next().zip(valid_rows().next_back()) else {
+        assert!(
+            actual.is_none(),
+            "{context}: expected no series, got {actual:?}"
+        );
+        return;
+    };
+    let actual =
+        actual.unwrap_or_else(|| panic!("{context}: expected a series over [{first}, {last}]"));
+    let TimeAxis::Grid(range) = &actual.time else {
+        panic!("expected a grid series, got {:?}", actual.time);
+    };
+    assert_eq!(
+        (range.start(), range.len()),
+        (first, last + 1 - first),
+        "{context}: grid range is not trimmed to the valid rows"
+    );
+    assert_eq!(range.grid().timestamps().len(), expected.len());
+    assert_eq!(&actual.metric, metric);
+    let bits = |dense: &Dense| -> Vec<Vec<Option<u64>>> {
+        dense
+            .iter()
+            .map(|row| row.iter().map(|value| value.map(bits_of)).collect())
+            .collect()
+    };
+    assert_eq!(bits(&expand(actual)), bits(expected), "{context}");
+}
+
+/// Values covering the bit patterns kernels most often mishandle.
+pub(crate) fn special_value(rng: &mut impl Rng) -> f64 {
+    const SPECIAL: [f64; 7] = [
+        0.0,
+        -0.0,
+        f64::NAN,
+        f64::INFINITY,
+        f64::NEG_INFINITY,
+        f64::MAX,
+        f64::MIN_POSITIVE,
+    ];
+    if rng.random_bool(0.2) {
+        SPECIAL[rng.random_range(0..SPECIAL.len())]
+    } else {
+        rng.random_range(-1e6..1e6)
+    }
+}
+
+/// A dense matrix with a random start, length and holes, all other rows missing.
+pub(crate) fn random_dense(rng: &mut impl Rng, grid_len: usize, fields: usize) -> Dense {
+    let mut dense = vec![vec![None; fields]; grid_len];
+    let start = rng.random_range(0..grid_len);
+    let end = rng.random_range(start..=grid_len);
+    let missing = rng.random_range(0.0..0.8);
+    for row in &mut dense[start..end] {
+        for value in row.iter_mut() {
+            if !rng.random_bool(missing) {
+                *value = Some(special_value(rng));
+            }
+        }
+    }
+    dense
+}
+
+/// Labels with `__name__` as an ordinary entry, the way Prometheus holds them.
+pub(crate) type Labels = BTreeMap<String, String>;
+
+/// Value bits by grid index.
+pub(crate) type Points = BTreeMap<usize, u64>;
+
+/// A case of a fixture written by a promql-compat `narthex-golden-*` command.
+pub(crate) struct GoldenCase {
+    /// The operation and its tab-separated arguments.
+    pub(crate) spec: Vec<String>,
+    pub(crate) grid: Arc<EvalGrid>,
+    pub(crate) inputs: Vec<(Labels, Points)>,
+    /// Native histogram points of each input, as written by the generator.
+    pub(crate) histograms: Vec<BTreeMap<usize, String>>,
+    /// Result series by label set, or the error message.
+    pub(crate) outcome: Result<BTreeMap<Labels, Points>, String>,
+    /// Native histogram points of the result series, as written by the generator.
+    pub(crate) result_histograms: BTreeMap<Labels, BTreeMap<usize, String>>,
+}
+
+/// Parses a fixture whose label pairs are separated by `|`.
+pub(crate) fn golden_cases(text: &str) -> Vec<GoldenCase> {
+    let labels = |text: &str| -> Labels {
+        text.split('|')
+            .filter(|pair| *pair != "-")
+            .map(|pair| {
+                let (name, value) = pair.split_once('=').unwrap();
+                (name.to_string(), value.to_string())
+            })
+            .collect()
+    };
+    let points = |text: &str| -> (Points, BTreeMap<usize, String>) {
+        let mut floats = Points::new();
+        let mut histograms = BTreeMap::new();
+        for point in text.split_whitespace() {
+            let (index, value) = point.split_once(':').unwrap();
+            let index = index.parse().unwrap();
+            if let Some(histogram) = value.strip_prefix('H') {
+                histograms.insert(index, histogram.to_string());
+            } else {
+                floats.insert(index, u64::from_str_radix(value, 16).unwrap());
+            }
+        }
+        (floats, histograms)
+    };
+    let mut cases = Vec::new();
+    for case in text.split("end\n").filter(|case| case.contains("case ")) {
+        let lines: Vec<&str> = case.lines().filter(|line| !line.starts_with('#')).collect();
+        let spec = lines[0].strip_prefix("case ").unwrap();
+        let grid: Vec<i64> = lines[1]
+            .split_whitespace()
+            .skip(1)
+            .map(|value| value.parse().unwrap())
+            .collect();
+        let grid = GridSpec::try_new(grid[0], grid[1], grid[2] as u64).unwrap();
+        let mut inputs = Vec::new();
+        let mut histograms = Vec::new();
+        let mut result_histograms = BTreeMap::new();
+        let mut outcome = Ok(BTreeMap::new());
+        for line in &lines[2..] {
+            if let Some(message) = line.strip_prefix("error ") {
+                outcome = Err(message.to_string());
+                continue;
+            }
+            let (kind, rest) = line.split_once(' ').unwrap();
+            let (series_labels, series_points) = rest.split_once(" ;").unwrap();
+            let (floats, histogram_points) = points(series_points);
+            let entry = (labels(series_labels), floats);
+            match kind {
+                "series" => {
+                    inputs.push(entry);
+                    histograms.push(histogram_points);
+                }
+                "result" => {
+                    if !histogram_points.is_empty() {
+                        result_histograms.insert(entry.0.clone(), histogram_points);
+                    }
+                    outcome.as_mut().unwrap().insert(entry.0, entry.1);
+                }
+                other => panic!("unexpected line {other}"),
+            }
+        }
+        cases.push(GoldenCase {
+            spec: spec.split('\t').map(str::to_string).collect(),
+            grid: Arc::new(EvalGrid::try_new(grid).unwrap()),
+            inputs,
+            histograms,
+            outcome,
+            result_histograms,
+        });
+    }
+    cases
+}
+
+pub(crate) fn metric_of(labels: &Labels) -> MetricName {
+    let mut labels = labels.clone();
+    let name = labels.remove("__name__").map(Arc::from);
+    MetricName::try_new(
+        name,
+        labels
+            .into_iter()
+            .map(|(name, value)| Label {
+                name: Arc::from(name),
+                value: Arc::from(value),
+            })
+            .collect(),
+    )
+    .unwrap()
+}
+
+pub(crate) fn labels_of(metric: &MetricName) -> Labels {
+    let mut labels: Labels = metric
+        .tags()
+        .iter()
+        .map(|tag| (tag.name.to_string(), tag.value.to_string()))
+        .collect();
+    if let Some(name) = metric.name() {
+        labels.insert("__name__".to_string(), name.to_string());
+    }
+    labels
+}
+
+/// A single-field series of `schema` holding `points`; `None` without points.
+pub(crate) fn series_of(
+    schema: &Arc<SeriesSchema>,
+    labels: &Labels,
+    points: &Points,
+) -> Option<Series> {
+    let mut builder = GridSeriesBuilder::try_new(schema.clone()).unwrap();
+    for (&index, &bits) in points {
+        builder.push(index, &[Some(f64::from_bits(bits))]).unwrap();
+    }
+    builder.finish(metric_of(labels)).unwrap()
+}
+
+/// The points of a single-field series, any NaN as one NaN: Prometheus' NaN payloads depend on
+/// how the Go compiler orders operands.
+pub(crate) fn points_of(series: &Series) -> Points {
+    let TimeAxis::Grid(range) = &series.time else {
+        panic!("expected a grid series");
+    };
+    series.fields.as_slice()[0]
+        .iter()
+        .enumerate()
+        .filter_map(|(row, sample)| match sample {
+            SampleRef::Float(value) => Some((range.start() + row, canonical_bits(value))),
+            _ => None,
+        })
+        .collect()
+}
+
+pub(crate) fn canonical_bits(value: f64) -> u64 {
+    if value.is_nan() {
+        f64::NAN.to_bits()
+    } else {
+        value.to_bits()
+    }
+}
+
+/// Prometheus `almost.Equal`, treating results below 1e-10 as equal and any NaN as equal to NaN,
+/// as promql-compat compares engines.
+pub(crate) fn close(a: f64, b: f64, epsilon: f64) -> bool {
+    if a.is_nan() || b.is_nan() {
+        return a.is_nan() && b.is_nan();
+    }
+    if a == b {
+        return true;
+    }
+    let (diff, sum) = ((a - b).abs(), a.abs() + b.abs());
+    let equal = if a == 0.0 || b == 0.0 || sum < f64::MIN_POSITIVE {
+        diff < epsilon * f64::MIN_POSITIVE
+    } else {
+        diff / sum.min(f64::MAX) < epsilon
+    };
+    equal || (a.abs() < 1e-10 && b.abs() < 1e-10)
+}
+
+/// A native histogram written by the generator as `/`-separated fields.
+pub(crate) struct OwnedHistogram {
+    schema: i32,
+    zero_threshold: f64,
+    zero_count: f64,
+    count: f64,
+    sum: f64,
+    reset_hint: i32,
+    positive: (Vec<i32>, Vec<i32>, Vec<f64>),
+    negative: (Vec<i32>, Vec<i32>, Vec<f64>),
+    custom_values: Vec<f64>,
+}
+
+impl OwnedHistogram {
+    pub(crate) fn parse(text: &str) -> Self {
+        let fields: Vec<&str> = text.split('/').collect();
+        let float = |text: &str| f64::from_bits(u64::from_str_radix(text, 16).unwrap());
+        let floats = |text: &str| -> Vec<f64> {
+            text.split(',')
+                .filter(|v| !v.is_empty())
+                .map(float)
+                .collect()
+        };
+        let spans = |text: &str| -> (Vec<i32>, Vec<i32>) {
+            text.split(',')
+                .filter(|v| !v.is_empty())
+                .map(|span| {
+                    let (offset, length) = span.split_once('_').unwrap();
+                    (
+                        offset.parse::<i32>().unwrap(),
+                        length.parse::<i32>().unwrap(),
+                    )
+                })
+                .unzip()
+        };
+        let (positive_offsets, positive_lengths) = spans(fields[6]);
+        let (negative_offsets, negative_lengths) = spans(fields[8]);
+        Self {
+            schema: fields[0].parse().unwrap(),
+            zero_threshold: float(fields[1]),
+            zero_count: float(fields[2]),
+            count: float(fields[3]),
+            sum: float(fields[4]),
+            reset_hint: fields[5].parse().unwrap(),
+            positive: (positive_offsets, positive_lengths, floats(fields[7])),
+            negative: (negative_offsets, negative_lengths, floats(fields[9])),
+            custom_values: floats(fields[10]),
+        }
+    }
+
+    pub(crate) fn view(&self) -> HistogramView<'_> {
+        fn side(
+            (offsets, lengths, buckets): &(Vec<i32>, Vec<i32>, Vec<f64>),
+        ) -> BucketSideView<'_> {
+            BucketSideView {
+                span_offsets: offsets,
+                span_lengths: lengths,
+                buckets,
+            }
+        }
+        HistogramView {
+            schema: self.schema,
+            zero_threshold: self.zero_threshold,
+            sum: self.sum,
+            count: self.count,
+            zero_count: self.zero_count,
+            reset_hint: CounterResetHint::from(self.reset_hint),
+            start_timestamp: None,
+            custom_values: &self.custom_values,
+            positive: side(&self.positive),
+            negative: side(&self.negative),
+        }
+    }
+}
+
+/// A single-field series holding float and native histogram points.
+pub(crate) fn mixed_series(
+    schema: &Arc<SeriesSchema>,
+    labels: &Labels,
+    floats: &Points,
+    histograms: &BTreeMap<usize, String>,
+) -> Option<Series> {
+    let points = floats.keys().chain(histograms.keys());
+    let start = *points.clone().min()?;
+    let end = *points.max()? + 1;
+    let float_values: Float64Array = (start..end)
+        .map(|point| floats.get(&point).map(|bits| f64::from_bits(*bits)))
+        .collect();
+    let samples = if histograms.is_empty() {
+        Samples::from_float(float_values)
+    } else {
+        let mut builder = HistogramBatchBuilder::new();
+        let indices: Vec<_> = (start..end)
+            .map(|point| {
+                let text = histograms.get(&point)?;
+                Some(builder.push(OwnedHistogram::parse(text).view()).unwrap())
+            })
+            .collect();
+        let histograms =
+            HistogramSamples::try_new(UInt32Array::from(indices), builder.finish().unwrap())
+                .unwrap();
+        Samples::try_from_mixed(float_values, histograms).unwrap()
+    };
+    let range = GridRange::try_new(schema.eval_grid.clone().unwrap(), start, end - start).unwrap();
+    Some(
+        Series::try_new(
+            schema,
+            metric_of(labels),
+            TimeAxis::Grid(range),
+            SeriesFields::one(samples),
+        )
+        .unwrap(),
+    )
+}
+
+/// Asserts `got` equals `want` with values within `epsilon`, bucket by bucket.
+pub(crate) fn assert_histogram_close(
+    got: &FloatHistogram,
+    want: &FloatHistogram,
+    epsilon: f64,
+    context: &str,
+) {
+    let scalars = |h: &FloatHistogram| [h.zero_count, h.count, h.sum];
+    let ok = got.schema == want.schema
+        && got.reset_hint == want.reset_hint
+        && got.zero_threshold.to_bits() == want.zero_threshold.to_bits()
+        && got.custom_values == want.custom_values
+        && scalars(got)
+            .iter()
+            .zip(scalars(want))
+            .all(|(a, b)| close(*a, b, epsilon))
+        && [
+            (&got.positive, &want.positive),
+            (&got.negative, &want.negative),
+        ]
+        .iter()
+        .all(|(a, b)| {
+            a.len() == b.len()
+                && a.iter()
+                    .zip(b.iter())
+                    .all(|((i, x), (j, y))| i == j && close(*x, *y, epsilon))
+        });
+    assert!(ok, "{context}: {got:?} vs {want:?}");
+}

src/promql/src/grid_series/tests.rs

@@ -0,0 +1,144 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::Arc;
+
+use datatypes::series::samples::{FieldSpec, SeriesSchema};
+use datatypes::series::time::{EvalGrid, GridSpec};
+use datatypes::series::{Label, MetricName};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+
+use super::reference::{Labels, Points, assert_series_eq, points_of, random_dense, series_of};
+use super::{GridSeriesBuilder, merge_same_labelset};
+
+fn grid_schema(fields: usize, grid_len: u64) -> Arc<SeriesSchema> {
+    Arc::new(SeriesSchema {
+        fields: (0..fields)
+            .map(|index| FieldSpec {
+                name: Arc::from(format!("f{index}")),
+            })
+            .collect::<Vec<_>>()
+            .into(),
+        eval_grid: Some(Arc::new(
+            EvalGrid::try_new(GridSpec::try_new(-5_000, 1_000, grid_len).unwrap()).unwrap(),
+        )),
+    })
+}
+
+fn metric(host: usize) -> MetricName {
+    MetricName::try_new(
+        Some(Arc::from("cpu")),
+        vec![Label {
+            name: Arc::from("host"),
+            value: Arc::from(format!("h{host}")),
+        }],
+    )
+    .unwrap()
+}
+
+#[test]
+fn builder_matches_dense_reference() {
+    for seed in 0..200 {
+        let mut rng = StdRng::seed_from_u64(seed);
+        let fields = rng.random_range(1..=3);
+        let grid_len = rng.random_range(1..64);
+        let mut builder = GridSeriesBuilder::try_new(grid_schema(fields, grid_len)).unwrap();
+        // One builder serves several series, as it does inside an operator.
+        for host in 0..3 {
+            let expected = random_dense(&mut rng, grid_len as usize, fields);
+            for (index, row) in expected.iter().enumerate() {
+                // Missing rows may be pushed as all-None or skipped entirely.
+                if row.iter().any(Option::is_some) || rng.random_bool(0.5) {
+                    builder.push(index, row).unwrap();
+                }
+            }
+            let actual = builder.finish(metric(host)).unwrap();
+            assert_series_eq(actual.as_ref(), &expected, &metric(host));
+        }
+    }
+}
+
+#[test]
+fn builder_rejects_invalid_rows() {
+    let mut builder = GridSeriesBuilder::try_new(grid_schema(2, 4)).unwrap();
+    builder.push(1, &[Some(1.0), None]).unwrap();
+    assert!(builder.push(1, &[Some(2.0), None]).is_err());
+    assert!(builder.push(0, &[Some(2.0), None]).is_err());
+    assert!(builder.push(4, &[Some(2.0), None]).is_err());
+    assert!(builder.push(2, &[Some(2.0)]).is_err());
+
+    let mut schema = grid_schema(1, 4).as_ref().clone();
+    schema.eval_grid = None;
+    assert!(GridSeriesBuilder::try_new(Arc::new(schema)).is_err());
+}
+
+/// Label sets compare without empty values, which Prometheus does not have: a series with
+/// `host=""` and one without `host` merge.
+#[test]
+fn merge_treats_empty_label_values_as_absent() {
+    let schema = grid_schema(1, 2);
+    let labels = |host: Option<&str>| {
+        let mut labels = Labels::from([("job".to_string(), "x".to_string())]);
+        if let Some(host) = host {
+            labels.insert("host".to_string(), host.to_string());
+        }
+        labels
+    };
+    let series = vec![
+        series_of(
+            &schema,
+            &labels(Some("")),
+            &Points::from([(0, 1f64.to_bits())]),
+        )
+        .unwrap(),
+        series_of(&schema, &labels(None), &Points::from([(1, 2f64.to_bits())])).unwrap(),
+    ];
+    let merged = merge_same_labelset(&schema, series).unwrap();
+    assert_eq!(merged.len(), 1);
+    assert_eq!(
+        points_of(&merged[0]),
+        Points::from([(0, 1f64.to_bits()), (1, 2f64.to_bits())])
+    );
+}
+
+/// Series of one label set merge field by field: different fields at one point combine, and
+/// only one field present in both collides.
+#[test]
+fn merge_combines_disjoint_fields_at_one_point() {
+    let schema = grid_schema(2, 1);
+    let series = |row: [Option<f64>; 2]| {
+        let mut builder = GridSeriesBuilder::try_new(schema.clone()).unwrap();
+        builder.push(0, &row).unwrap();
+        builder.finish(metric(0)).unwrap().unwrap()
+    };
+    let merged = merge_same_labelset(
+        &schema,
+        vec![series([Some(1.0), None]), series([None, Some(2.0)])],
+    )
+    .unwrap();
+    assert_eq!(merged.len(), 1);
+    assert_series_eq(
+        Some(&merged[0]),
+        &vec![vec![Some(1.0), Some(2.0)]],
+        &metric(0),
+    );
+    assert!(
+        merge_same_labelset(
+            &schema,
+            vec![series([Some(1.0), None]), series([Some(2.0), None])]
+        )
+        .is_err()
+    );
+}

src/promql/src/histogram_eval.rs

@@ -0,0 +1,254 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Histogram functions over evaluated series: `histogram_quantile` and `histogram_fraction` over
+//! classic and native histograms (Prometheus `funcHistogramQuantile`, `funcHistogramFraction`
+//! and `resetHistograms`), and `histogram_count`, `histogram_sum`, `histogram_avg`,
+//! `histogram_stddev` and `histogram_stdvar` over native histograms.
+
+mod aggregate;
+mod bounds;
+mod classic;
+// `sub`, `copy_to_schema`, `detect_reset` and `equals` are for the native histogram range
+// functions and binary operators, which build on other branches.
+#[cfg_attr(not(test), allow(dead_code))]
+pub(crate) mod float_histogram;
+mod native;
+#[cfg(test)]
+mod tests;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::histogram::HistogramView;
+use datatypes::series::samples::{DenseSamplesRef, SampleRef, Series, SeriesSchema};
+use datatypes::series::time::TimeAxis;
+
+pub(crate) use aggregate::sum_or_avg;
+pub use aggregate::{HistogramAggregate, aggregate_histograms};
+
+use crate::go_sort;
+use crate::grid_series::{
+    GridSeriesBuilder, LabelSet, METADATA_LABELS, label_set, merge_same_labelset,
+};
+
+const BUCKET_LABEL: &str = "le";
+
+/// `histogram_quantile` or `histogram_fraction` with its constant arguments.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum HistogramFunction {
+    /// `histogram_quantile(q, v)`.
+    Quantile(f64),
+    /// `histogram_fraction(lower, upper, v)`.
+    Fraction { lower: f64, upper: f64 },
+}
+
+/// Evaluates `function` over the classic and native histograms in `series`.
+///
+/// Float series with the same labels other than `le` form a classic histogram; a float series
+/// whose `le` does not parse is ignored. Native histogram samples are evaluated one by one. At a
+/// point where a native histogram and classic buckets with the same labels (`le` aside) are both
+/// present, neither is evaluated. Each field is evaluated on its own. Classic results drop
+/// `le`; all results drop `__name__`, `__type__` and `__unit__`. Series that then share a label
+/// set are merged as [`merge_same_labelset`] does.
+pub fn evaluate_histograms(
+    function: HistogramFunction,
+    schema: &Arc<SeriesSchema>,
+    series: &[Series],
+) -> Result<Vec<Series>> {
+    let mut groups: HashMap<LabelSet, Group<'_>> = HashMap::new();
+    for series in series {
+        let range = grid_range(series)?;
+        if let Some(upper_bound) = series
+            .metric
+            .get(BUCKET_LABEL)
+            .and_then(classic::parse_bound)
+        {
+            let mut metric = series.metric.clone();
+            metric.remove(BUCKET_LABEL);
+            groups
+                .entry(label_set(&metric))
+                .or_insert_with(|| Group::new(metric))
+                .classic
+                .push((upper_bound, series, range));
+        }
+        if has_histograms(series) {
+            let metric = series.metric.clone();
+            groups
+                .entry(label_set(&metric))
+                .or_insert_with(|| Group::new(metric))
+                .native = Some((series, range));
+        }
+    }
+
+    let mut output = Vec::with_capacity(groups.len());
+    let mut builder = GridSeriesBuilder::try_new(schema.clone())?;
+    let mut classic_buckets = Vec::new();
+    let mut native_buckets = Vec::new();
+    let mut values = vec![None; schema.fields.len()];
+    for mut group in groups.into_values() {
+        let ranges = group
+            .classic
+            .iter()
+            .map(|member| member.2)
+            .chain(group.native.map(|native| native.1));
+        let start = ranges.clone().map(|range| range.0).min().unwrap_or(0);
+        let end = ranges.map(|range| range.1).max().unwrap_or(0);
+        for point in start..end {
+            for (field, value) in values.iter_mut().enumerate() {
+                classic_buckets.clear();
+                for &(upper_bound, series, range) in &group.classic {
+                    if let Some(SampleRef::Float(count)) = sample(series, range, field, point) {
+                        classic_buckets.push(classic::Bucket { upper_bound, count });
+                    }
+                }
+                // Go sorts the buckets present at each point by `<`: +0 and -0 tie and NaN
+                // ties with everything, so which of them coalescing keeps and where a NaN
+                // bound lands follow its sort algorithm.
+                go_sort::sort_by(&mut classic_buckets, |a, b| a.upper_bound < b.upper_bound);
+                let native = group.native.and_then(|(series, range)| {
+                    match sample(series, range, field, point) {
+                        Some(SampleRef::Histogram(h)) => Some(h),
+                        _ => None,
+                    }
+                });
+                // A native histogram and classic buckets of one label set conflict.
+                *value = match (native, classic_buckets.is_empty()) {
+                    (Some(_), false) | (None, true) => None,
+                    (Some(h), true) => Some(match function {
+                        HistogramFunction::Quantile(q) => {
+                            native::quantile(q, &h, &mut native_buckets)?
+                        }
+                        HistogramFunction::Fraction { lower, upper } => {
+                            native::fraction(lower, upper, &h, &mut native_buckets)?
+                        }
+                    }),
+                    (None, false) => Some(match function {
+                        HistogramFunction::Quantile(q) => {
+                            classic::bucket_quantile(q, &mut classic_buckets)
+                        }
+                        HistogramFunction::Fraction { lower, upper } => {
+                            classic::bucket_fraction(lower, upper, &mut classic_buckets)
+                        }
+                    }),
+                };
+            }
+            builder.push(point, &values)?;
+        }
+        group.metric.remove_all(&METADATA_LABELS);
+        output.extend(builder.finish(group.metric)?);
+    }
+    merge_same_labelset(schema, output)
+}
+
+/// The series of one label set (`le` aside): classic buckets, and the series of exactly that
+/// label set when it holds native histograms.
+struct Group<'a> {
+    metric: MetricName,
+    classic: Vec<(f64, &'a Series, (usize, usize))>,
+    native: Option<(&'a Series, (usize, usize))>,
+}
+
+impl Group<'_> {
+    fn new(metric: MetricName) -> Self {
+        Self {
+            metric,
+            classic: Vec::new(),
+            native: None,
+        }
+    }
+}
+
+/// The absolute grid range `[start, end)` of `series`.
+fn grid_range(series: &Series) -> Result<(usize, usize)> {
+    let TimeAxis::Grid(range) = &series.time else {
+        return Err(DataFusionError::Execution(
+            "histogram functions require evaluated series".into(),
+        ));
+    };
+    Ok((range.start(), range.start() + range.len()))
+}
+
+fn sample(
+    series: &Series,
+    (start, end): (usize, usize),
+    field: usize,
+    point: usize,
+) -> Option<SampleRef<'_>> {
+    (start..end)
+        .contains(&point)
+        .then(|| series.fields.as_slice()[field].sample(point - start))
+}
+
+fn has_histograms(series: &Series) -> bool {
+    series.fields.iter().any(|samples| {
+        samples
+            .segments()
+            .iter()
+            .any(|segment| !matches!(segment.dense(), Some(DenseSamplesRef::Float(_))))
+    })
+}
+
+/// A function of one native histogram.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NativeHistogramFunction {
+    Count,
+    Sum,
+    Avg,
+    StdDev,
+    StdVar,
+}
+
+/// Applies `function` to the native histogram samples of `series`; float samples are dropped and
+/// so is `__name__`. The result is `None` when the series has no histogram sample.
+///
+/// Series that share a label set once their names are dropped must then go through
+/// [`merge_same_labelset`].
+pub fn map_native_histogram(
+    function: NativeHistogramFunction,
+    schema: &Arc<SeriesSchema>,
+    series: &Series,
+) -> Result<Option<Series>> {
+    let range = grid_range(series)?;
+    let mut builder = GridSeriesBuilder::try_new(schema.clone())?;
+    let mut buckets = Vec::new();
+    let mut values = vec![None; schema.fields.len()];
+    for point in range.0..range.1 {
+        for (field, value) in values.iter_mut().enumerate() {
+            *value = match sample(series, range, field, point) {
+                Some(SampleRef::Histogram(h)) => Some(function.apply(&h, &mut buckets)?),
+                _ => None,
+            };
+        }
+        builder.push(point, &values)?;
+    }
+    let mut metric = series.metric.clone();
+    // Prometheus `simpleHistogramFunc` drops only `__name__`, unlike `histogram_quantile`.
+    metric.remove("__name__");
+    builder.finish(metric)
+}
+
+impl NativeHistogramFunction {
+    fn apply(self, h: &HistogramView<'_>, buckets: &mut Vec<native::NativeBucket>) -> Result<f64> {
+        Ok(match self {
+            Self::Count => h.count,
+            Self::Sum => h.sum,
+            Self::Avg => h.sum / h.count,
+            Self::StdDev => native::variance(h, buckets)?.sqrt(),
+            Self::StdVar => native::variance(h, buckets)?,
+        })
+    }
+}

src/promql/src/histogram_eval/aggregate.rs

@@ -0,0 +1,210 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! `sum` and `avg` of native histograms within one aggregation group, following the histogram
+//! paths of Prometheus `aggregation`.
+
+use std::sync::Arc;
+
+use datafusion::arrow::array::UInt32Array;
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::histogram::HistogramBatchBuilder;
+use datatypes::series::samples::{SampleRef, Samples, Series, SeriesFields, SeriesSchema};
+use datatypes::series::time::{GridRange, TimeAxis};
+
+use crate::grid_series::external;
+use crate::histogram_eval::float_histogram::FloatHistogram;
+use crate::histogram_eval::grid_range;
+
+/// A native histogram aggregation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HistogramAggregate {
+    Sum,
+    Avg,
+}
+
+/// Aggregates the native histograms of one group at every point, adding them in the order of
+/// `group`. A point yields no histogram when the group also has a float sample there, or when
+/// its histograms mix exponential and custom buckets. Float-only points are left to the float
+/// aggregation. The result carries `metric`.
+pub fn aggregate_histograms(
+    op: HistogramAggregate,
+    schema: &Arc<SeriesSchema>,
+    group: &[Series],
+    metric: MetricName,
+) -> Result<Option<Series>> {
+    let grid = schema.eval_grid.clone().ok_or_else(|| {
+        DataFusionError::Execution("histogram aggregation requires an evaluation grid".into())
+    })?;
+    let ranges = group.iter().map(grid_range).collect::<Result<Vec<_>>>()?;
+    let start = ranges.iter().map(|range| range.0).min().unwrap_or(0);
+    let end = ranges.iter().map(|range| range.1).max().unwrap_or(0);
+
+    let fields = schema.fields.len();
+    // Written from the first point with a result, so a sparse group allocates no full span.
+    let mut builders: Vec<HistogramBatchBuilder> =
+        (0..fields).map(|_| HistogramBatchBuilder::new()).collect();
+    let mut indices: Vec<Vec<Option<u32>>> = vec![Vec::new(); fields];
+    let mut first = None;
+    let mut row: Vec<Option<FloatHistogram>> = (0..fields).map(|_| None).collect();
+    for point in start..end {
+        for (field, value) in row.iter_mut().enumerate() {
+            let samples = group
+                .iter()
+                .zip(&ranges)
+                .filter(|(_, (from, to))| (*from..*to).contains(&point))
+                .map(|(series, &(from, _))| series.fields.as_slice()[field].sample(point - from));
+            *value = aggregate_point(op, samples)?;
+        }
+        if row.iter().all(Option::is_none) {
+            continue;
+        }
+        let first = *first.get_or_insert(point);
+        for ((value, builder), indices) in row.iter().zip(&mut builders).zip(&mut indices) {
+            indices.resize(point - first, None);
+            indices.push(match value {
+                Some(h) => Some(h.push_to(builder)?),
+                None => None,
+            });
+        }
+    }
+    let Some(first) = first else {
+        return Ok(None);
+    };
+    let len = indices[0].len();
+    let mut samples = Vec::with_capacity(fields);
+    for (builder, indices) in builders.into_iter().zip(indices) {
+        let batch = builder.finish().map_err(external)?;
+        samples.push(
+            Samples::try_from_histogram(UInt32Array::from(indices), batch).map_err(external)?,
+        );
+    }
+    let range = GridRange::try_new(grid, first, len).map_err(external)?;
+    Series::try_new(
+        schema,
+        metric,
+        TimeAxis::Grid(range),
+        SeriesFields::try_from_vec(samples).map_err(external)?,
+    )
+    .map(Some)
+    .map_err(external)
+}
+
+/// One point of one field.
+fn aggregate_point<'a>(
+    op: HistogramAggregate,
+    samples: impl Iterator<Item = SampleRef<'a>>,
+) -> Result<Option<FloatHistogram>> {
+    let (mut histograms, mut has_float) = (Vec::new(), false);
+    for sample in samples {
+        match sample {
+            SampleRef::Missing => {}
+            SampleRef::Float(_) => has_float = true,
+            SampleRef::Histogram(view) => histograms.push(FloatHistogram::try_from_view(&view)?),
+        }
+    }
+    let Some(mut value) = sum_or_avg(op, histograms)? else {
+        return Ok(None);
+    };
+    if has_float {
+        return Ok(None);
+    }
+    value.compact();
+    Ok(Some(value))
+}
+
+/// The Kahan sum or the mean of `histograms` in order, without compaction; `None` when there is
+/// none or they mix exponential and custom buckets. Prometheus `sum_over_time` and
+/// `avg_over_time` run the same steps as the aggregations.
+pub(crate) fn sum_or_avg(
+    op: HistogramAggregate,
+    histograms: impl IntoIterator<Item = FloatHistogram>,
+) -> Result<Option<FloatHistogram>> {
+    let mut value: Option<FloatHistogram> = None;
+    let mut compensation: Option<FloatHistogram> = None;
+    let mut mean: Option<FloatHistogram> = None;
+    let mut count = 0.0;
+    for h in histograms {
+        count += 1.0;
+        let Some(current) = value.as_mut() else {
+            value = Some(h);
+            continue;
+        };
+        // Go drops the result with a warning for this addition error only; others propagate.
+        if current.uses_custom_buckets() != h.uses_custom_buckets() {
+            return Ok(None);
+        }
+        match op {
+            HistogramAggregate::Sum => {
+                let (c, _) = current.kahan_add(&h, compensation.take())?;
+                compensation = Some(c);
+            }
+            HistogramAggregate::Avg => {
+                if mean.is_none() {
+                    let mut sum = current.clone();
+                    let (c, _) = sum.kahan_add(&h, compensation.clone())?;
+                    if !sum.has_overflow() {
+                        *current = sum;
+                        compensation = Some(c);
+                        continue;
+                    }
+                    let mut started = current.clone();
+                    started.div(count - 1.0);
+                    if let Some(c) = compensation.as_mut() {
+                        c.div(count - 1.0);
+                    }
+                    mean = Some(started);
+                }
+                // Go switches to an incremental mean once the plain sum overflows.
+                let q = (count - 1.0) / count;
+                if let Some(c) = compensation.as_mut() {
+                    c.mul(q);
+                }
+                let mut to_add = h;
+                to_add.div(count);
+                let mean = mean.as_mut().expect("set above");
+                mean.mul(q);
+                let (c, _) = mean.kahan_add(&to_add, compensation.take())?;
+                compensation = Some(c);
+            }
+        }
+    }
+    let Some(mut value) = value else {
+        return Ok(None);
+    };
+    match op {
+        HistogramAggregate::Sum => {
+            if let Some(c) = compensation {
+                value.add(&c)?;
+            }
+        }
+        HistogramAggregate::Avg => match mean {
+            Some(mut mean) => {
+                if let Some(c) = compensation {
+                    mean.add(&c)?;
+                }
+                value = mean;
+            }
+            None => {
+                value.div(count);
+                if let Some(mut c) = compensation {
+                    c.div(count);
+                    value.add(&c)?;
+                }
+            }
+        },
+    }
+    Ok(Some(value))
+}

src/promql/src/histogram_eval/arithmetic_cases.txt

@@ -0,0 +1,726 @@
+# Generated by promql-compat cmd/narthex-golden-histarith built for amd64 (Prometheus
+# v3.15.0 model/histogram, seed 1, 80 cases per operation). Each line is
+# `<operation> <argument> <inputs...> => <outputs...>`; see the command for the encoding.
+add - 3/3fe0000000000000/0/4055001175c76074/40adb352ce0f464f/3/-2_1/0/-19_1,2_4/4042800000000000,3f2aa1d1faf86ea9,0,3f4c431a422a645b,4047800000000000/ -2/0/0/4070a40000000000/c05338b536f50bec/2/-2_2,2_2,1_2/0,4050e80000000000,404f800000000000,4050980000000000,4038000000000000,4046a00000000000/// => -2/3fe0000000000000/4050e80000000000/4075e4045d71d81d/40ad198d24579df0/3/0_1,1_2,1_2/0,404f800000000000,4050980000000000,4038000000000000,4046a00000000000/0_1/4055001175c76074/ false false
+add - 1/3f847ae147ae147b/4043800000000000/4055c00000000000/409a41576ddcfc94/1/-9_1,1_1/4000000000000000,4047000000000000/// 8/3f50624dd2f1a9fc/4051a00000000000/4051a00000000000/4086de815c93f4eb/2///// => 1/3f847ae147ae147b/405b600000000000/4063b00000000000/40a2d84c0e137b85/0/-9_1,1_1/4000000000000000,4047000000000000/// true false
+add - -1/3f847ae147ae147b/0/406308039013db44/40b9864b9433bdfa/3/-9_1,0_4/0,4053a00000000000,4014000000000000,3f3c809eda1bc597,4051300000000000/// -1/0/4058800000000000/40803e02c4469307/40d70047979f06bd/2/-7_1,1_4,1_4/0,3f43aa8dcd5315f5,4053c00000000000,4051800000000000,4055800000000000,4059700000000000,0,4055400000000000,3f4899db6326e870/// => -1/3f90000000000000/4078f4043d5ba74c/40850003a84b89d8/40dd61da7cabf63c/3/-2_1,1_4/4055800000000000,4059700000000000,0,4055400000000000,3f4899db6326e870/// false false
+add - -53/0/0/0/8000000000000000/0/////bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/0/////4024000000000000 false true
+add - -53/0/0/4051000000000000/409966d3ad531a66/1/0_1,0_1/4051000000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/403e000000000000/c0893fa096ce3281/0/0_1/403e000000000000///4000000000000000 => -53/0/0/4058800000000000/40898e06c3d8024b/0/0_1/4058800000000000///4000000000000000 false true
+add - 2/0/4051580000000000/4060ec00ea32dd35/c0a5fc6b8295851c/3/-15_1,0_1/4050800000000000,3f1d465ba69a2d82/// 2/255bba08cf8c979d/404f000000000000/4083000000000000/40e136d2220a7a78/1///1_3,0_4,2_2/0,4054400000000000,4057c00000000000,4057400000000000,4058000000000000,4040000000000000,404e000000000000,403d000000000000,404e000000000000/ => 2/255bba08cf8c979d/40606c0000000000/40873b003a8cb74d/40dfae16d3c2444c/3/-15_2/4050800000000000,3f1d465ba69a2d82/1_7,2_2/0,4054400000000000,4057c00000000000,4057400000000000,4058000000000000,4040000000000000,404e000000000000,403d000000000000,404e000000000000/ false false
+add - 3/255bba08cf8c979d/0/4059000000000000/40b4e40ebf046b5a/0///9_2/4055400000000000,402e000000000000/ -1/3f50624dd2f1a9fc/0/406b2c11d7a201e9/40c9769978520227/0/-6_4/4056800000000000,3f4d5a8ade8ace76,3ef39f4ac3c77555,3f3bc20af1adbdf4/-5_1,0_3/3f4b85fd5a261456,4036000000000000,405a180000000000,3ff0000000000000/ => -1/3f50624dd2f1a9fc/0/4073d608ebd100f4/40d1f4506bea1bea/0/-4_2/3ef39f4ac3c77555,3f3bc20af1adbdf4/-4_3,2_1/4036000000000000,405a180000000000,3ff0000000000000,4059000000000000/ false false
+add - -53/0/0/0/8000000000000000/3/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/405fc00000000000/c0977f2f5b288871/0/0_3,0_1/0,4047000000000000,4038000000000000,404c800000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/405fc00000000000/c0977f2f5b288871/3/1_2/4051800000000000,404c800000000000///3ff0000000000000,4014000000000000 false true
+add - 2/3f847ae147ae147b/4053400000000000/4053400000000000/40b45464bac7db92/3///// 1/3f847ae147ae147b/0/404b80221ffa7737/c069c9c4b42704a7/1/-20_4/4000000000000000,3f420ae6585e5e45,404a800000000000,3f4015141ed88149/// => 1/3f847ae147ae147b/4053400000000000/4060800887fe9dce/40b386169526a36d/3///// false false
+add - -4/0/4053400000000000/4067000000000000/c08c89b1e5762346/0/-3_2,2_1/4050400000000000,0,4045000000000000/// 0/3f847ae147ae147b/4058000000000000/40759400359377b2/40d082df51cf94f8/0/-12_3/3f0ac9bbd92a4212,4040000000000000,4000000000000000/-7_4,2_1/404c200000000000,0,4050400000000000,0,4057800000000000/ => -4/3f847ae147ae147b/406dc00000000000/40808a001ac9bbd9/40cf3d238547c7bc/0/0_2/40410001ac9bbd93,4045000000000000/0_1/406ae80000000000/ false false
+add - -53/0/0/0/0/0/////4000000000000000 -53/0/0/4054400000000000/c0942d5c55748449/2/0_1/4054400000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4054400000000000/c0942d5c55748449/0/0_1/4054400000000000///4000000000000000 false true
+add - -4/0/4052c00000000000/40652003ba9a0d24/c08b279e8e4dc053/3/7_2,1_4/3f3dd4d069223133,0,0,0,4057800000000000,0/// 1/0/4049000000000000/40705a032b9fd255/40cb12f81835a5e3/2/9_4/3f213200cad0775c,0,4042500000000000,4055c00000000000/-20_2/4056000000000000,3f45107e5ff6aac6/ => -4/0/405f400000000000/407aea0508ecd8e7/40c9607e2f50c9de/3/1_1,5_2,1_4/405ee8022640195a,3f3dd4d069223133,0,0,0,4057800000000000,0/0_1/4056000a883f2ffb/ false false
+add - 5/0/0/405600093cef3e69/40b6fcfd692ab2ba/2/-7_2,0_2/404f800000000000,3f4279de7cd2292d,0,4039000000000000/// 5/0/0/406ce0000fc9ce2e/40c8bcb7216b7dfb/0/-6_2,0_2,2_4/3edf939c5ac29b70,3ff0000000000000,0,4056000000000000,404e000000000000,0,4054800000000000,0/// => 5/0/0/4073f0025720b6b1/40d21d9aeb006bac/0/-7_2,0_3,2_4/404f800000000000,3f42b905b587ae64,3ff0000000000000,4039000000000000,4056000000000000,404e000000000000,0,4054800000000000,0/// false false
+add - 1/3f847ae147ae147b/0/0/0/1///// -53/0/0/4054c00000000000/c09a16167abe8cd0/1/1_2/0,4054c00000000000///3ff0000000000000,4014000000000000,4024000000000000 => error
+add - -4/3f50624dd2f1a9fc/4058800000000000/408066050f0e5c7c/40da13893c2a1e5e/0/-19_4,0_1,1_4/405c980000000000,0,3f3ed04b2e45fea6,4054800000000000,4051800000000000,0,3f1092a3cf86d3d4,3f4a23f8325b053c,4051000000000000/-17_2,0_2,0_2/4044800000000000,3f375db598c81a6f,3ff0000000000000,3f49a398b7f2696c,4041800000000000,402ec00000000000/ 0/3fe0000000000000/0/4061200000000000/40bd8a9f0f269364/1/-17_1,2_1,0_3/4041800000000000,4049000000000000,404a000000000000,0,0/// => -4/3fe0000000000000/408066050f0e5c7c/4084ae050f0e5c7c/40e0bb187ff9e19c/0/0_1/4059800000000000/// false false
+add - 5/255bba08cf8c979d/3f387367ab034118/405980070425b3dc/c093688953d820fb/2/3_2,0_1/403e400000000000,4051f00000000000,3f0ce9792362aacf/// 5/3fe0000000000000/4036000000000000/40746a0000000000/40bcc3040c1902f8/3/-5_3,0_3,0_4/401c000000000000,3ff0000000000000,3ff0000000000000,4049000000000000,403aa00000000000,4034600000000000,402e000000000000,403ea00000000000,404e000000000000,4057400000000000/// => 5/3fe0000000000000/403600187367ab03/407aca01c1096cf7/40b7e8e1b722fab9/3/-5_8,0_3/401c000000000000,3ff0000000000000,3ff0000000000000,4049000000000000,403aa00000000000,4034600000000000,402e000000000000,403ea00000000000,4056900000000000,4064980000000000,3f0ce9792362aacf/// false false
+add - 5/0/0/0/0/3///// 2/255bba08cf8c979d/0/4063b40000000000/40be7f19c0e231c4/0/8_4/4029400000000000,4040000000000000,4037000000000000,4056800000000000/// => 2/255bba08cf8c979d/0/4063b40000000000/40be7f19c0e231c4/3/8_4/4029400000000000,4040000000000000,4037000000000000,4056800000000000/// false false
+add - -2/3fe0000000000000/0/0/0/3///// 2/3f50624dd2f1a9fc/3f4305579bb84a94/406ae006303bd8e0/c0a2d04a80336bb5/3/-13_1,2_2,2_1/3f26ee5f1f1fc606,4054f80000000000,4057c80000000000,4042000000000000/// => -2/3fe0000000000000/406ae006303bd8e0/406ae006303bd8e0/c0a2d04a80336bb5/3/0_1/406ae0016ee5f1f2/// false false
+add - 5/3f50624dd2f1a9fc/0/407da004bdf97b56/40bf8a2ca0dadb2a/3/9_3,0_1,0_2/0,402e000000000000,3f4d33d2909fe965,3f3177f2941fd20e,4010000000000000,0/-1_2,0_4,2_2/4056b00000000000,404f000000000000,404d000000000000,4043000000000000,4056000000000000,4047200000000000,0,4052000000000000/ 2/255bba08cf8c979d/0/404b800000000000/40948dee462df3d0/1/1_2/0,404b800000000000/// => 2/3f50624dd2f1a9fc/0/408088025efcbdab/40c256d419332c0f/3/1_2/0,40528012f7e5ed58/0_2/4063180000000000,4072e40000000000/ false false
+add - -4/3f847ae147ae147b/0/40793e013fccb52d/40923f1c699d83b6/0/2_4,1_4,1_1/4054c00000000000,0,4058000000000000,0,403fa00000000000,404fb00000000000,405ab80000000000,3f33fccb52caf68a,4037000000000000/// 1/0/4047800000000000/4055780000000000/c092b2c3d82c68d9/0/-20_2/4008000000000000,4041f00000000000/// => -4/3f847ae147ae147b/4055780000000000/407e9c013fccb52d/c03ce9dba3b948c0/0/0_1,1_4,1_4,1_1/4043700000000000,4054c00000000000,0,4058000000000000,0,403fa00000000000,404fb00000000000,405ab80000000000,3f33fccb52caf68a,4037000000000000/// false false
+add - 3/0/0/4030600000000000/408ef98b943a5cd4/1/-1_1/4030600000000000/// -2/0/0/4059c00042ea2514/c091b29812ab5e82/3///-2_2,0_4,1_1/3ef0ba8944e9d17f,0,0,0,0,4053800000000000,4039000000000000/ => -2/0/0/405dd80042ea2514/c061ae92447180c0/3/0_1/4030600000000000/-2_6,1_1/3ef0ba8944e9d17f,0,0,0,0,4053800000000000,4039000000000000/ false false
+add - 3/255bba08cf8c979d/4053000000000000/4062dc04b0d6f42e/40c32887d8c7d510/0///-12_4/3f3e98a09668f9e5,3f1bb85c2c3286aa,4051b80000000000,4010000000000000/ -4/255bba08cf8c979d/0/4064fc01678603a8/c095819fc87792a0/0/2_4/4039000000000000,4053800000000000,3f2678603a7aeac0,4050380000000000/// => -4/255bba08cf8c979d/4053000000000000/4073ec030c2e7beb/40c07853dfb8e2bc/0/2_4/4039000000000000,4053800000000000,3f2678603a7aeac0,4050380000000000/0_1/4052b80961ade85d/ false false
+add - 0/3f847ae147ae147b/4052f00000000000/4067fc0286b3f5ee/c0ab14b6ed71f285/1/-9_2,0_2,2_1/3f34359faf6db525,4042800000000000,404b900000000000,402a000000000000,4026000000000000/// 1/255bba08cf8c979d/3f3d89082035127a/4064c015e13ae358/c0b35120489f64f8/2/-15_3/404c800000000000,0,3f501f6fb9f7a194/-17_2,0_2,1_2/0,3f41e3bcf8ed4d08,3f417d032bc28b2b,3f24831f929190f1,4050c00000000000,4045000000000000/ => 0/3f90000000000000/40730e0c33f76ca3/40765e0c33f76ca3/c0c06dbddfac2f1d/0/-3_1/4026000000000000/-5_1/4045000000000000/ true false
+add - 0/255bba08cf8c979d/0/4071220222b0f14a/4077011e6192f40d/3/-4_3,0_4,0_2/403d000000000000,3f4115878a4b9106,4052d80000000000,4044000000000000,402f800000000000,0,4057000000000000,4036000000000000,0/// -1/3fe0000000000000/4050c00000000000/406680069abe4afa/40b06b930a294459/2/5_3/403b000000000000,3f4a6af92bea7589,4055800000000000/// => -1/3fe0000000000000/406a6c044561e293/407c6205701016c7/40b1dba4f042739a/3/0_3,2_3/402f800000000000,4057000000000000,4036000000000000,403b000000000000,3f4a6af92bea7589,4055800000000000/// false false
+add - 0/0/0/40584006f5050aa1/40a23bdd5bec4aa7/0///8_2/3f3bd4142a83385a,4058400000000000/ 0/3fe0000000000000/0/4077740015709b87/40d87198f2915601/3/-16_2,2_4,1_2/4014000000000000,4041600000000000,4053e00000000000,3ef5709b872e7295,4055c00000000000,4054000000000000,4050400000000000,4038000000000000/// => 0/3fe0000000000000/0/407d8401d2b1de2f/40dab9149e0edf56/3///8_2/3f3bd4142a83385a,4058400000000000/ false false
+add - -53/0/0/0/0/2/////4000000000000000 -53/0/0/4036000000000000/408ded9c28dbcdfe/2/1_3/0,4036000000000000,0///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/4036000000000000/408ded9c28dbcdfe/2/0_1/4036000000000000/// false true
+add - -4/3fe0000000000000/0/0/8000000000000000/2///// 2/3fe0000000000000/4044900000000000/406e2001ec055a30/40cdb834800b7bb3/0/5_3,0_3/4055c00000000000,4037e00000000000,3ff0000000000000,3f2ec055a303c4c9,0,4056000000000000/// => -4/3fe0000000000000/4044900000000000/406e2001ec055a30/40cdb834800b7bb3/0/1_1/4068fc01ec055a30/// false false
+add - -53/0/0/404de00000000000/40a81b0dbc9cafc4/1/1_2/4041e00000000000,4038000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/8000000000000000/1/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/404de00000000000/40a81b0dbc9cafc4/1/0_1/404de00000000000///4024000000000000 false true
+add - 8/3f50624dd2f1a9fc/0/406740019b1009bc/40b922c599a2e0bc/0/-11_2,0_3,2_2/4041000000000000,4045000000000000,3f29b1009bbd3933,0,404e000000000000,4000000000000000,4041000000000000/-11_1,2_1/0,402c000000000000/ 5/3f50624dd2f1a9fc/0/4031000000000000/4079dd92499b78d2/1/-3_1/4031000000000000/// => 5/3f50624dd2f1a9fc/0/406960019b1009bc/40bac09ebe3c9849/0/-3_1,1_2/4031000000000000,4053000336201378,4058000000000000/-1_1/402c000000000000/ false false
+add - 3/3fe0000000000000/0/406c180538808ddd/40bf562aee9c2d8f/0/-10_4/3f44e20237734b6b,4057000000000000,404e000000000000,4052300000000000/// 5/255bba08cf8c979d/0/40894502fb0014e0/40e6584ba5d6c9cd/3/-12_1,1_4,1_4/405f300000000000,404c800000000000,4032600000000000,404e000000000000,3f4e780f219b6a91,4056800000000000,4020000000000000,404f000000000000,4051000000000000/4_4,0_3,0_3/4056c00000000000,3f237f6be25f14cd,4033800000000000,4038000000000000,0,3f38b02e67abf255,404a000000000000,4052800000000000,4038000000000000,4042000000000000/ => 3/3fe0000000000000/0/4090258224901c2c/40ea431103aa4f7f/3/-10_4,3_4/3f44e20237734b6b,4057000000000000,404e000000000000,4052300000000000,405f300000000000,4060ec0000000000,4058800f3c0790ce,4060400000000000/1_4/4056c00000000000,4045c004dfdaf898,4062c0031605ccf6,4042000000000000/ false false
+add - 1/3fe0000000000000/0/407a000b90e854da/40d2461e3deb6957/1/-8_2,0_4,0_4/3f4be6d803de982e,4051800000000000,3f25eed92421272d,4056400000000000,3f21f861d766186d,4056400000000000,4030000000000000,3f4637bc3fd02619,4039000000000000,402c000000000000/-19_4/4044000000000000,404d800000000000,402c000000000000,3f50376fd21f8a96/ -4/3f847ae147ae147b/403fa00000000000/4079ea053e2d558e/40d0116598a915b3/1///4_4,2_3,2_2/3f45eda2f45ce87c,4053480000000000,4033000000000000,4049100000000000,4053400000000000,4048000000000000,404ec00000000000,3f4403c7b812ffca,4049200000000000/ => -4/3fe0000000000000/403fa00000000000/4089f508678ad534/40e12bc1eb4a3f85/1/0_2/40721007830c6052,402c000000000000/0_1,3_4,2_3,2_2/405c4010376fd220,3f45eda2f45ce87c,4053480000000000,4033000000000000,4049100000000000,4053400000000000,4048000000000000,404ec00000000000,3f4403c7b812ffca,4049200000000000/ false false
+add - -53/0/0/0/0/1/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/4066480000000000/40baaa9081beb33a/2/1_3/0,405a680000000000,4052280000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4066480000000000/40baaa9081beb33a/0/1_1/4066480000000000///3ff0000000000000,4014000000000000 true true
+add - -2/3f847ae147ae147b/0/3f61123dfedea1f4/3fa88b0aa6ee6511/1///-17_2,1_2/3f31d93f098fc80d,0,3f501b60201d9bcc,3f4b259836776c30/ -1/0/0/405b780ad3a0ec9b/40972b6c7f1cfc5c/3/-14_3/3f4443070282bf7a,4050d00000000000,3f0643ad6b428509/5_1/4045500000000000/ => -2/3f847ae147ae147b/4050d00ad3a0ec9b/405b782cf81cea58/40972b9d95324a39/3///-17_2,1_2,15_1/3f31d93f098fc80d,0,3f501b60201d9bcc,3f4b259836776c30,4045500000000000/ false false
+add - -4/3f50624dd2f1a9fc/0/407d92016684e977/40a53b2eba1e8d31/2/3_2,2_3/0,4052400000000000,4042800000000000,4043800000000000,4054400000000000/-16_4,0_3,0_2/0,403d000000000000,4052400000000000,3f2d703a6c6e5383,4031000000000000,4056500000000000,3f1ec0c5851ca8cc,403f000000000000,400f000000000000/ 1/0/0/0/0/1///// => -4/3f50624dd2f1a9fc/0/407d92016684e977/40a53b2eba1e8d31/0/3_2,2_3/0,4052400000000000,4042800000000000,4043800000000000,4054400000000000/-16_4,0_3,0_2/0,403d000000000000,4052400000000000,3f2d703a6c6e5383,4031000000000000,4056500000000000,3f1ec0c5851ca8cc,403f000000000000,400f000000000000/ true false
+add - -53/0/0/0/8000000000000000/3/////4000000000000000 -53/0/0/401c001fb679ad96/c05a2a4e629033cc/0/0_1,1_3/0,3f1fb679ad95bd95,401c000000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/401c001fb679ad96/c05a2a4e629033cc/3/0_2/3f1fb679ad95bd95,401c000000000000///4000000000000000 false true
+add - 2/255bba08cf8c979d/4031e00000000000/4031e00000000000/406bbd03d3a3dd9a/3///// 8/3f50624dd2f1a9fc/0/40600003d4b11718/c0a3795b966cb94e/1///4_4/4051c00000000000,3f3ea588b8bc7dd5,404c800000000000,0/ => 2/3f50624dd2f1a9fc/4031e00000000000/40623c03d4b11718/c0a1bd8b59327b74/3///1_1/40600003d4b11718/ false false
+add - 5/3f50624dd2f1a9fc/0/4047a00000000000/c090ab6c95efff66/3///6_1,1_3,1_2/4038400000000000,4030000000000000,401c000000000000,0,0,0/ 5/255bba08cf8c979d/4047f00000000000/40633c0ca4f0028e/c09134bdcebfe835/1/1_2,0_4/4041800000000000,3f468b5c33d8eb75,4014000000000000,3f4c0863d65d5888,4050800000000000,0/// => 5/3f50624dd2f1a9fc/4047f00000000000/4069240ca4f0028e/c0a0f0153257f3ce/3/1_6/4041800000000000,3f468b5c33d8eb75,4014000000000000,3f4c0863d65d5888,4050800000000000,0/6_1,1_3,1_2/4038400000000000,4030000000000000,401c000000000000,0,0,0/ false false
+add - -53/0/0/403f000000000000/40937513178e7e42/3/0_1,0_1,1_1/403f000000000000,0,0///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/8000000000000000/2/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/403f000000000000/40937513178e7e42/3/0_1,0_1,1_1/403f000000000000,0,0///bff0000000000000,0,3fe0000000000000,4024000000000000 false false
+add - -53/0/0/404f700eea01855e/406e36efb3b68fb4/0/1_3/4043f00000000000,4037000000000000,3f3dd4030abb461c///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/404f700eea01855e/406e36efb3b68fb4/0/0_2/404f700000000000,3f3dd4030abb461c///4024000000000000 false true
+add - -53/0/0/0/8000000000000000/2/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/4000000000000000/4038307289ce7fd5/3/1_3/0,0,4000000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/4000000000000000/4038307289ce7fd5/3/0_1/4000000000000000///4024000000000000 false true
+add - 1/255bba08cf8c979d/0/4045800000000000/408f3304459ad839/0/-10_3/4045800000000000,0,0/// -53/0/0/0/0/0/1_1/0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => error
+add - 1/3f50624dd2f1a9fc/4008000000000000/4057800061596f70/40b7622fd1b9db7c/2/4_4,1_2,2_1/0,3ef8565bdc1d57e1,0,0,4048800000000000,0,4022000000000000/2_2/4040800000000000,0/ 5/3f847ae147ae147b/403f000000000000/40615c04fa34fd3e/40c2ba8fd99b567a/0/-7_4/3f43e8d3f4f5ddd9,0,405a580000000000,4004000000000000/// => 1/3f847ae147ae147b/4041000000000000/406d1c052ae1b4f6/40ce6ba7c2784438/0/0_1,4_1,3_1,3_1/405af809f469fa7b,3ef8565bdc1d57e1,4048800000000000,4022000000000000/2_1/4040800000000000/ false false
+add - -53/0/0/3f4db89e86b7e438/3f385343cc6ab3bf/1/1_1,2_1/3f4db89e86b7e438,0///bff0000000000000,0,3fe0000000000000,4024000000000000 -2/3f50624dd2f1a9fc/0/407840040befa417/c0c52a2b51e8bee6/0/-8_3,0_3,0_1/4058c00000000000,4050c00000000000,4044800000000000,403b000000000000,4050400000000000,4056400000000000,3f502fbe905def66/// => error
+add - 8/3f847ae147ae147b/0/4064ec0000000000/c09068f937d187e0/0/-8_3,1_3,2_1/0,0,4044000000000000,401e800000000000,4053400000000000,401c000000000000,4041e00000000000/// -53/0/0/4061e00000000000/c07ffc9133064f61/1/0_1,0_1/4058800000000000,4046800000000000///4000000000000000 => error
+add - -2/3f847ae147ae147b/404b000000000000/404b000000000000/40a599907e16b934/2///// 3/3f847ae147ae147b/0/0/0/1///// => -2/3f847ae147ae147b/404b000000000000/404b000000000000/40a599907e16b934/0///// true false
+add - -53/0/0/403a0031fb3039af/408519f126c8b735/2/1_2/3f48fd981cd78e1c,403a000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405e800000000000/40ab45eba5a24a61/0/1_2/4058c00000000000,4037000000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/406280063f660736/40b04633f7aa3c17/0/0_3/3f48fd981cd78e1c,405f400000000000,4037000000000000///3ff0000000000000,4014000000000000 false true
+add - 3/0/0/4010000000000000/c05576f88b155036/2/-18_1/4010000000000000/// 0/255bba08cf8c979d/404d800000000000/40714a0000000000/c0b558e5cdfa94b6/0/-17_3,1_2,2_3/4048700000000000,4043800000000000,403d200000000000,0,4056c00000000000,4023400000000000,0,0/// => 0/255bba08cf8c979d/404d800000000000/40718a0000000000/c0b5aec1b026e9f7/0/-17_3,1_2,2_3,4_1/4048700000000000,4043800000000000,403d200000000000,0,4056c00000000000,4023400000000000,0,0,4010000000000000/// false false
+add - -53/0/0/3f534c049ce8f142/bfa0fdc70ffce0e7/1/0_3/3f24142da2ff7c83,3f3c5ffd89b48b50,3f4362ff0c37bdba///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/3f534c049ce8f142/bfa0fdc70ffce0e7/0/0_3/3f24142da2ff7c83,3f3c5ffd89b48b50,3f4362ff0c37bdba///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 true false
+add - 0/3fe0000000000000/3ff0000000000000/405e580000000000/409e916dd1273ccd/1/-20_2,0_4/0,4058d80000000000,0,4018000000000000,0,402e000000000000/// 1/3f847ae147ae147b/3f1620b4f217d05e/40624000b105a791/c0a04c069a87c581/3/9_2/4045000000000000,0/-15_2,1_3,1_1/4028000000000000,4030000000000000,404e000000000000,0,0,4030000000000000/ => 0/3fe0000000000000/405a4001620b4f22/4070b6005882d3c8/c06034fb1f4271a8/3/-20_2,0_4,19_1/0,4058d80000000000,0,4018000000000000,0,402e000000000000,4045000000000000/// false false
+add - -4/3f847ae147ae147b/3f1466169cb2dc9d/4070da0571003fad/40c47d54e599d88b/1/7_2,0_4/0,4058800000000000,3f30c36709905707,4052a80000000000,4010000000000000,3f30180ded5cf85f/9_4/4047000000000000,4037000000000000,3f488d84ae57cc60,4038000000000000/ 1/0/4046000000000000/4061c00000000000/40add49e362751ec/2/9_1/4058800000000000/// => -4/3f847ae147ae147b/404600028cc2d396/4079ba0571003fad/40cbf27c7323ad06/0/1_1,5_2,0_4/4058800000000000,0,4058800000000000,3f30c36709905707,4052a80000000000,4010000000000000,3f30180ded5cf85f/9_4/4047000000000000,4037000000000000,3f488d84ae57cc60,4038000000000000/ true false
+add - -53/0/0/40633c0000000000/c0aab21bf1b5fa23/3/1_1,0_2/4053000000000000,403d000000000000,4048700000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4057400000000000/409105c713c3f879/0/0_2/4052000000000000,4035000000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/406edc0000000000/c0a22f3867d3fde6/3/0_3/4062800000000000,4049000000000000,4048700000000000///3ff0000000000000,4000000000000000,4014000000000000 false true
+add - 5/3fe0000000000000/4040000000000000/4073b801412850e4/c0c121225e99e9bb/1/-17_3,2_2/4000000000000000,3f205e44bb296eff,4039800000000000,4052800000000000,0/-18_1,1_1,0_2/4055400000000000,3f27c6c561687250,0,4058400000000000/ 1/3fe0000000000000/0/0/0/1///// => 1/3fe0000000000000/4040000000000000/4073b801412850e4/c0c121225e99e9bb/1/-1_2/400000417912eca6,4058e00000000000/-1_2/40554002f8d8ac2d,4058400000000000/ false false
+add - -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/4055c004d391667d/40b5b1ed079d8c52/0/0_1,0_2,0_2/4020000000000000,3f334e4599f38f9c,403c000000000000,0,4049800000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/4055c004d391667d/40b5b1ed079d8c52/0/0_2/40420009a722ccfa,4049800000000000///4024000000000000 false true
+add - 0/3fe0000000000000/0/4064e41349f789e2/40acc792ae355503/3/1_4,2_2,0_1/4053800000000000,3f3318ccb4be7988,4055800000000000,3f46ecc82432c7ed,3f47ba9ef6512d40,3f44f410b2a46979,4009000000000000/// 3/3fe0000000000000/4050c00000000000/4080e201a721fa32/c0bfab83c999564f/2/3_3,2_4,2_4/0,4052400000000000,403b000000000000,4047800000000000,402e400000000000,403f000000000000,3f4a721fa31879d6,4058000000000000,4043800000000000,4055800000000000,404d900000000000/// => 0/3fe0000000000000/4050c00000000000/40861b06799fdcaa/c0b147ba727eabce/3/1_4,2_2,0_1/406c200000000000,4070b2047fd0bfaf,4062240000000000,3f46ecc82432c7ed,3f47ba9ef6512d40,3f44f410b2a46979,4009000000000000/// false false
+add - -1/3fe0000000000000/0/405380159d5c5de3/40b060a03c67105a/1/-20_1,1_3/4053800000000000,3f4c1b7a921d4cb3,3f3899f61e343204,3f169218d47058ef/// 1/3f50624dd2f1a9fc/0/40773c02aebcc982/4070b34547b7e419/0/-1_3,2_2,2_3/404b000000000000,0,3f4575e64c10bd71,404b800000000000,4052000000000000,4030000000000000,4044000000000000,4054000000000000/5_2/4042600000000000,4032000000000000/ => -1/3fe0000000000000/0/407c1c081613e0fb/40b16bd490e28e9c/0/-20_1,1_3,15_4/4053800000000000,3f4c1b7a921d4cb3,3f3899f61e343204,3f169218d47058ef,404b000000000000,404b801575e64c11,4056000000000000,405e000000000000/2_1/404b600000000000/ false false
+add - -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/3/////3ff0000000000000,4014000000000000 false true
+add - -1/3f847ae147ae147b/4045000000000000/4045000000000000/4091ada33453b5e3/1///// 3/0/4042000000000000/4080b702eae724d7/40d4057ee11aa96c/1/0_1,1_3,0_4/4051300000000000,0,404cc00000000000,4050c00000000000,4048600000000000,3f4bfd807a4f4c8a,0,4042000000000000/1_4,2_4/4008000000000000,3f31a99dea181cdd,4056400000000000,4041000000000000,3f33b845bc198901,404a700000000000,4045000000000000,0/ => -1/3f847ae147ae147b/4053800000000000/40820702eae724d7/40d52059145fe4ca/1/0_2/4051300000000000,406a2806ff601e94/1_1/406b9c04ac3c74c6/ false false
+add - -1/3fe0000000000000/0/40684005a3d08b14/40b869592f9c5573/2/-12_4,2_3/3f468f422c4e836b,4051800000000000,4056c00000000000,401c000000000000,0,403a000000000000,0/// 2/3f847ae147ae147b/4034000000000000/4034000000000000/4075b01d9a011cf2/1///// => -1/3fe0000000000000/4034000000000000/406ac005a3d08b14/40b9c45b093c6742/0/-12_4,2_3/3f468f422c4e836b,4051800000000000,4056c00000000000,401c000000000000,0,403a000000000000,0/// true false
+add - -53/0/0/0/8000000000000000/3/////4000000000000000 -53/0/0/0/8000000000000000/0/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/8000000000000000/3///// false true
+add - 8/255bba08cf8c979d/0/407f5c03d10d8292/c0c1e066c91b1074/2///-11_4,0_3,2_4/4041500000000000,4018000000000000,0,4059600000000000,4054000000000000,4059800000000000,404a800000000000,4053000000000000,3f2af950180c804a,3f47ca180e8f072c,4048500000000000/ -1/0/0/406440108a108d2c/c06b15a111adc552/2/8_4,1_3,2_1/3f4aa87afda13e91,4056000000000000,4040800000000000,4044800000000000,3f369e88dbf71bcb,3f4c3082c91203be,0,0/// => -1/255bba08cf8c979d/0/4084be060b0ae494/c0c24cbd4d61c789/2/8_4,1_3,2_1/3f4aa87afda13e91,4056000000000000,4040800000000000,4044800000000000,3f369e88dbf71bcb,3f4c3082c91203be,0,0/0_2/407c5203d10d8292,4048500000000000/ false false
+add - -53/0/0/0/8000000000000000/3/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/40604004a9d7483e/40b503444cc93a83/2/0_3/403a000000000000,405a000000000000,3f42a75d20f7697d///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/40604004a9d7483e/40b503444cc93a83/3/0_1/40604004a9d7483e///4024000000000000 false true
+add - 8/3fe0000000000000/0/4067e4008418500a/c0b502c51d66f42c/3/-16_4/4051000000000000,0,3f10830a0142b9b2,405ec80000000000/// 5/0/0/405ff00d603457a4/40b09328eff9a629/3/2_3/405b280000000000,4033200000000000,3f4ac068af48a865/// => 5/3fe0000000000000/0/4073ee039a193dee/c091be70b5b5380c/3/-2_2,2_3/4051000000000000,405ec8010830a014,405b280000000000,4033200000000000,3f4ac068af48a865/// false false
+add - -53/0/0/4050080c14bbe762/40a468ba5bd1816d/0/1_3/404d900000000000,4014000000000000,3f482977cec39f38///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4058000ad81e8dc3/c09f8224355fe28e/2/1_3/4058000000000000,0,3f45b03d1b86b359///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4064040b766d3a92/40829ea104864098/0/1_3/4063640000000000,4014000000000000,3f56ecda75252948///3ff0000000000000,4000000000000000,4014000000000000 false false
+add - 1/3f50624dd2f1a9fc/0/4071be03488d8d1e/c0c08ab305c26eb9/3/8_4,1_1/4058000000000000,3f4a446c68f06b9f,405cb80000000000,4040000000000000,4044800000000000/// 5/3fe0000000000000/4054400000000000/4054400000000000/c0936e01f22c8051/2///// => 1/3fe0000000000000/4054400000000000/4076ce03488d8d1e/c0c2f8734407fec3/3/8_4,1_1/4058000000000000,3f4a446c68f06b9f,405cb80000000000,4040000000000000,4044800000000000/// false false
+add - -53/0/0/0/0/3/1_1/0///4000000000000000 -53/0/0/0/8000000000000000/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/3/////4000000000000000 false true
+add - 1/0/3f30c5d69eff53e9/404e8055c10eba07/40aef4afca067dd8/0/-19_1,0_4/3f4d40516c35ed27,3f4cf1ce2fdff7c2,404e800000000000,0,3f432c03ce710e7e/// 1/3f847ae147ae147b/4056400000000000/4056400000000000/408ee8a8e4ccb3ef/0///// => 1/3f847ae147ae147b/4062c0157043ae82/4062c0157043ae82/40b3576d019cd56a/0///// false false
+add - -4/3f847ae147ae147b/3f4ea1d4b624b721/405f181160a0514a/40b537010d7a78af/1/5_3,0_2/4034000000000000,4024000000000000,3f207dafb1bebc4a,4022000000000000,4055580000000000/// -2/0/0/406b840422b24da1/c0b12a9d436b2765/2/-10_1,1_3/4042000000000000,4057000000000000,3f408ac936847aee,4057080000000000/// => -4/3f847ae147ae147b/406b840bcb277b2a/4075880669813b23/4090318f283d4528/0/5_3,0_2/4034000000000000,4024000000000000,3f207dafb1bebc4a,4022000000000000,4055580000000000/// true false
+add - -53/0/0/4031000000000000/40922f337ddf8855/2/0_2/401c000000000000,4024000000000000///4000000000000000 -53/0/0/0/0/1/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/4031000000000000/40922f337ddf8855/0/0_1/4031000000000000/// true true
+add - -4/255bba08cf8c979d/4054980000000000/407aae01c887d5b1/40c2f59a640da627/3/-8_2/4057400000000000,4057000000000000/-11_1,2_3,1_2/4041800000000000,3f3c887d5b0ba885,4024000000000000,4057900000000000,4034400000000000,0/ 3/255bba08cf8c979d/0/406684078751de55/40b021bd0db6c56b/2/-4_1,1_3/3f442f2876d30172,3f33dc3e0502f50e,404e000000000000,4034000000000000/-14_4/4004000000000000,0,4032a00000000000,4053c00000000000/ => -4/255bba08cf8c979d/4054980000000000/4082f802c618626e/40cb0678eae908dc/3/-8_2,6_1/4057400000000000,4057000000000000,4054000f0ea3bcaa/-11_1,2_3,1_2,2_1/4041800000000000,3f3c887d5b0ba885,4024000000000000,4057900000000000,4034400000000000,0,4059080000000000/ false false
+add - -53/0/0/4056800000000000/c0a42c3a24992490/3/1_1/4056800000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/8000000000000000/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4056800000000000/c0a42c3a24992490/3/1_1/4056800000000000///3ff0000000000000,4014000000000000 false true
+add - 3/3f50624dd2f1a9fc/0/0/8000000000000000/2///// 1/255bba08cf8c979d/4042800000000000/4064400000000000/40c17db05f9352db/2/5_2/4052000000000000,404a800000000000/// => 1/3f50624dd2f1a9fc/4042800000000000/4064400000000000/40c17db05f9352db/2/5_2/4052000000000000,404a800000000000/// false false
+add - 8/0/4041800000000000/4077fe0000000000/c0a03248b903c091/2///7_4,1_4,0_2/0,4008000000000000,4042700000000000,4050000000000000,404a800000000000,4018000000000000,404f800000000000,0,4044800000000000,4054800000000000/ 0/255bba08cf8c979d/0/4075ac0000000000/40bfecb8fb20a162/2/-7_4,2_1/4030000000000000,4050300000000000,4056c00000000000,4050000000000000,4041000000000000/-1_1/4053400000000000/ => 0/255bba08cf8c979d/4041800000000000/4086d50000000000/40b7d3949e9ec11a/2/-7_4,2_1/4030000000000000,4050300000000000,4056c00000000000,4050000000000000,4041000000000000/-1_1,1_1/4053400000000000,4075ce0000000000/ false false
+add - -53/0/0/0/0/1/////4000000000000000 -53/0/0/0/0/3/0_1/0///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/3///// false true
+add - 8/3f847ae147ae147b/4015800000000000/406ddc0000000000/c0a5815c3d927048/3/-16_3/4051e00000000000,4050400000000000,4058400000000000/// 5/3f50624dd2f1a9fc/0/4056000000000000/40a7226d44737120/3/-19_3,0_1/4022000000000000,0,0,4053c00000000000/// => 5/3f847ae147ae147b/4015800000000000/40746e0000000000/406a11106e100d80/3/-19_4,13_2/4022000000000000,0,0,4053c00000000000,4051e00000000000,4064400000000000/// false false
+add - 0/3f847ae147ae147b/0/4046000000000000/409bb050531a3593/1/-9_3/4031000000000000,401c000000000000,4034000000000000/// 8/3f50624dd2f1a9fc/0/0/8000000000000000/2///// => 0/3f847ae147ae147b/0/4046000000000000/409bb050531a3593/0/-9_3/4031000000000000,401c000000000000,4034000000000000/// true false
+add - -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/3f3fea6b2b7afe27/3f774581aa45ddbf/1/1_1/3f3fea6b2b7afe27///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/3f3fea6b2b7afe27/3f774581aa45ddbf/0/0_1/3f3fea6b2b7afe27///3fe0000000000000 true true
+add - -1/3f50624dd2f1a9fc/0/407340081d836431/c0b0d0c82322ef14/3/-18_4,1_3/404a800000000000,0,4044800000000000,4046800000000000,3f4ca538f7a8d972,0,0/5_3,2_4/3f34e20fa021b1c7,404d000000000000,4042000000000000,404a000000000000,3f49d5da59ce4063,4037000000000000,0/ -4/0/4025400000000000/4056280000000000/4084cf51b1344737/1/-14_1/4053800000000000/// => -4/3f50624dd2f1a9fc/4056280000000000/4078ca081d836431/c0ac6dbbd9f8cc5a/3/-2_2/4057800000000000,4046801ca538f7a9/1_2/405780053883e808,4052c00ceaed2ce7/ false false
+add - -1/255bba08cf8c979d/4048900000000000/40802808cec5ea87/40c7d723a0875b44/2/-1_2,2_4,0_2/4050c00000000000,3f43596096ef1b3d,3f4c95c5751150e3,3f3a4b3e1847ee0c,3f4bffaa7ef8f17a,4042000000000000,405ea00000000000,4035a00000000000/-14_3,1_3/4043c00000000000,4046800000000000,3f49e794703699f8,4051900000000000,3f49f05aa117ac54,4050800000000000/ 8/255bba08cf8c979d/3f4ebf88edf17bac/3f4ebf88edf17bac/3f811836b1929199/2///// => -1/255bba08cf8c979d/4048901ebf88edf1/4080280ababe7966/40c7d724b20ac65d/2/-1_2,2_4,0_2/4050c00000000000,3f43596096ef1b3d,3f4c95c5751150e3,3f3a4b3e1847ee0c,3f4bffaa7ef8f17a,4042000000000000,405ea00000000000,4035a00000000000/-14_3,1_3/4043c00000000000,4046800000000000,3f49e794703699f8,4051900000000000,3f49f05aa117ac54,4050800000000000/ false false
+add - -4/3f50624dd2f1a9fc/0/405f400000000000/40b915fbe8f547d2/0/-4_1,2_2,0_1/4050c00000000000,4022000000000000,4048800000000000,0/// 8/3fe0000000000000/4043800000000000/404380114fcd9378/c0862029411704f4/1/-2_1/3f414fcd93781939/// => -4/3ff0000000000000/4064800453f364de/4064800453f364de/40b651f6c0d26734/0///// false false
+add - -4/3f847ae147ae147b/0/4060800000000000/40b95be022a82b91/1/-3_1,2_3/0,4048800000000000,4033000000000000,4050000000000000/// -4/3f847ae147ae147b/0/0/8000000000000000/3///// => -4/3f847ae147ae147b/0/4060800000000000/40b95be022a82b91/3/-3_1,2_3/0,4048800000000000,4033000000000000,4050000000000000/// false false
+sub - -53/0/0/4031000000000000/408334cab1c64430/2/1_1/4031000000000000///4000000000000000 -53/0/0/4037000000000000/4093d404028be48a/1/0_1/4037000000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/c018000000000000/c084733d535184e4/0/0_1/c018000000000000/// true true
+sub - 5/3f50624dd2f1a9fc/404e800000000000/4074c204014bef7c/40b3089c9d09e59d/2/7_4/4057600000000000,403b000000000000,4028000000000000,3f50052fbdf18640/-6_2,1_3/0,4055400000000000,404ad00000000000,0,0/ 2/255bba08cf8c979d/0/40656c0bcc3b147e/40c05007f1527b0e/2/7_2,2_1,1_2/3f4c7cffa4dc649e,404a800000000000,3f42b3ecad1acdba,0,405d980000000000/// => 2/3f50624dd2f1a9fc/404e800000000000/406417fc365cca7a/c0ab2ee68b3620fe/2/1_2,4_2,2_1,1_2/405e200000000000,40280080297def8c,bf4c7cffa4dc649e,c04a800000000000,bf42b3ecad1acdba,8000000000000000,c05d980000000000/0_1/4061540000000000/ false false
+sub - -1/3fe0000000000000/0/4058400000000000/40b728014367bfcc/1/0_1/4058400000000000/// 1/3f847ae147ae147b/0/407d4203ac059cc2/c0be5e4f15ebc66a/0/-3_3,2_1,1_4/4008000000000000,3f478b9521bd6bd8,3f27525f11469851,4041000000000000,4036e00000000000,4043000000000000,4047100000000000,4057000000000000/-15_2,2_4/0,4038000000000000,405d080000000000,403e000000000000,0,404f000000000000/ => -1/3fe0000000000000/c06d6405e2e5486f/c0773203ac059cc2/40cac3282ca9c31b/0/0_3/40577ff14fe98cf8,c04c700000000000,c066040000000000/// false false
+sub - -53/0/0/0/0/2/////4000000000000000 -53/0/0/4056400000000000/40b07b798aab5411/2/0_1/4056400000000000///4000000000000000 => -53/0/0/c056400000000000/c0b07b798aab5411/2/0_1/c056400000000000///4000000000000000 false false
+sub - -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/402a00c7a92424a6/407c1b331635e8a5/1/1_2,0_2/4018000000000000,3f501b3e31459781,3f41b3cca69e8f7f,401c000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/c02a00c7a92424a6/c07c1b331635e8a5/3/0_3/c018000000000000,bf58f5248494df40,c01c000000000000///3ff0000000000000,4014000000000000 false true
+sub - 1/3f847ae147ae147b/4018000000000000/408210002fd0058a/c092ddd52214fba6/0/-4_3/4056400000000000,4057200000000000,4054300000000000/-20_3,2_1,1_1/4054800000000000,405ef00000000000,4053400000000000,403b000000000000,3f17e802c4e58a72/ 1/0/4040800000000000/4069400574272fba/40c290688928ce06/3/2_3,2_1/403a000000000000,4059000000000000,3f45d09cbee7531e,4045800000000000/// => 1/3f847ae147ae147b/c03b000000000000/40777ffda58c7337/c0c4ec232d6b6d7b/3/-4_3,3_3,2_1/4056400000000000,4057200000000000,4054300000000000,c03a000000000000,c059000000000000,bf45d09cbee7531e,c045800000000000/-20_3,2_1,1_1/4054800000000000,405ef00000000000,4053400000000000,403b000000000000,3f17e802c4e58a72/ false false
+sub - -53/0/0/4070b80000000000/4084e22b9529fa40/0/0_3/4055c00000000000,4052400000000000,405ae00000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/4070b80000000000/4084e22b9529fa40/0/0_1/4070b80000000000/// false true
+sub - 2/3f847ae147ae147b/0/4070560194b5f8b0/c0ae32461b24c413/3/-9_1,0_2,0_3/403b000000000000,4052980000000000,3ef736427aec65cb,404e800000000000,4055800000000000,402a000000000000/-19_1/3f37d7fb6348642e/ 5/0/3f4c9244d3cdcfa8/3f4c9244d3cdcfa8/3fad92e4dea982d1/3///// => 2/3f847ae147ae147b/bf4c9244d3cdcfa8/407055fe026d5e36/c0ae3263ae09a2bd/3/-9_1,0_2,0_3/403b000000000000,4052980000000000,3ef736427aec65cb,404e800000000000,4055800000000000,402a000000000000/-19_1/3f37d7fb6348642e/ false false
+sub - -53/0/0/0/8000000000000000/2/////4000000000000000 -53/0/0/0/8000000000000000/0/////4000000000000000 => -53/0/0/0/0/0/////4000000000000000 false false
+sub - 0/0/403e000000000000/4065c001ca334fca/40bd5f662b85a18e/1/2_3,0_1,0_2/4010000000000000,0,402a000000000000,3f2ca334fc9d0c48,404b800000000000,4052000000000000/// 1/3f847ae147ae147b/0/4075800c800e7845/c0bf657d319c1ca4/0/-5_4,0_1,2_2/4053400000000000,3f43cbb79a15e86c,4053000000000000,403d000000000000,3f1aa338fd6123b5,4058c00000000000,0/0_1,1_4,2_1/402e000000000000,4048000000000000,3f4b40c642512eca,0,3f4d45e7224bfaa4,3f4459a7a3cfa9cf/ => 0/3f847ae147ae147b/403e000000000000/c065401735e9a0c0/40ce6271ae90df19/0/-2_4,0_1,1_4/c0534009e5dbcd0b,c05a400000000000,bf1aa338fd6123b5,c058c00000000000,4010000000000000,402a000000000000,3f2ca334fc9d0c48,404b800000000000,4052000000000000/0_5/c02e000000000000,c048000000000000,bf4b40c642512eca,bf4d45e7224bfaa4,bf4459a7a3cfa9cf/ false false
+sub - -53/0/0/0/8000000000000000/0/////4000000000000000 -53/0/0/4054580000000000/40b50a2196cf348e/1/0_3/4051c00000000000,4024c00000000000,0///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/c054580000000000/c0b50a2196cf348e/0/0_1/c054580000000000/// false true
+sub - -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/8000000000000000/1/0_1/0///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/0/0_1/8000000000000000///3ff0000000000000,4000000000000000,4014000000000000 false false
+sub - -1/3f50624dd2f1a9fc/4014000000000000/40821001f41a39b1/c0caef438a509d96/2/-14_4,2_2,1_4/404c000000000000,3f278af099e6ca93,4054800000000000,3f016a2fcfb0f7ba,4026000000000000,4056400000000000,4048000000000000,403f000000000000,4054800000000000,403a000000000000/4_4/4053000000000000,4024000000000000,404f000000000000,3f48484477a30b27/ -53/0/0/4038000000000000/c078d8b6f0b54486/3/0_1/4038000000000000///3ff0000000000000,4014000000000000,4024000000000000 => error
+sub - -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 5/0/0/4072840000000000/40a6b6466e54b41d/1/-6_1,0_1,2_3/4056000000000000,0,4050680000000000,4051680000000000,4052400000000000/// => error
+sub - 8/255bba08cf8c979d/404f800000000000/4076400000000000/c0c3e4a427980441/2/-19_2/4043600000000000,4056380000000000/-1_2/4047000000000000,405dd80000000000/ 0/3f847ae147ae147b/4055000000000000/4066200000000000/40a3883b26f8e10f/0///-3_1/4057400000000000/ => 0/3f847ae147ae147b/c035000000000000/4066600000000000/c0c8c6b2f1563c85/0/0_1/405fe80000000000/-3_1,2_1/c057400000000000,4064ac0000000000/ false false
+sub - -53/0/0/0/0/3/////4000000000000000 -2/3f847ae147ae147b/0/40627c0daec15e02/40c384e202da3d5b/1/6_4,0_2,1_4/0,3f26d1557a8b7820,3f3171044971b246,0,4031e00000000000,3f3c5cf87b431f00,404f000000000000,0,3f4a1fb1b70c16a4,4051000000000000/// => error
+sub - 1/3f50624dd2f1a9fc/0/40746c0000000000/c09593f5ac82d9ff/2/2_2,2_3/403ac00000000000,4057800000000000,4045000000000000,4014000000000000,4050400000000000/4_2,1_1,1_1/0,4043000000000000,404c000000000000,0/ 3/255bba08cf8c979d/0/0/0/0///// => 1/3f50624dd2f1a9fc/0/40746c0000000000/c09593f5ac82d9ff/0/2_2,2_3/403ac00000000000,4057800000000000,4045000000000000,4014000000000000,4050400000000000/4_2,1_1,1_1/0,4043000000000000,404c000000000000,0/ false false
+sub - -2/255bba08cf8c979d/0/407dbc00e946de20/40ce4d4e88069d5d/1/8_4/4055700000000000,3edc28edcbb809af,4058c00000000000,0/-3_4,0_2/4052000000000000,3f2c479455a3adc1,4055400000000000,4050000000000000,4045000000000000,403c000000000000/ 1/3fe0000000000000/3f4060196c39dbc6/4074dc03749c3854/40d3dd65670859e1/3/-20_1,0_4/4055000000000000,403ac00000000000,3f2c841b999b9311,4054000000000000,3f208f05c015b4ce/-17_1,0_3/404f000000000000,4022000000000000,4050000000000000,4020000000000000/ => -2/3ff0000000000000/c05c300a497e569c/4061bffae9554b98/c0b2daf88c142cca/3/8_3/4055700000000000,3edc28edcbb809af,4058c00000000000/1_2/4045000000000000,403c000000000000/ false false
+sub - -1/3f847ae147ae147b/4054400000000000/4054400000000000/40b5cad8a3e10b2a/1///// -2/3f50624dd2f1a9fc/0/0/0/1///// => -2/3f847ae147ae147b/4054400000000000/4054400000000000/40b5cad8a3e10b2a/1///// false false
+sub - 2/3f50624dd2f1a9fc/0/4073960360d28bb7/c09c3bd0f8c1ce69/0/-8_3,2_3,0_1/4040000000000000,4053000000000000,3f46b3fd373c815d,4041000000000000,4059f00000000000,4050e80000000000,3f214a5c99ed3c4d/// -2/255bba08cf8c979d/4059b00000000000/4080e20000000000/409d3f3eb7c26fa4/1/-3_2/4049800000000000,4051400000000000/-13_1,0_2,2_3/404c000000000000,0,404e000000000000,404b400000000000,404b800000000000,4057000000000000/ => -2/3f70000000000000/c080e20000000000/c06c5bf93e5ae892/c0acbd87d8421f06/0/0_1/4073960360d28bb7/// false false
+sub - -1/0/0/4060000000000000/40b5db79eeb5f98d/2/3_2,0_3/4026000000000000,4058800000000000,402e000000000000,0,4010000000000000/// 5/0/0/4046000f6c5b7f2f/4092412763b3c3ec/0/-10_1,1_2,0_2/3f3ed8b6fe5d9447,0,0,4038000000000000,4034000000000000/// => -1/0/0/4054fff849d24068/40b14b3015c90892/0/0_1,2_2,0_3/c046000f6c5b7f2f,4026000000000000,4058800000000000,402e000000000000,0,4010000000000000/// false false
+sub - 2/3f847ae147ae147b/0/4060600431d1e858/40ae735bd016c109/0/-13_3/4057800000000000,4042800000000000,3f40c747a1604042/// -53/0/0/0/0/2/////bff0000000000000,0,3fe0000000000000,4024000000000000 => error
+sub - -53/0/0/4064c00303becfe1/c0b25f64110ef469/1/0_1,2_2/4054400000000000,4055400000000000,3f381df67f040922///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/4064c00303becfe1/c0b25f64110ef469/3/0_2/4054400000000000,40554006077d9fc1///3fe0000000000000 false true
+sub - -53/0/0/0/8000000000000000/1/0_1,0_1/0,0///4000000000000000 -53/0/0/0/0/0/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/8000000000000000/0///// false true
+sub - 3/0/4022000000000000/4066200f72bebe39/409489b80a469c64/2/6_4/403f000000000000,4050800000000000,4046800000000000,403a000000000000/5_3/3f44f997513cce5e,3f4ac67cf9c26db6,3f3c15cd5bca1ed8/ 0/3f50624dd2f1a9fc/3f4a579be70a4719/405d08230bd68d4a/40a9c2dd0afbdcd8/3/-6_1,1_2,1_4/4009000000000000,4053400000000000,0,3f42e4cccb7c2861,4042000000000000,0,3f48db44680e916e/// => 0/3f50624dd2f1a9fc/4021ff96a19063d7/404e6ff7b34dde50/c09efc020bb11d4c/3/-6_1,1_2,1_2,0_2/c009000000000000,c053400000000000,8000000000000000,bf42e4cccb7c2861,c042000000000000,4061c00000000000,4039ffce49772fe3/1_1/3f5ee57d7c7225c0/ false false
+sub - 1/0/0/4073f80000000000/40d0e786e3c7d590/2/-7_3,0_1,0_4/4031000000000000,402e000000000000,0,4057800000000000,4045000000000000,4045500000000000,4031000000000000,4056f80000000000/// 2/0/0/407470063d996299/40d2604d6bb31a99/1/7_1,2_4,1_4/4010000000000000,3f322474ebd72c31,0,4031000000000000,404a000000000000,4040800000000000,3f22e10f20bd5186,404b200000000000,3f47d33bc5c4e2be/-10_1,0_2,2_2/4031000000000000,4037000000000000,4013800000000000,405e780000000000,3f389e2221d2cc4d/ => 1/0/0/c01e018f6658a640/c0978c687eb45090/0/-7_3,0_1,0_4,3_6/4031000000000000,402e000000000000,0,4057800000000000,4045000000000000,4045500000000000,4031000000000000,4056f80000000000,c010000000000000,bf322474ebd72c31,c031000000000000,c04a000000000000,c0408004b843c82f,c04b2017d33bc5c5/-5_2,1_1/c031000000000000,c03be00000000000,c05e780627888875/ true false
+sub - 0/3f50624dd2f1a9fc/0/406f040000000000/40b7be4d3c339fd3/0///-2_3/404d100000000000,4057800000000000,4058000000000000/ -1/3fe0000000000000/0/40724c016a8f3116/40c8a8398a1443ba/1/-7_4,1_3/4047800000000000,0,4046000000000000,4050800000000000,3f36a8f3116490b6,4043800000000000,4058300000000000/// => -1/3fe0000000000000/4063040000000000/c046500b547988b0/c0b99225d7f4e7a1/0/0_1/c058300000000000/0_1/4058000000000000/ false false
+sub - 0/3fe0000000000000/0/4077c40000000000/40d0f2d0e4f890e2/2/4_4,1_3/4051c00000000000,4058c00000000000,4042200000000000,404c000000000000,0,4040800000000000,4055400000000000/// 0/0/0/405da021c21780e7/409e515fb3703038/1/-6_1,1_4,2_1/3f338d56124eaddc,3f37d16e9274c046,405da00000000000,3f3082e4e3970794,3f4a13907440fa59,3f36ff9392be4917/// => 0/3fe0000000000000/c05da01c02329c37/40705bf78f7a1fc6/40ce1b75d3831bbd/0/2_1,1_4,1_3/bf36ff9392be4917,4051c00000000000,4058c00000000000,4042200000000000,404c000000000000,0,4040800000000000,4055400000000000/// true false
+sub - -53/0/0/4058000000000000/40a41b8e86fd0e9a/1/1_1/4058000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4039000000000000/409678f16152b180/1/0_1/4039000000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4051c00000000000/4091be2baca76bb4/1/0_1/4051c00000000000///3ff0000000000000,4000000000000000,4014000000000000 false true
+sub - -53/0/0/404a000000000000/40ab3c3260b12014/0/1_2/4034000000000000,4040000000000000///3ff0000000000000,4000000000000000,4014000000000000 -2/255bba08cf8c979d/4049800000000000/4049800000000000/408b92cd399fcad6/1///// => error
+sub - 5/3f50624dd2f1a9fc/0/4081400000000000/c0876ab539131e4b/0/-17_2,0_2/4049800000000000,4056600000000000,404b000000000000,403b000000000000/-17_2,2_4,0_1/4045000000000000,0,402c000000000000,4030000000000000,405ea00000000000,4052400000000000,404f800000000000/ -4/3fe0000000000000/0/406e3c04dcbe9db2/c0b0211f8c33b256/1/5_2,1_1/4034200000000000,404ce00000000000,4043800000000000/4_3,0_1,0_2/404c800000000000,0,0,3f4372fa76c879b3,0,4051000000000000/ => -4/3fe0000000000000/0/407361fd91a0b127/40aa6791ca229d19/0/0_1,4_2,1_1/406bb00000000000,c034200000000000,c04ce00000000000,c043800000000000/0_1,3_6/4074a80000000000,c04c800000000000,8000000000000000,8000000000000000,bf4372fa76c879b3,8000000000000000,c051000000000000/ false false
+sub - -53/0/0/0/8000000000000000/1/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/402ac00000000000/4084815b37078686/1/0_1/402ac00000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/c02ac00000000000/c084815b37078686/1/0_1/c02ac00000000000///3fe0000000000000 false true
+sub - 0/3f50624dd2f1a9fc/0/4050800c8552915d/c05ecd6a44660034/2/-7_4/0,4049000000000000,4030000000000000,3f490aa522ba303d/// 3/255bba08cf8c979d/4054c00000000000/40725202d355de40/40b2c4f9133aa3b9/1///5_3,0_2/403d000000000000,0,4056c00000000000,3f469aaef1ffbea8,4056880000000000/ => 0/3f50624dd2f1a9fc/c054c00000000000/c06c63ff640273d2/c0b3402ebc4c3bba/0/-7_4/0,4049000000000000,4030000000000000,3f490aa522ba303d/1_2/c05e000b4d577900,c056880000000000/ true false
+sub - 2/255bba08cf8c979d/4010000000000000/4054c00798fcca3c/40b2306d0191aa1a/0/-12_3/3f3e63f328ede380,4053c00000000000,0/// 0/255bba08cf8c979d/4014000000000000/4067f8051a990ce7/40a4cf164926e798/2/1_1,2_3,1_1/0,4059700000000000,3f446a64339b4c83,0,4055400000000000/// => 0/255bba08cf8c979d/bff0000000000000/c05b30029c354f92/409f238773f8d938/0/-3_2,2_1,2_3,1_1/3f3e63f328ede380,4053c00000000000,8000000000000000,c059700000000000,bf446a64339b4c83,8000000000000000,c055400000000000/// false false
+sub - -53/0/0/4000000000000000/404b31792da8034f/0/1_1/4000000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/4067e00000000000/409fe7ee0d884baf/2/1_3/4056400000000000,4033000000000000,4054c00000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/c067a00000000000/c09f0e62441b0b95/0/1_2/c05a800000000000,c054c00000000000///3ff0000000000000,4014000000000000 false true
+sub - 0/0/0/4071c00730555055/40af320cbf6bf7d6/1/-4_2,1_3,0_3/4051000000000000,3f4783cebba72ac4,3f46a7b2c376a240,3f30bee3f5e3a079,4056800000000000,3f17bdb844ce37bc,4056000000000000,4043000000000000/// -53/0/0/0/0/1/////4000000000000000 => error
+sub - -53/0/0/0/8000000000000000/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/////4000000000000000 => -53/0/0/0/8000000000000000/3/////4000000000000000 false true
+sub - 2/3f847ae147ae147b/403e000000000000/403e000000000000/4092c9d844a782b0/2///// 1/3fe0000000000000/4054800000000000/40814400a1f40832/40b94754ec9f6610/3/-16_4,1_4/4010000000000000,3f343e81064bd15a,405e900000000000,4050000000000000,4056800000000000,0,4057900000000000,4058000000000000/// => 1/3fe0000000000000/c04a000000000000/c0805400a1f40832/c0b494dedb758564/3///// false false
+sub - -2/0/0/40648404f5d2bd27/40c13157d0f289fb/3/-1_4,0_4/3f43d74af49ce657,4056400000000000,0,0,0,3ff0000000000000,0,4038a00000000000/8_3/0,4048c00000000000,0/ 8/3f50624dd2f1a9fc/402c000000000000/402c000000000000/40843f9056a872b7/2///// => -2/3f50624dd2f1a9fc/c02c000000000000/4062c404f5d2bd27/40bfdabd9710059f/3/-1_2,3_1,1_1/3f43d74af49ce657,4056400000000000,3ff0000000000000,4038a00000000000/9_1/4048c00000000000/ false false
+sub - 1/255bba08cf8c979d/0/40735408b16a2de1/c0911b98e1465c53/0/-19_2/4054400000000000,3f1a8add5ef1de86/-13_2,1_4,2_4/0,4057c00000000000,3f3e10ea93ce64f3,3f48a341b761446c,4044800000000000,3f22d37524698bc0,4028000000000000,4054100000000000,3f45d96178c8810c,0/ -2/255bba08cf8c979d/4002000000000000/406e480000000000/40c79155fbc55395/1/7_2,2_2/4052400000000000,0,4056c00000000000,4053000000000000/// => -2/255bba08cf8c979d/c002000000000000/4050c022c5a8b784/c0c9b4c917ee1f1f/0/-2_1,8_2,2_2/40544001a8add5ef,c052400000000000,8000000000000000,c056c00000000000,c053000000000000/-1_2/40610009eaedc052,4057100d471f60f1/ false false
+sub - -2/0/0/4065a00b975b46cc/40c2d453984b6978/0/-14_4,0_3/3f3f238eb98d29b6,4051400000000000,0,404a000000000000,3f4ecba5be6b0c73,403b400000000000,4038c00000000000/// 0/0/0/0/0/0///// => -2/0/0/4065a00b975b46cc/40c2d453984b6978/0/-14_4,0_3/3f3f238eb98d29b6,4051400000000000,0,404a000000000000,3f4ecba5be6b0c73,403b400000000000,4038c00000000000/// false false
+sub - -53/0/0/3f3cd042ec7b9216/bf69e751aa54e7d2/3/0_1/3f3cd042ec7b9216///4000000000000000 -53/0/0/3f473ec994330a97/3f66749944fcdf58/2/0_1/3f473ec994330a97///4000000000000000 => -53/0/0/bf31ad503bea8318/bf782df577a8e395/3/0_1/bf31ad503bea8318///4000000000000000 false false
+sub - -4/3f847ae147ae147b/0/4056400b15003785/c048d6495881aa90/2/2_2/3f462a006f0a87c4,4056400000000000/// -1/255bba08cf8c979d/0/40883d02338a25d9/40d3096e181182ba/1/-6_4,1_4/4055c00000000000,402e000000000000,4041f00000000000,4058000000000000,0,4054400000000000,404fe00000000000,4049800000000000/7_4,1_4,2_2/0,404c800000000000,3f48242d973a3aab,4055000000000000,401c000000000000,4054800000000000,4035000000000000,3f3628e98caab0f6,4057c00000000000,0/ => -4/3f90000000000000/c06d3c0000000000/c0857500d0ea1ee8/c0d315d93cbdc38f/0/0_2,0_2/c073ae0000000000,c05cb00000000000,3f462a006f0a87c4,4056400000000000/1_3/c04c800000000000,c0684008ce289763,c057c00000000000/ true false
+sub - 1/3f847ae147ae147b/4033000000000000/406a7c0737e3d430/40c31ea9066f55b8/1/-4_4,1_1,1_3/4050c00000000000,4039e00000000000,0,0,4057c00000000000,4008000000000000,4000000000000000,3f4cdf8f50c1ba26/// 8/255bba08cf8c979d/405c100000000000/406e2804b8f607ca/40b3bfaf6b2b6505/1/8_2,2_3/404d800000000000,4049000000000000,4034000000000000,0,3f42e3d81f28c428/// => 1/3f847ae147ae147b/c057500000000000/c03d5fec08919cd0/40b27da2a1b3466b/1/-4_4,1_1,1_3/4050c00000000000,4039e00000000000,0,0,c0410012e3d81f28,4008000000000000,4000000000000000,3f4cdf8f50c1ba26/// false false
+sub - -4/0/0/0/8000000000000000/1/-16_2/0,0/// 8/3f847ae147ae147b/0/406e00059a8ef492/4083f8cc3ac55f25/3/1_2,0_2,2_2/404e800000000000,3f466a3bd249e807,4043800000000000,403e000000000000,4054c00000000000,403b000000000000/// => -4/3f847ae147ae147b/0/c06e00059a8ef492/c083f8cc3ac55f25/3/1_1/c06e00059a8ef492/// false false
+sub - 5/0/4035000000000000/4061b00000000000/40b600d7c9ccc02c/3/9_1,2_4/401e000000000000,0,404b800000000000,0,404d000000000000/// 1/3f847ae147ae147b/4051400000000000/4079500000000000/40d6801e0d945c6a/3/7_4,1_2,2_2/4058400000000000,0,4052c00000000000,4037000000000000,0,4041800000000000,404f000000000000,4046000000000000/// => 1/3f847ae147ae147b/c048000000000000/c070780000000000/c0d0ffe81b212c5f/3/1_1,5_4,1_2,2_2/405e200000000000,c058400000000000,8000000000000000,c052c00000000000,c037000000000000,8000000000000000,c041800000000000,c04f000000000000,c046000000000000/// false false
+sub - 8/255bba08cf8c979d/0/3f1b116b044b6448/bf64a5376b8ed139/0/2_1/3f1b116b044b6448/// 1/255bba08cf8c979d/0/405a5815abb8f97c/40b5ee5d1cabe6bf/0///-9_4,0_3/3ff6000000000000,4043800000000000,3f33c9f63124be63,0,4050400000000000,3f0e2ebc162d27c0,3f4f8f8b1904b90c/ => 1/255bba08cf8c979d/0/c05a5813faa24937/c0b5ee5dc1d5a21b/0/1_1/3f1b116b044b6448/-9_7/bff6000000000000,c043800000000000,bf33c9f63124be63,8000000000000000,c050400000000000,bf0e2ebc162d27c0,bf4f8f8b1904b90c/ false false
+sub - 5/3f847ae147ae147b/0/4064c80000000000/4097b8bf6e652102/1/-4_1,1_4/0,405a900000000000,4048000000000000,4028000000000000,0/// -1/3f50624dd2f1a9fc/4047d00000000000/4069b4039790be58/40b5ffa7f46dddd5/0/-2_1,0_1,2_2/4051c00000000000,3f3cbc85f2bb9fa5,4052c00000000000,4028000000000000/// => -1/3f847ae147ae147b/c047d00000000000/c043b00e5e42f960/c0b0117818d49594/0/-2_2,0_4/c051c00000000000,bf3cbc85f2bb9fa5,4064c80000000000,0,c052c00000000000,c028000000000000/// false false
+sub - -53/0/0/4059200000000000/c0a255ddd414c46e/2/0_1/4059200000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/8000000000000000/1/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/4059200000000000/c0a255ddd414c46e/0/0_1/4059200000000000///3ff0000000000000,4014000000000000,4024000000000000 true false
+sub - -53/0/0/0/0/1/////4000000000000000 -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/0///// true true
+sub - -4/0/0/0/0/1///// 3/3f50624dd2f1a9fc/4051800000000000/4070e003fc50ee5f/c0a4732cee1e719f/1/1_2,1_3,1_1/3f4fe28772f9d584,0,4056c00000000000,4057000000000000,0,4031000000000000/// => -4/3f50624dd2f1a9fc/c051800000000000/c070e003fc50ee5f/40a4732cee1e719f/1/1_1/c0690007f8a1dcbe/// false false
+sub - 2/3fe0000000000000/0/0/0/0///// 0/3f847ae147ae147b/0/4075100000000000/40a922d1d58a0fc7/1/-3_1/403e000000000000/4_4,1_2/4057000000000000,402e000000000000,4053c00000000000,403f000000000000,403c000000000000,404f000000000000/ => 0/3fe0000000000000/c03e000000000000/c075100000000000/c0a922d1d58a0fc7/0///4_4,1_2/c057000000000000,c02e000000000000,c053c00000000000,c03f000000000000,c03c000000000000,c04f000000000000/ false false
+sub - -53/0/0/0/8000000000000000/0/////4000000000000000 -53/0/0/3f4a003019c5e8d4/3fa1b611275090ab/1/1_1/3f4a003019c5e8d4///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/bf4a003019c5e8d4/bfa1b611275090ab/0/0_1/bf4a003019c5e8d4/// false true
+sub - 0/255bba08cf8c979d/0/405c180000000000/40bbc4ac2d6e1e3f/2///7_4,2_1/0,405bd80000000000,3ff0000000000000,0,0/ -1/3f847ae147ae147b/0/407f4c053cc5ff9e/40c08f72fddb9024/1/1_4,1_4/404b800000000000,4031000000000000,4037000000000000,4030000000000000,4053800000000000,4059f00000000000,0,3f32d88b882021b1/5_1,0_3,2_4/0,3f4ca2efc5d75dc1,4041800000000000,4045000000000000,4040b00000000000,4058680000000000,0,3f1eb7d3985fbe64/ => -1/3f847ae147ae147b/0/c07846053cc5ff9e/c09568e739240824/0/1_4,1_4/c04b800000000000,c031000000000000,c037000000000000,c030000000000000,c053800000000000,c059f00000000000,8000000000000000,bf32d88b882021b1/4_5,2_4/405bd80000000000,3ff0000000000000,bf4ca2efc5d75dc1,c041800000000000,c045000000000000,c040b00000000000,c058680000000000,8000000000000000,bf1eb7d3985fbe64/ true false
+sub - -1/0/0/4082e3016f099d12/40d284f205ac28f4/1/-13_3,2_2,1_3/4043000000000000,403c000000000000,4054400000000000,3f46f099d1209a69,4044000000000000,4047c00000000000,4056c00000000000,4051000000000000/-1_2,2_2/405d680000000000,4041a00000000000,4028000000000000,4047000000000000/ 3/3fe0000000000000/0/4056400000000000/40abf8dde17ea9ab/1///-8_3/0,4056400000000000,0/ => -1/3ff0000000000000/407c9602de133a24/40801b016f099d12/40ce0bac92f8a77d/1///3_2/4028000000000000,4047000000000000/ false false
+sub - -53/0/0/4049000000000000/40a57900eb29895d/3/1_1/4049000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4051380000000000/c0962fe07f4326eb/0/0_2/4051380000000000,0///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/c032e00000000000/40b0487895658e69/3/0_1/c032e00000000000/// false true
+sub - -2/0/404e000000000000/404e000000000000/c0976969038261be/1///// 0/3f847ae147ae147b/402e000000000000/406aac0000000000/4033244f204469af/3/-10_1,0_1,2_3/4034000000000000,0,4026c00000000000,4054800000000000,4055400000000000/// => -2/3f847ae147ae147b/4046800000000000/c0632c0000000000/c097b5fa40037365/3/-1_1/c0664c0000000000/// false false
+sub - -2/3f847ae147ae147b/0/407a40056ef85ad2/40da56f4bfcddb4b/2/-11_1,0_1,2_3/4058000000000000,0,4053c00000000000,3f491b9532fcc7ab,4056c00000000000/0_1,0_3,2_3/402e000000000000,0,4000000000000000,4056c00000000000,3f259e251caca455,4047000000000000,3f39e948b8d2eed1/ -2/0/0/4052000000000000/40a34efff68750c8/3/-7_1/4052000000000000/// => -2/3f847ae147ae147b/c052000000000000/4075c0056ef85ad2/40d7ed14c0fcf132/3/-11_1,0_1,2_3/4058000000000000,0,4053c00000000000,3f491b9532fcc7ab,4056c00000000000/0_1,0_3,2_3/402e000000000000,0,4000000000000000,4056c00000000000,3f259e251caca455,4047000000000000,3f39e948b8d2eed1/ false false
+sub - -53/0/0/403ae00000000000/c078c0b1b2ddd0f5/2/0_2/403ae00000000000,0///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/8000000000000000/3/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/403ae00000000000/c078c0b1b2ddd0f5/3/0_1/403ae00000000000///3ff0000000000000,4014000000000000 false true
+sub - -1/3f847ae147ae147b/3f3901215f1bbbce/4035c01901215f1c/4093a1cd08ee51c5/3/-18_2/4026000000000000,4025800000000000/// -4/3fe0000000000000/401c000000000000/4076b6033bf3d52a/40d5f567f82c5d0a/1///2_2,1_4/3f49df9ea94e3651,4058800000000000,4055400000000000,4058000000000000,4051180000000000,4022000000000000/ => -4/3fe0000000000000/402d80320242be38/c0755a01abe1bf38/c0d4bb4b279d77ee/3///2_2,1_4/bf49df9ea94e3651,c058800000000000,c055400000000000,c058000000000000,c051180000000000,c022000000000000/ false false
+sub - 8/3fe0000000000000/0/0/0/0///// 2/3fe0000000000000/0/4071c803f73bb127/40cfb2abb58be2c6/3/-19_3,2_4,1_3/0,403f000000000000,0,4018000000000000,4055000000000000,3f4fb9dd89382514,0,4044800000000000,405ea00000000000,0/// => 2/3fe0000000000000/0/c071c803f73bb127/c0cfb2abb58be2c6/3///// false false
+sub - -53/0/0/403e800000000000/409655d405cefcbc/0/1_1/403e800000000000///4000000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/403e800000000000/409655d405cefcbc/0/0_1/403e800000000000/// false true
+sub - -53/0/0/0/0/3/////4000000000000000 5/3f847ae147ae147b/4055800000000000/40719c02e63ab006/409501ce0c04334a/2/-7_2,0_4/0,3f4731d5802fa1c2,0,4042000000000000,4049300000000000,405b580000000000/// => error
+sub - 8/255bba08cf8c979d/4055800000000000/4055800000000000/409c4e23493950e2/0///// -4/3f847ae147ae147b/404b800000000000/4075e0036695e821/40d73c1781e25cd0/0/7_2,2_4/4043600000000000,0,4058900000000000,4054000000000000,3f4b34af4106d9f9,4053800000000000/// => -4/3f847ae147ae147b/403f000000000000/c07080036695e821/c0d577354d4ec7c2/0/7_2,2_4/c043600000000000,8000000000000000,c058900000000000,c054000000000000,bf4b34af4106d9f9,c053800000000000/// false false
+sub - -53/0/0/4054800000000000/40b60ff04c6c3ed9/1/0_1/4054800000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4054800000000000/40b60ff04c6c3ed9/0/0_1/4054800000000000///3ff0000000000000,4014000000000000 false true
+sub - 8/255bba08cf8c979d/4051980000000000/4072e00000000000/40bc9a7136a3a549/1///-4_2,1_4,1_1/0,403f000000000000,404a800000000000,4022000000000000,4051c00000000000,4005000000000000,4050400000000000/ 8/0/0/4080cc018e0e49d8/c0bbddbf127c8a65/0/-13_2,0_4/403d000000000000,403b600000000000,3f279380362863bd,403d000000000000,4055c00000000000,4055c00000000000/9_2,2_3,0_4/0,0,4050b80000000000,0,404a800000000000,3f42fc048feddf27,4034000000000000,4057800000000000,4046200000000000/ => 8/255bba08cf8c979d/4051980000000000/c06d700638392760/40cc3c18249017d7/0/-13_6/c03d000000000000,c03b600000000000,bf279380362863bd,c03d000000000000,c055c00000000000,c055c00000000000/-4_2,1_4,1_1,4_2,2_7/0,403f000000000000,404a800000000000,4022000000000000,4051c00000000000,4005000000000000,4050400000000000,8000000000000000,8000000000000000,c050b80000000000,8000000000000000,c04a800000000000,bf42fc048feddf27,c034000000000000,c057800000000000,c046200000000000/ false false
+sub - 8/3fe0000000000000/0/4075a004d13b0e04/40d4627bbba61bc3/0/-19_3,1_3/0,404c800000000000,3f26a55e114c5d7b,4038000000000000,4000000000000000,404d000000000000/-6_4,2_1,2_3/3f3dfecf5532a549,4037000000000000,403c000000000000,3f37a53952c1b5d1,3f2839f25f3f1e31,4056c00000000000,404f800000000000,0/ -53/0/0/406fd407852e1f2e/c088654c24f2fe63/3/0_1,0_2,1_1/4059680000000000,3f4e14b87cb64bd6,4057400000000000,404e000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => error
+sub - -4/3fe0000000000000/0/0/0/3///// 0/0/3f423a946c0c7d7b/4083f101ee032b15/40e1caaeca09c140/0/6_2,0_1,1_3/4026000000000000,404f800000000000,4055000000000000,4054400000000000,0,4058000000000000/3_2,2_3,1_4/404f200000000000,4045000000000000,4026000000000000,403b800000000000,4033000000000000,405c180000000000,0,3f394b3c8a746fe8,403d000000000000/ => -4/3fe0000000000000/bf423a946c0c7d7b/c083f101ee032b15/c0e1caaeca09c140/3/1_1/c074f00000000000/1_1/c072f20194b3c8a7/ false false
+sub - 5/3f50624dd2f1a9fc/0/406f7408759c18c5/40c2a0b40e6e24c3/0/2_3,2_2/3f4b34e5cf71cd3b,0,0,4041000000000000,0/8_3,0_2/4043d00000000000,4058000000000000,403e000000000000,3f2a862a4e8d0249,404a000000000000/ 8/0/0/4060600657e28dff/40bd58692ac0771d/1/5_4/4056c00000000000,3f495f8a37fcfcce,0,4044000000000000/// => 5/3f50624dd2f1a9fc/0/405e28043b73158c/409fa3fbc86f49a4/0/1_4,2_2/c060600657e28dff,3f4b34e5cf71cd3b,0,0,4041000000000000,0/8_3,0_2/4043d00000000000,4058000000000000,403e000000000000,3f2a862a4e8d0249,404a000000000000/ false false
+sub - -53/0/0/4064c00000000000/40c5f481d0e06f36/0/1_2/4052000000000000,4057800000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/40630000829e4529/c0920a68ee745174/3/0_3/4057000000000000,404e000000000000,3f1053c8a512a3fb///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/402bfff7d61bad70/40c835ceeeaef964/3/0_3/c057000000000000,4028000000000000,40577ffefac375af///3ff0000000000000,4000000000000000,4014000000000000 false false
+sub - 0/3fe0000000000000/0/4075d00000000000/40d58eb0ca327384/0/-19_1,1_4,2_1/405b800000000000,403a000000000000,4056080000000000,4053c00000000000,4046f00000000000,0/// 2/3fe0000000000000/0/4072f80000000000/40cd23814d7ec6b4/3///5_3,0_2,0_1/405b200000000000,4050000000000000,0,404e800000000000,404b000000000000,4030000000000000/ => 0/3fe0000000000000/0/4046c00000000000/40bbf3c08dcc40a8/3/-19_1,1_4,2_1/405b800000000000,403a000000000000,4056080000000000,4053c00000000000,4046f00000000000,0/2_2/c06d300000000000,c051800000000000/ false false
+sub - 3/3f50624dd2f1a9fc/0/4064000000000000/40c34de6940ec8ca/3/-19_2/4058400000000000,404f800000000000/// 2/0/4053800000000000/40864e0160a46c78/40d4fc566c20e1fe/3/9_1,2_4,2_1/4026000000000000,4046000000000000,4052c00000000000,4055c00000000000,4044000000000000,404bb00000000000/0_2,1_4,0_2/3f39be77ab6e7c67,3f325615e3a6fca1,4055000000000000,4055400000000000,4038000000000000,0,4031000000000000,405c580000000000/ => 2/3f50624dd2f1a9fc/c053800000000000/c0814e0160a46c78/c0c6aac64432fb32/3/-9_1,17_1,2_4,2_1/4064000000000000,c026000000000000,c046000000000000,c052c00000000000,c055c00000000000,c044000000000000,c04bb00000000000/0_2,1_6/bf39be77ab6e7c67,bf325615e3a6fca1,c055000000000000,c055400000000000,c038000000000000,8000000000000000,c031000000000000,c05c580000000000/ false false
+sub - -53/0/0/0/8000000000000000/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/3f3aa9164b5e6cd9/bf82bea8a8a077e4/0/0_2/3f3aa9164b5e6cd9,0///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/bf3aa9164b5e6cd9/3f82bea8a8a077e4/0/0_1/bf3aa9164b5e6cd9///3ff0000000000000,4000000000000000,4014000000000000 false true
+sub - -1/3f847ae147ae147b/4058c00000000000/408e800000000000/40ed8249f57d153d/3/7_1,1_1,1_4/4052c00000000000,4023400000000000,405a080000000000,405d300000000000,4053c80000000000,404c800000000000/0_1,2_3,2_2/404c800000000000,4054000000000000,404f100000000000,4057000000000000,4056000000000000,404c200000000000/ 3/3f50624dd2f1a9fc/0/4044001c34efeecb/40960f6ec2e3270b/0/3_1/3f4c34efeecae292/-11_1/4044000000000000/ => -1/3f847ae147ae147b/4058c00000000000/408d3ffe3cb10113/40ecd1ce7f65fc05/3/1_1,5_1,1_1,1_4/bf4c34efeecae292,4052c00000000000,4023400000000000,405a080000000000,405d300000000000,4053c80000000000,404c800000000000/0_1,2_3,2_2/4031000000000000,4054000000000000,404f100000000000,4057000000000000,4056000000000000,404c200000000000/ false false
+sub - 5/3fe0000000000000/0/4052000b6e53b54d/c07235c0ab71066c/3/3_2/4052000000000000,3f46dca76a9a91b0/// 8/0/0/0/0/3///// => 5/3fe0000000000000/0/4052000b6e53b54d/c07235c0ab71066c/3/3_2/4052000000000000,3f46dca76a9a91b0/// false false
+sub - 1/3f847ae147ae147b/0/40670007bf7b2886/c09c3c49bfbc1495/2/-8_4/3f4efdeca217c6ab,4054000000000000,4057000000000000,4028000000000000/// -2/3fe0000000000000/4058280000000000/4071380000000000/40b54b4d9887a331/1/5_3/4049900000000000,0,404ce00000000000/9_3/0,4047800000000000,4037000000000000/ => -2/3fe0000000000000/4055d80f7ef6510c/c056dff08109aef4/c0bc5a600876a856/0/5_3/c049900000000000,8000000000000000,c04ce00000000000/9_3/8000000000000000,c047800000000000,c037000000000000/ true false
+sub - 3/3f50624dd2f1a9fc/0/4071d20277faadb7/40cecf597c863069/1/0_4/4041d00000000000,0,4054c80000000000,402c000000000000/-18_4,2_4/0,0,0,4054000000000000,4018000000000000,404e200000000000,4018800000000000,3f43bfd56dbb58aa/ 0/0/0/4075940000000000/40a0cbf82a9d4197/1///5_3,2_1,2_3/4000000000000000,4044000000000000,4028000000000000,0,405f200000000000,4053c00000000000,4055f00000000000/ => 0/3f50624dd2f1a9fc/0/c04e0fec402a9248/40ca9c5b71dee003/1/0_2/4041d00000000000,4058480000000000/-2_2,5_3,2_1,2_3/0,40630c04eff55b6f,c000000000000000,c044000000000000,c028000000000000,8000000000000000,c05f200000000000,c053c00000000000,c055f00000000000/ false false
+sub - -2/3fe0000000000000/0/40704c0453c8e6f8/40a2cf996330f46b/3/6_3/4034e00000000000,0,403d000000000000/0_3,0_1,1_4/0,404c800000000000,3f418ca394a29793,3f4111a3a322ec6c,403f000000000000,0,4043700000000000,4055000000000000/ 2/3f50624dd2f1a9fc/3f320095b9df8f6d/3f320095b9df8f6d/3f8d356e8b764ef5/1///// => -2/3fe0000000000000/bf320095b9df8f6d/40704c0333bf8b5a/40a2cf9215d5518d/3/6_3/4034e00000000000,0,403d000000000000/0_3,0_1,1_4/0,404c800000000000,3f418ca394a29793,3f4111a3a322ec6c,403f000000000000,0,4043700000000000,4055000000000000/ false false
+sub - 2/0/0/406354036629d68b/c095b1eaa3efab2d/1/-10_2/405f280000000000,3f3b314eb4587cc2/-15_3/0,403e000000000000,0/ -1/3fe0000000000000/3f062309f7106a09/406c8c0f1798a47e/c06ffd21cbbc17c1/1/-18_3,1_1,2_3/404ac00000000000,3f4727a7701c59cc,4039000000000000,3f2901ecd2596a19,4032000000000000,4007000000000000,3f4d940f4dd4f474/1_2/4050400000000000,4050000000000000/ => -1/3fe0000000000000/406354030d9daeaf/c052701762dd9be6/c091b2466a782835/1///1_2/c050400000000000,c050000000000000/ false false
+sub - 0/3fe0000000000000/4052d80000000000/4084320000000000/c0d04698abcf7b83/2/-5_2,0_3/4058400000000000,4022000000000000,4028000000000000,404f000000000000,4053400000000000/-20_4,1_4/405e280000000000,4051000000000000,0,4044000000000000,4010000000000000,4054500000000000,0,0/ -4/255bba08cf8c979d/0/4048000000000000/409875f9482a9e00/1/8_1,0_1/4048000000000000,0/// => -4/3fe0000000000000/4052d80000000000/4082b20000000000/c0d1cdf840522563/0/0_1,7_2/4070100000000000,c048000000000000,8000000000000000/-1_2/406c940000000000,4055500000000000/ true false
+kahan - -53/0/0/4053f00b74f32685/40aa57a12b90457c/3/1_1,0_1/3f46e9e64d0ad140,4053f00000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/4054c00000000000/40ac8515812fd236/3/1_3/4037000000000000,404e000000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4061400739ab505c/c0986613c3263a50/3/1_3,0_1/404c000000000000,3f4ce6ad416dd961,4020000000000000,4052800000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/3f42576196c02c2a/3f91d95032ea5153/0/0_2/3f32d0501eed4a32,3f31de730e930e22///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/4072cc08c4fea4a7/40b554dadbea8a00/3/0_1/4072cc08c4fea4a7/// -53/0/0/3d11615000000000/bd5aead000000000/3/0_1/3cfad96000000000/// false true
+kahan - 3/3f50624dd2f1a9fc/3f2000fe50353fba/407974029bd65691/407652219500ddf4/1/-6_3,0_3/4341c37937e08000,0,4341c37937e08000,3fd3333333333333,3fd3333333333333,4341c37937e08000/-10_1,1_2/0,3fd3333333333333,3fd3333333333333/ -53/3f70624dd2f1a9fc/0/0/0/1/////3ff0000000000000,4014000000000000,4024000000000000 5/0/4034000000000000/4051b00000000000/40b0a8c218389bc2/2/-16_1/4049600000000000/// -1/3f847ae147ae147b/0/4073700000000000/406df6dc099fd87b/3/-7_4,2_2/4052c00000000000,4050c00000000000,4014000000000000,4052c00000000000,4000000000000000,4055c00000000000/// => error
+kahan - 0/255bba08cf8c979d/0/405c080000000000/40b2c452e2ba36e9/3///-8_1,0_2/3fd3333333333333,3ffb333333333333,4341c37937e08000/ 1/257bba08cf8c979d/0/40743c0625eed67d/40c58a0e5a7bd783/0/-12_2,0_2/0,0,0,4341c37937e08000/-10_1,0_4,0_2/4341c37937e08000,4341c37937e08000,4341c37937e08000,4341c37937e08000,0,3ffb333333333333,3ffb333333333333/ 0/3f847ae147ae147b/0/407bb203a746b044/40d1db475d58f8bf/3/-4_3,2_3,1_4/402e000000000000,4055400000000000,405bf00000000000,4040000000000000,405ee80000000000,403d000000000000,0,3f1e9225ac9c4f60,4047600000000000,3f4967f0cc904174/// => 0/3f90000000000000/4341c37937e08001/408b7804e69ac360/40e0a8b1a1a2b91e/3/-4_3,2_3,1_4/4341c37937e08008,4055400000000000,405bf00000000000,4040000000000000,405ee80000000000,403d000000000000,0,3f1e9225ac9c4f60,4047600000000000,3f4967f0cc904174/-5_4/4341c37937e08000,4351c37937e08000,4341c37937e08000,400b333333333333/ 0/3f90000000000000/bca0000000000000/3d30000000000000/bd94000000000000/3/-4_3,2_3,1_4/bff0000000000000,0,0,0,0,0,0,0,0,0/-5_4/0,0,0,0/ false false
+kahan - -1/3fe0000000000000/0/0/8000000000000000/3///// 8/4000000000000000/0/405dd0018b1f3e3c/40abe9b9b2491f02/0/-1_3,2_3/3ffb333333333333,0,4341c37937e08000,3fd3333333333333,4341c37937e08000,3fd3333333333333/// => -1/4000000000000000/0/405dd0018b1f3e3c/40abe9b9b2491f02/3/1_1/4351c37937e08000/// -1/4000000000000000/0/0/0/3/1_1/3fe3333333333333/// false false
+kahan - 5/3fe0000000000000/3f400bb9d23408f2/404be0100bb9d234/4069c3011b8adc21/1/-1_1/404be00000000000/// 0/3fe0000000000000/0/4059000000000000/c09a5b9a9bbc35f2/1/2_2/4026000000000000,4056400000000000/// -4/3fe0000000000000/0/407d060000000000/40c33d233f6dc264/1/-11_4,1_4,0_1/403e600000000000,4055800000000000,4045800000000000,4054800000000000,4047800000000000,404f000000000000,4057000000000000,4036000000000000,0/// -1/255bba08cf8c979d/3f39c631221ca6a3/4060400c24feb430/c0a8a5666ea2a93e/1/-8_4,2_1,1_1/3f367fd7264368e4,4050000000000000,0,0,0,0/-9_2,2_1,2_2/4020000000000000,4002000000000000,3fe8000000000000,3f4870f6ac90023d,404b800000000000/ => -4/3fe0000000000000/4060401027ed28bd/4087710409fb4a2f/40b45ec4a977798d/1/0_2/405df00000000000,4059000000000000/0_1/404be01870f6ac90/ -4/3fe0000000000000/3cc2f28000000000/3d20000000000000/3d61000000000000/1/0_2/0,0/0_1/3c91e80000000000/ false false
+kahan - 5/255bba08cf8c979d/0/4010000000000000/c05b6a15c679e000/1/-3_1/4010000000000000/// 2/0/0/4064f408cd100553/c0b238bdd8a7082e/3/-2_4,0_3,0_3/3f4c3bb44807485e,3f1d3c6874ce99f4,0,3f01172060e0af5a,405e280000000000,402e000000000000,4020000000000000,0,3f11fc65c4e101e1,4038000000000000/// 0/3fe0000000000000/0/40833f049983c059/c0bb5e4cc6b3959f/2/-4_4,2_2,2_1/0,404e800000000000,4041000000000000,4050b80000000000,3f4e067e9dc8ae65,4056000000000000,4047800000000000/-4_4,1_2,2_2/4056c00000000000,4055400000000000,3f4c8c1f6fe6a48a,4047000000000000,3f3e0b3befc73137,401c000000000000,4050400000000000,4039000000000000/ => 0/3fe0000000000000/0/40889c06ccc7c1ae/c0c702597b3a42a6/3/0_4,2_1/401000ff1a0ab509,4061f400445c8184,403800408c16acc9,4056000000000000,4047800000000000/1_2,2_2/3f3e0b3befc73137,401c000000000000,4050400000000000,4039000000000000/ 0/3fe0000000000000/0/bd20000000000000/bd70000000000000/3/0_4,2_1/bca18e0000000000,bd0f50a600000000,3ce3a84800000000,0,0/1_2,2_2/0,0,0,0/ false false
+kahan - 1/0/0/4064980000000000/40baaf156afe59c6/2///7_3,1_4/0,3ffb333333333333,0,3ffb333333333333,3ffb333333333333,4341c37937e08000,0/ 1/0/4051800000000000/4074c40000000000/40be8da8ea51b811/0/-6_3/3fd3333333333333,3fd3333333333333,0/-20_2/3ffb333333333333,0/ 0/3fe0000000000000/3f31ed69c45ee7dc/406f48023dad388c/40a7da4cf555ca06/3/-4_1,1_1,0_4/0,405a500000000000,0,4048800000000000,0,4058000000000000/// 5/0/4048000000000000/4077f003790e8d0c/c0804cbf8a6ebd3a/3/-17_3,2_1/0,3f4bc874685e49b3,4014000000000000,4052000000000000/-9_2,0_2/4056000000000000,4037000000000000,4050800000000000,4054400000000000/ => 0/3fe0000000000000/405e1337ae8da44b/4091a90125f94a54/40d0c81337ab47cd/3/0_3/405f800de43a342f,0,4058000000000000/0_1,3_1,1_2/4070200000000000,3ffb333333333333,400b333333333333,4341c37937e08000/ 0/3fe0000000000000/bcd4090000000000/3d40000000000000/bd74000000000000/0/0_3/3ce26cc000000000,0,0/0_1,3_1,1_2/0,0,0,0/ false false
+kahan - 3/0/4056c00000000000/405e800000000000/40a2a3864855c89d/1/-9_1/0/// -1/3f70624dd2f1a9fc/0/4053400000000000/40b215de07e83243/2/-20_1/0/// => -1/3f70624dd2f1a9fc/4056c00000000000/4068e00000000000/40bb67a12c131692/0///// -1/3f70624dd2f1a9fc/0/0/bd60000000000000/0///// true false
+kahan - 0/3f847ae147ae147b/0/40782e03b295e805/40cef420a0372d07/3/5_3,0_4,0_2/4052400000000000,4055c00000000000,4038e00000000000,4014000000000000,0,4054c00000000000,404b000000000000,0,0/2_2/404e000000000000,3f4d94af402806ab/ 1/3fe0000000000000/0/4074e003b394568e/40a887d0dd38e514/2/-16_2,1_4/4058c00000000000,4037000000000000,4046800000000000,4051400000000000,4058800000000000,3f4d9ca2b4707a54/// -1/3fe0000000000000/0/4071160000000000/40bc17f0b16a0324/1/0_4,2_3/404d000000000000,404b600000000000,4055c00000000000,0,4047500000000000,403b000000000000,0/// 1/3f847ae147ae147b/0/4070b80396d8bd4b/c0b7f9dfc637bb69/3/-20_4,1_3,0_1/4054c00000000000,0,4039000000000000,3f126d8a76225189,0,0,3f4a69149b96d8f5,4057600000000000/9_1/4050800000000000/ => -1/3fe0000000000000/406930072db17a97/4093b702bf40bef8/40d3928ea68f4515/3/0_3,0_6/404d000000000000,404b600000000000,4055c00000000000,4064000000000000,403de00000000000,4054c00000000000,4059280000000000,403b000000000000,0/1_3/404e000000000000,3f4d94af402806ab,4050800000000000/ -1/3fe0000000000000/bcfb9b3c00000000/bd40000000000000/bd70000000000000/3/0_3,0_6/0,0,0,0,0,0,0,0,0/1_3/0,0,0/ false false
+kahan - 2/3f847ae147ae147b/4053a80000000000/4053a80000000000/c092629206aed73a/0///// -4/4000000000000000/0/406d201aa40ed65e/40ae084041b2e056/3/-2_4,0_1,0_2/3ffb333333333333,4341c37937e08000,3ffb333333333333,0,3fd3333333333333,4341c37937e08000,3ffb333333333333/-4_3,0_1,2_3/4341c37937e08000,3ffb333333333333,3fd3333333333333,3ffb333333333333,0,3ffb333333333333,3ffb333333333333/ => -4/4000000000000000/4053a80000000000/40737a0d52076b2f/40a4d6f73e5b74b9/3/1_4/0,3fd3333333333333,4341c37937e08000,3ffb333333333333/2_3/0,3ffb333333333333,3ffb333333333333/ -4/4000000000000000/0/0/0/3/1_4/0,0,0,0/2_3/0,0,0/ false false
+kahan - -4/3f50624dd2f1a9fc/0/406bec0da61e3900/40b348f3c5ba5b8c/0/-10_3,2_2/3fd3333333333333,0,0,4341c37937e08000,3fd3333333333333/// 1/3f70624dd2f1a9fc/404d000000000000/406d0002dfa014f0/40ca7c75f1e1a7bd/2/7_1,0_3/4341c37937e08000,4341c37937e08000,3fd3333333333333,3ffb333333333333/3_1/4341c37937e08000/ => -4/3f70624dd2f1a9fc/4341c37937e0801d/407c760842df26f8/40d21077ea5f6ac2/0/1_1/4351c37937e08000/1_1/4341c37937e08000/ -4/3f70624dd2f1a9fc/3fe3333333333333/0/bd80000000000000/0/1_1/4000000000000000/1_1/0/ false false
+kahan - 5/3f847ae147ae147b/0/4068700e2c02a3f6/c0b61a4cc47034ed/3/5_4/0,0,3fd3333333333333,0/-19_3/0,0,3fd3333333333333/ 3/3fa47ae147ae147b/0/4075080000000000/40c645391355cbed/2/-10_1,1_4,2_4/3ffb333333333333,0,3fd3333333333333,3fd3333333333333,0,3fd3333333333333,3ffb333333333333,3ffb333333333333,4341c37937e08000/// -2/3f847ae147ae147b/0/4078d202cf2a3cb4/40d31dd3f23ca90c/1/-2_4,0_4,1_2/405f080000000000,4057000000000000,403f000000000000,4032000000000000,3f2f4c1c1a63cf0c,3f3c06e9f511f407,0,4044800000000000,3ef45abc8fc3b5c5,4056c00000000000/// => -2/3fb0000000000000/406b040000000000/408d0904f295c758/40d8b9dd4acb81c7/3/0_6,1_2/4042800000000000,4341c37937e08009,3f2f4c1c1a63cf0c,3f3c06e9f511f407,0,4044800000000000,3ef45abc8fc3b5c5,4056c00000000000/0_1/3fd3333333333333/ -2/3fb0000000000000/0/bd30000000000000/3d70000000000000/3/0_6,1_2/bca8000000000000,3fd3333333333333,0,0,0,0,0,0/0_1/0/ false false
+kahan - 8/0/0/0/0/0///// 5/0/3f3b1490ded99edc/405d78072c6427c4/40a8758bec74f637/3/8_3/4043000000000000,3ef9cffc03305c04,4053f80000000000/// 1/3f847ae147ae147b/4026000000000000/4026000000000000/4025be081ee59979/0///// 3/255bba08cf8c979d/0/0/8000000000000000/3///// => 1/3f847ae147ae147b/402600362921bdb3/40601c03963213e2/40a88b49f493dbd0/3/1_1/405d7800673ff00d/// 1/3f847ae147ae147b/3cbedc0000000000/0/3d4e400000000000/3/1_1/bcef47f800000000/// false false
+kahan - 8/255bba08cf8c979d/0/406b38027cec5a68/4090f3845916d626/1/4_1,1_2,1_3/4050400000000000,3f0134798fe20196,403a000000000000,4055800000000000,4044600000000000,3f31c0d3a13e7235/// 2/3f847ae147ae147b/3ec0419708da2bd8/4084f101495193bd/40dc8e71efbdbbd6/1/7_4,0_4,1_4/0,402e000000000000,403f000000000000,4052800000000000,4036000000000000,4055c00000000000,402a000000000000,4051400000000000,4054800000000000,4053d00000000000,4055000000000000,0/-11_2,2_4/3f4484d7a4d236a2,4029000000000000,4015000000000000,0,4030200000000000,4054000000000000/ 2/3fe0000000000000/0/0/0/1///// -2/255bba08cf8c979d/4024000000000000/4054e00000000000/c0808fa16440fc19/3/-9_2/4051600000000000,4010000000000000/// => -2/3fe0000000000000/4068ac0525464ef7/408e5b01e88caa57/40dd192d2a2d2157/3/1_2/408316009f3b169a,4064680000000000/// -2/3fe0000000000000/bcfde64500000000/0/3d83000000000000/1/1_2/bd15366100000000,0/// false false
+kahan - 0/3fe0000000000000/0/4049000000000000/c08be8bf22d35e2b/1/-17_1/3fd3333333333333/// -53/4000000000000000/0/40671808219af25c/40bec254fe533d23/1/1_3/3ffb333333333333,3fd3333333333333,4341c37937e08000///3ff0000000000000,4000000000000000,4014000000000000 => error
+kahan - -53/0/0/4064340000000000/c0b08ba536db1c82/3/1_3/0,4046800000000000,405d280000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/2/////4000000000000000 -53/0/0/0/0/2/////bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/8000000000000000/1/0_1/0///4000000000000000 => -53/0/0/4064340000000000/c0b08ba536db1c82/3/0_1/4064340000000000/// -53/0/0/0/0/3/0_1/0/// false true
+kahan - 3/3f50624dd2f1a9fc/0/4068040000000000/40c925aa4fecc465/0/-2_3,2_4/0,3fd3333333333333,4341c37937e08000,3fd3333333333333,3ffb333333333333,0,0/// -53/3f70624dd2f1a9fc/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 -2/0/0/4076580000000000/c043b0b7adb2e3fa/3/-5_2,0_3/4048000000000000,4057000000000000,4053200000000000,4058000000000000,4046800000000000/// -1/3f50624dd2f1a9fc/0/407d4001d744587b/40c8ce384151d453/2/-3_2,2_1,1_4/4052000000000000,403e000000000000,0,4052800000000000,4057c00000000000,4055800000000000,3f3d744587ad8d57/-14_3/401c000000000000,4046000000000000,404e000000000000/ => error
+kahan - -53/0/0/0/8000000000000000/2/////bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/0/1/////4000000000000000 -53/0/0/4066800000000000/40b6c9972f45f348/0/0_2/4055c00000000000,4057400000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4037000e467c3a39/c072d1d510e18e6c/2/0_2/3f2c8cf874715a01,4037000000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/40696001c8cf8747/40b59c79de37da61/0/0_1/40696001c8cf8747/// -53/0/0/3cf0000000000000/3d50000000000000/0/0_1/3ce5a01000000000/// true true
+kahan - -4/3f50624dd2f1a9fc/3f4e2f90712ad929/407f760711bd2776/c0c8c160d300ba10/0/-6_4,1_3,0_4/4341c37937e08000,0,4341c37937e08000,3fd3333333333333,3fd3333333333333,3fd3333333333333,4341c37937e08000,4341c37937e08000,4341c37937e08000,3fd3333333333333,3fd3333333333333/// 1/3f70624dd2f1a9fc/0/0/8000000000000000/3///// -1/3f50624dd2f1a9fc/4028000000000000/4028000000000000/c05b2ebe802a2174/3///// => -4/3ff0000000000000/4351c37937e08003/40801b0388de93bb/c0c8f7be50010e53/3/1_5/4341c37937e08000,4341c37937e08000,4341c37937e08000,3fd3333333333333,3fd3333333333333/// -4/3ff0000000000000/3fecd458b0e91784/0/3d48000000000000/3/1_5/0,0,0,0,0/// false false
+kahan - 3/3fe0000000000000/4056400000000000/4076240595c20b07/c0a3320ae9c75dd0/0/-1_2,0_4,2_4/3fd3333333333333,3fd3333333333333,0,4341c37937e08000,3ffb333333333333,4341c37937e08000,0,3ffb333333333333,4341c37937e08000,4341c37937e08000/-2_2/4341c37937e08000,0/ -4/4000000000000000/4008000000000000/405e480000000000/40ac39957489cadc/2/0_4/0,4341c37937e08000,4341c37937e08000,4341c37937e08000/// 1/3fe0000000000000/4028c00000000000/405a1806382cd5e4/c07a8dba16f74d64/2/1_1,1_4/0,4051c00000000000,3f38e0b3579185d0,0,4035000000000000/// 2/3f847ae147ae147b/4044000000000000/4044000000000000/4097401413b79d12/1/-3_1/0/// => -4/4000000000000000/435aa535d3d0c025/40835e0391e6a040/40a155dd51bf51e8/0/1_3/435aa535d3d0c017,4341c37937e08000,4341c37937e08000/// -4/4000000000000000/3fd7fffffffffffe/0/3d50000000000000/0/1_3/3f38e0b3579185d0,0,0/// false false
+kahan - 0/0/0/4060c002fc0655e8/40b957268469ccca/3/-8_4,0_2/4054000000000000,0,0,3f37e032af439e2b,0,404b000000000000/// -4/3f847ae147ae147b/3f415e12c3092762/4070c8022bc25861/40cf2d0d79e604e6/1///-9_2,2_2,0_2/0,402e000000000000,404ec00000000000,4053800000000000,403a000000000000,4056000000000000/ => -4/3f847ae147ae147b/40540008af096185/40792803a9c58355/40d5ec505e0d75a6/3/0_1/404b000bf01957a2/// -4/3f847ae147ae147b/bcfb13c000000000/0/bd80000000000000/3/0_1/bcd8754000000000/// false false
+kahan - 2/3f50624dd2f1a9fc/0/0/8000000000000000/0///// 2/3fe0000000000000/3f43a7b6c779c779/4052f011321bb6dc/40a6738dab0de185/3///-20_4/4041e00000000000,3f3d79014c7a9449,0,4044000000000000/ 8/3fe0000000000000/0/4063800000000000/40c283832895078b/0/-11_4/4045800000000000,4041800000000000,4039000000000000,404a800000000000/// 3/3fe0000000000000/0/0/8000000000000000/0///// => 2/3fe0000000000000/3f43a7b6c779c779/406cf808990ddb6e/40c8206693587fec/3/0_1/4063800000000000/// 2/3fe0000000000000/0/0/3d60000000000000/3/0_1/0/// false false
+kahan - 8/0/0/407df002c913da33/40e04cc9b3fe19d2/1/-4_1,0_4/402c000000000000,404c800000000000,4056000000000000,404f800000000000,4054000000000000/9_4/4056000000000000,4052400000000000,4030000000000000,3f46489ed1963624/ 8/3f847ae147ae147b/0/0/0/3///// -1/3f50624dd2f1a9fc/0/4080c400f83ac15c/40e0825379ca2b8a/1/-4_4,2_3,0_4/0,403b000000000000,4058000000000000,4058000000000000,0,4050d80000000000,4056480000000000,4033000000000000,3f3f07582b71bf67,4046000000000000,4058800000000000/// => -1/3f90000000000000/403b000000000000/408fbc025cc4ae76/40f0678e96e422ae/3/-2_2,0_1,1_7/4058000000000000,4058000000000000,4072e00000000000,0,4050d80000000000,4056480000000000,4033000000000000,3f3f07582b71bf67,4046000000000000,4058800000000000/1_1/406620059227b466/ -1/3f90000000000000/0/bd30000000000000/0/3/-2_2,0_1,1_7/0,0,0,0,0,0,0,0,0,0/1_1/bd0c9dc000000000/ false false
+kahan - 1/3fe0000000000000/4056c00000000000/407ce60000000000/40d07c96089f4a78/0/2_2,0_4,2_1/4037000000000000,404a000000000000,403c000000000000,4058800000000000,404c800000000000,4042000000000000,4053580000000000/// -53/0/0/406f880000000000/40cf67de00395bb2/3/1_3,0_1/404b000000000000,4039400000000000,4058400000000000,4053000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 2/0/0/40721c0000000000/c0a30d8ba68931c2/2/2_2,2_4/4053c00000000000,4046600000000000,4042000000000000,4024000000000000,4052000000000000,4048000000000000/// 1/3f50624dd2f1a9fc/4040000000000000/4076c20856f99a60/c0ba10ef77759d30/3/-14_4,1_4/4056c00000000000,4055800000000000,4053000000000000,3f24581a4272d5fe,4053c80000000000,3f4d71d8b93ff506,3f5017f6c490a10b,0/// => error
+kahan - -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/0/////3ff0000000000000,4014000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000 false true
+kahan - -53/0/0/40524004b4496ae7/c08cd0651840066e/1/0_1,0_1/3f32d125ab9bb498,4052400000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/8000000000000000/1/////4000000000000000 -53/0/0/405ca80000000000/4070910fa14cbeb5/1/1_2/4034000000000000,4057a80000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/406774025a24b574/c08487dd4799a714/1/0_1/406774025a24b574/// -53/0/0/bd10000000000000/3d30000000000000/1/0_1/bd112da000000000/// false true
+kahan - -2/3f847ae147ae147b/4055400000000000/4077e0004be87ddb/c0c22b533ef2b381/0/-5_4,0_2/0,0,4341c37937e08000,4341c37937e08000,3fd3333333333333,0/// -1/3fa47ae147ae147b/0/40628c01e81fb298/c0a551a86ba21867/2/-14_2,0_3,2_1/0,3ffb333333333333,3fd3333333333333,4341c37937e08000,3fd3333333333333,3ffb333333333333/0_2/3ffb333333333333,3fd3333333333333/ -1/0/0/4068200c43d44b8c/c0a39b121c4bb94b/1/0_4,1_2,2_1/3f1fd44787c173e6,4035000000000000,3f3a1cf1628f53f7,4049800000000000,4010000000000000,3f500327c5f8d22a,405d400000000000/// 3/255bba08cf8c979d/0/405c4008f5e74c6e/c08451816bde0d3c/0/-1_1/3f41ebce98dce596/-7_3,0_1/0,403c000000000000,4055400000000000,0/ => -2/3fb0000000000000/435aa535d3d0c016/408a2304cfae2805/c0cdab99f7ac08c2/0/0_4,1_1/3f45e65789d51413,4035001a1cf1628f,4049800000000000,40100100327c5f8d,405d400000000000/0_2/405caccccccccccd,3fd3333333333333/ -2/3fb0000000000000/3ff4cccccccccccc/bd38000000000000/3d78000000000000/0/0_4,1_1/bbe0000000000000,3cd4fdc000000000,0,3ca1500000000000,0/0_2/bcea000000000000,0/ false false
+kahan - 0/255bba08cf8c979d/0/40783e0000000000/40d84c5780e69d5e/3/8_3,2_4/3ffb333333333333,3fd3333333333333,4341c37937e08000,3fd3333333333333,0,0,3ffb333333333333/// -4/3fa47ae147ae147b/4014000000000000/4061e00919c41eff/40b170ad65dcce90/1/4_4,2_1/4341c37937e08000,3fd3333333333333,4341c37937e08000,3ffb333333333333,3fd3333333333333/// => -4/3fa47ae147ae147b/4014000000000000/40809702467107c0/40dca882da5dd102/3/1_1,2_4,2_1/4341c37937e08002,4341c37937e08000,3fd3333333333333,4341c37937e08000,3ffb333333333333,3fd3333333333333/// -4/3fa47ae147ae147b/0/bd20000000000000/0/3/1_1,2_4,2_1/bca0000000000000,0,0,0,0,0/// false false
+kahan - 5/255bba08cf8c979d/404d800000000000/407a000666384292/40cd72a84493d63d/1/-5_3,1_3/3f4ccd71ef1c285b,404a800000000000,3f466450257609e1,4053000000000000,4020000000000000,4054000000000000/2_3/4030000000000000,4049800000000000,4052400000000000/ 8/3fe0000000000000/3f3e3a47ac5d840d/40753801e3a47ac6/4086efdb6a3ddda9/0///0_4/4053c00000000000,405ae00000000000,4055000000000000,4051400000000000/ 0/0/0/406ca0076d8ffaae/40bbf31f12b3a026/3/-9_3,1_3,2_2/4058000000000000,4057400000000000,3f4d23e7e6386d01,0,0,0,4044000000000000,3ef24b009012a77d/// => 0/3fe0000000000000/406f000b1042ef1a/408ec40600525d58/40d66d9ac248c216/3/0_2/4066200ccc708524,40540000492c0240/0_2/4053c00000000000,4079080000000000/ 0/3fe0000000000000/bcfa1f1000000000/bd30000000000000/bd87000000000000/0/0_2/3d1191e000000000,3cf2a77d00000000/0_2/0,0/ false false
+kahan - 2/0/0/407ac80000000000/c0661b327086ff86/1/-19_3,0_2,2_2/4054800000000000,4055800000000000,0,405e200000000000,4022000000000000,4053000000000000,404b800000000000/// -2/3fe0000000000000/3f12221310c6926e/3f12221310c6926e/bf553de45aa9a155/0///// -2/255bba08cf8c979d/0/4071200000000000/c09c24bdb1621ac7/3/-8_4/4050c00000000000,4051800000000000,4056800000000000,4047800000000000/// -4/3f847ae147ae147b/401c000000000000/40636003de8b8cee/40a942eefd5e63af/1/-18_1/4050400000000000/-9_3,1_2/4014000000000000,3f3ef45c676b0b95,4036000000000000,404a000000000000,4010000000000000/ => -4/3fe0000000000000/408acc011be7095e/408acc011be7095e/40939db8a76b86fc/3///// -4/3fe0000000000000/bd41a7e7c0000000/bd3e5b6480000000/bd36855400000000/0///// false false
+kahan - 0/255bba08cf8c979d/0/4074ac038613fd84/40d669b267e78490/0/-5_3,2_4/401c800000000000,4058800000000000,3f4c309fec1f7389,4018000000000000,0,4058c00000000000,4046700000000000/9_2/4052f00000000000,0/ 1/3fe0000000000000/0/406bcc02dd25a782/40b7afbbf66c23a7/0/-18_2,0_3,2_1/405a480000000000,4056c00000000000,3f36e92d3c123aef,0,4028800000000000,402c000000000000/// => 0/3fe0000000000000/405a480e184ff610/408149027a5368a2/40dc55a165828d7a/0/0_1,1_2/4018000000000000,4058c00000000000,4046700000000000/9_1/4052f00000000000/ 0/3fe0000000000000/bcf18ee000000000/3d30000000000000/bd70000000000000/0/0_1,1_2/0,0,0/9_1/0/ false false
+kahan - 2/3fe0000000000000/0/0/0/0///// -2/4000000000000000/4058000000000000/4082af01bacc4b80/40d60073d32d5b45/3/7_2,0_3,1_1/4341c37937e08000,3ffb333333333333,3ffb333333333333,0,3fd3333333333333,0/-18_4,2_4,0_4/4341c37937e08000,4341c37937e08000,3fd3333333333333,3fd3333333333333,3ffb333333333333,3fd3333333333333,3ffb333333333333,4341c37937e08000,0,0,4341c37937e08000,3ffb333333333333/ => -2/4000000000000000/4058000000000000/4082af01bacc4b80/40d60073d32d5b45/3/7_5,1_1/4341c37937e08000,3ffb333333333333,3ffb333333333333,0,3fd3333333333333,0/// -2/4000000000000000/0/0/0/3/7_5,1_1/0,0,0,0,0,0/// false false
+kahan - -1/255bba08cf8c979d/0/40720003529a0e7f/c0b5715e4a655833/1/-8_1,0_2/403f000000000000,4055c00000000000,0/-5_4/4044800000000000,3f4a94d073f89ab3,4052000000000000,404c800000000000/ -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 8/3f847ae147ae147b/4042800000000000/407a50054e1ed570/40b4ddf696d2b326/2/3_2,1_4/3f501d911f324458,4057400000000000,3f346ba8da2c759d,4051800000000000,4047800000000000,4055400000000000/-4_2/4036000000000000,4050c00000000000/ => error
+kahan - 5/3f50624dd2f1a9fc/0/405ac00000000000/40a40de98ff14c88/3///0_3,1_1/0,3fd3333333333333,0,0/ -53/3f70624dd2f1a9fc/0/4057c00000000000/40a3593d010a2014/2/0_2/0,3fd3333333333333///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => error
+kahan - -1/3f847ae147ae147b/0/405d00063f5d169e/40af9dcb364c6b85/0/6_1,0_2/4041000000000000,4054800000000000,3f38fd745a79a56d/// 2/255bba08cf8c979d/0/40655c0a83e1119c/40c52eab2eca320b/2/-14_2/4053c00000000000,3f3bf53234016961/-12_3,2_1/3f4c14eb2c723791,404ef00000000000,4038000000000000,4018000000000000/ 8/3f50624dd2f1a9fc/0/0/8000000000000000/1///// 2/3f847ae147ae147b/0/408270013e1c2ea4/40e189f82d566195/1/-16_2,0_4/0,4040000000000000,3f30b9a1d25ca840,4054400000000000,4059000000000000,4055000000000000/-7_3,1_3,1_4/0,0,3f3709e4020f475f,0,4054800000000000,0,403a000000000000,404e000000000000,4054000000000000,4046800000000000/ => -1/3f847ae147ae147b/0/408b6704a70015df/40e8cf7fac6db4d0/0/-2_2,6_1,0_2/0,40778002caed4066,4041000000000000,4054800000000000,3f38fd745a79a56d/-1_3/4055780e0a759639,40560005c2790084,406a600000000000/ -1/3f847ae147ae147b/0/bd20000000000000/3d60000000000000/0/-2_2,6_1,0_2/0,bcfee5f000000000,0,0,0/-1_3/3cdbc88000000000,bce7142000000000,0/ false false
+kahan - -4/3f50624dd2f1a9fc/3f439913cd86ee50/4053580d9c4fbde7/c0a0de206f1c29a5/0/-20_1,1_2/3fd3333333333333,0,3fd3333333333333/// 5/3f70624dd2f1a9fc/0/40673c0193a99729/40b9ed3ac7792e30/1/8_1,0_4,1_3/0,4341c37937e08000,0,0,4341c37937e08000,0,0,0/// -4/0/4050000000000000/4050000000000000/408d9ae8dc10a3eb/2///// => -4/3f70624dd2f1a9fc/4050267032f04d2a/4074740430e8bb0e/40b53187ab6d2ddb/0/1_1/4351c37937e08000/// -4/3f70624dd2f1a9fc/bce16c0000000000/3d10000000000000/bd40000000000000/0/1_1/0/// false false
+kahan - 2/3fe0000000000000/4042000000000000/4054f800d363b620/c0a0048352376b5e/0/3_4,1_1/0,3f0a6c76c3ffc24c,4007000000000000,403b000000000000,4032000000000000/// -4/3f847ae147ae147b/0/406ca4054dfe18b7/40c2a66d4e9611a9/0/-8_3,1_4/3f3e122604fdfbd5,3f28bb9581771e91,4021000000000000,0,4028000000000000,4031600000000000,4055000000000000/-20_1/405ad00000000000/ -2/3f50624dd2f1a9fc/4050400000000000/407f880000000000/40d3c50d52b51ec6/0/5_4,0_4,0_4/4050d80000000000,4040000000000000,404f800000000000,401c000000000000,404f900000000000,0,0,4046800000000000,4026000000000000,4049800000000000,4052000000000000,403c000000000000/// => -4/3fe0000000000000/4074a202a6ff0c5c/40898c016debfcf2/40db17b38fb93a2f/0/1_4/4047f001a6c76c40,40652c0000000000,405b080000000000,4064400000000000/// -4/3fe0000000000000/bd19d38a00000000/bd20000000000000/bd70000000000000/0/1_4/bc9eda0000000000,0,0,0/// false false
+kahan - -53/0/0/404b900000000000/407387da9d82965b/3/1_1/404b900000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/406d080000000000/40c3f4f48c970ee2/3/1_3/4055000000000000,405c500000000000,4041800000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/40698401b4fedaf5/40c8e0e77e6a37cb/1/1_1,0_2/405d480000000000,4055c00000000000,3f2b4fedaf486f50///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/407eb800da7f6d7a/40d6b90d6ff6adb0/3/0_4/4065880000000000,4065600000000000,405c500369fdb5e9,4041800000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/3d20000000000000/bd54000000000000/3/0_4/0,0,3ccbd40000000000,0///3ff0000000000000,4000000000000000,4014000000000000 false true
+kahan - -53/0/0/0/0/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4026000000000000/4063eb352f36fe5c/0/1_1/4026000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405d000000000000/4075d9a4a1eac651/1/1_1/405d000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4061c00000000000/40b664839b96331b/2/0_3/4053c00000000000,0,404f800000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/4070d00000000000/40b861778f2e9773/0/0_3/4053c00000000000,405fc00000000000,404f800000000000///3ff0000000000000,4014000000000000 -53/0/0/0/bd30000000000000/0/0_3/0,0,0///3ff0000000000000,4014000000000000 false true
+kahan - -2/0/405db00000000000/405db00000000000/40b1f8f033f53471/2///// 1/257bba08cf8c979d/0/40606001c3ad3f9a/40c1ca1cbf22d92f/2/-11_1,2_3/3ffb333333333333,4341c37937e08000,4341c37937e08000,3fd3333333333333/// => -2/257bba08cf8c979d/405db00000000000/406f3801c3ad3f9a/40cac694d91d7368/2/-1_2/4341c37937e08001,4341c37937e08000/// -2/257bba08cf8c979d/0/0/bd70000000000000/2/-1_2/bfd3333333333334,3fd3333333333333/// false false
+kahan - -1/0/0/404e000000000000/c05bfe2541d64f25/3/-15_4/0,3fd3333333333333,4341c37937e08000,0/// -2/3f70624dd2f1a9fc/0/0/0/3///// => -2/3f70624dd2f1a9fc/4341c37937e08000/404e000000000000/c05bfe2541d64f25/3///// -2/3f70624dd2f1a9fc/3fd3333333333333/0/0/3///// false false
+kahan - -4/3fe0000000000000/0/404b800000000000/c04719b37816baff/3/-16_1/404b800000000000/// 2/255bba08cf8c979d/4056800000000000/4056800000000000/406da2e921550a01/3///// => -4/3fe0000000000000/4056800000000000/4062200000000000/4067dc7c434f5b41/3/-16_1/404b800000000000/// -4/3fe0000000000000/0/0/3d00000000000000/3/-16_1/0/// false false
+kahan - 2/255bba08cf8c979d/0/407874008bd3e42d/40be7d846f529cbf/2/-7_4/3fd3333333333333,3ffb333333333333,0,3fd3333333333333/-19_3,0_3,0_1/3ffb333333333333,4341c37937e08000,4341c37937e08000,3ffb333333333333,3ffb333333333333,3fd3333333333333,0/ -1/257bba08cf8c979d/0/406a600000000000/408d120630f4fb42/0/-9_3,1_2/3fd3333333333333,0,4341c37937e08000,0,3ffb333333333333/// => -1/257bba08cf8c979d/0/4082d20045e9f216/40c10fe29ab89e14/0/-9_3,1_2,3_1/3fd3333333333333,0,4341c37937e08000,0,3ffb333333333333,4002666666666666/-2_2/4351c37937e08000,4000000000000000/ -1/257bba08cf8c979d/0/3d30000000000000/bd68000000000000/0/-9_3,1_2,3_1/0,0,0,0,0,3ca0000000000000/-2_2/400b333333333333,bc90000000000000/ false false
+kahan - -2/3f847ae147ae147b/0/0/8000000000000000/3///8_1/0/ 2/0/0/0/0/1///// 3/0/4042800000000000/4046801dbb9e944d/409b15721b8441f5/2/-13_3/3f4dbb9e944d76df,0,0/-19_1/4020000000000000/ => -2/3f847ae147ae147b/4042800000000000/4046801dbb9e944d/409b15721b8441f5/3/0_1/3f4dbb9e944d76df/0_1,7_1/4020000000000000,0/ -2/3f847ae147ae147b/0/0/0/3/0_1/0/0_1,7_1/0,0/ false false
+kahan - -1/3fe0000000000000/404f800000000000/4077180000000000/40be1df0bf29b685/2/-7_4,2_3/3ffb333333333333,0,0,0,3ffb333333333333,0,0/// -2/4000000000000000/0/406f440000000000/c0ba6a9a1c1947be/1///-5_2,1_2/0,4341c37937e08000,0,4341c37937e08000/ => -2/4000000000000000/405099999999999a/40835d0000000000/408d9ab518837638/0///// -2/4000000000000000/bcfa000000000000/0/0/0///// true false
+kahan - -53/0/0/0/8000000000000000/1/1_1/0///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/8000000000000000/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4058300000000000/406113ac1c4da002/1/0_1/4058300000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4058300000000000/406113ac1c4da002/0/0_1/4058300000000000///3fe0000000000000 -53/0/0/0/0/0/0_1/0///3fe0000000000000 true true
+kahan - 5/3fe0000000000000/4058700000000000/4069b80000000000/c0a41c3c0ba14402/0/-11_2/3fd3333333333333,0/// 1/4000000000000000/404a000000000000/4073100000000000/c0bc3074a3d62aef/0/-13_4/3ffb333333333333,3ffb333333333333,3ffb333333333333,3ffb333333333333/// 1/255bba08cf8c979d/0/4061e00be37f8243/40a7346d95381bb8/0///-7_1,2_3,0_4/3f44df3e82935bed,4047800000000000,404b000000000000,3f4aaebf867763a9,0,4045000000000000,0,0/ 0/3f847ae147ae147b/0/40813f0104c8816e/40a2e9b584a119aa/2/-11_3,2_3/3f404c8816d979aa,0,4033000000000000,4034400000000000,405c380000000000,404e800000000000/-7_3,1_3,0_3/404a000000000000,0,4033000000000000,404c800000000000,4058480000000000,4030200000000000,4012000000000000,4028000000000000,4054400000000000/ => 0/4000000000000000/4087df6a640ec864/4092d681fed43100/c0b12f811cba323f/0///2_1/4054400000000000/ 0/4000000000000000/3d353e8000000000/bd44000000000000/0/0///2_1/0/ false false
+kahan - 8/3f847ae147ae147b/4058c00000000000/407ab804818296f6/c0c766a1fd69870e/2/7_4,1_1/4341c37937e08000,3ffb333333333333,4341c37937e08000,3fd3333333333333,3fd3333333333333/-20_4,2_3/4341c37937e08000,0,3ffb333333333333,4341c37937e08000,3fd3333333333333,0,3ffb333333333333/ -53/3fa47ae147ae147b/0/40440032dccbc893/c08d40ffee5f17e9/3/0_1,0_2/3ffb333333333333,4341c37937e08000,4341c37937e08000///bff0000000000000,0,3fe0000000000000,4024000000000000 -2/3f50624dd2f1a9fc/4014000000000000/4067e00000000000/c0a51b17b07f049c/3/-10_1,0_1,1_3/0,4028000000000000,4043800000000000,404c000000000000,4053c00000000000/// -2/3fe0000000000000/4057680000000000/407d30036ddf21be/40d7b0dfda4a2586/1/-13_3,0_2,1_1/4047000000000000,4052580000000000,4022000000000000,3f33d57cd9f71842,4055000000000000,3f41843aa0eee586/-14_3,0_1/4043000000000000,4053c00000000000,4046000000000000,0/ => error
+kahan - 3/0/0/0/0/0///// -4/3f847ae147ae147b/4045000000000000/4056001142a432d2/40940bc1d3d06826/3/-20_1,0_2/3f49fb687b0ea753,4047000000000000,3f3113bfd528c14e/// => -4/3f847ae147ae147b/4045000000000000/4056001142a432d2/40940bc1d3d06826/3///// -4/3f847ae147ae147b/0/0/0/3///// false false
+kahan - 5/3fe0000000000000/0/406740001b08b7a6/40b505317bf4f69a/2/-4_4,2_4,2_3/3ffb333333333333,3fd3333333333333,4341c37937e08000,3ffb333333333333,3fd3333333333333,3fd3333333333333,0,3ffb333333333333,4341c37937e08000,4341c37937e08000,3ffb333333333333/// -4/4000000000000000/4022000000000000/4080cc02f64a7012/40e15bdccbca2cc9/2/-7_3,0_3,2_1/3ffb333333333333,3ffb333333333333,3ffb333333333333,4341c37937e08000,3fd3333333333333,0,4341c37937e08000/-2_4,2_3/3fd3333333333333,0,4341c37937e08000,0,0,4341c37937e08000,3fd3333333333333/ -2/3f50624dd2f1a9fc/0/4056001d0f611810/c0954a47c99d0a0e/1/-17_2,1_1/3f5030e366d6b330,3f49bcfb6271d497,4056000000000000/// => -4/4000000000000000/435aa535d3d0c01a/40895c069ef8c0fe/40e35230bcfbe34c/0/1_1/4341c37937e08000/1_1,2_3/0,0,4341c37937e08000,3fd3333333333333/ -4/4000000000000000/3fe674ee16f26e35/bd30000000000000/bd78000000000000/2/1_1/0/1_1,2_3/0,0,0,0/ true false
+kahan - 0/3f50624dd2f1a9fc/405c800000000000/405c800c4cc3476b/40a43b2e3c6398a6/3/-14_1/3ffb333333333333/// -2/3fa47ae147ae147b/0/4036000000000000/40939187fd235ef0/3/4_1/3fd3333333333333/// 3/255bba08cf8c979d/0/0/8000000000000000/1///// 8/0/0/4063e00000000000/40b3e0f8a334b9ac/0///-13_3/404d800000000000,403c000000000000,4052000000000000/ => -2/3fa47ae147ae147b/405ceccccccccccd/407270031330d1db/40c17178e057aede/3/4_1/3fd3333333333333/0_1/4063e00000000000/ -2/3fa47ae147ae147b/bcea000000000000/bd10000000000000/bd70000000000000/3/4_1/0/0_1/0/ false false
+kahan - -1/3f50624dd2f1a9fc/3f49d69ef316a717/404d201b83daa5aa/4074401fbde076c0/2/3_3/3f0ad3bb2932e282,0,0/9_4/4031000000000000,0,0,4044a00000000000/ 3/3f50624dd2f1a9fc/4051c00000000000/4074ae0000000000/40c50ffd21ac2b49/3/-10_2/4050000000000000,0/-6_2,2_3/404f000000000000,404dc00000000000,3ff6000000000000,404c000000000000,4031000000000000/ => -1/3f50624dd2f1a9fc/4051c00ceb4f798b/40785203707b54b5/40c5b1fe1f9b2eff/3/0_1,2_3/4050000000000000,3f0ad3bb2932e282,0,0/0_1,8_4/40687c0000000000,4031000000000000,0,0,4044a00000000000/ -1/3f50624dd2f1a9fc/3cf4e2e000000000/3d10000000000000/0/3/0_1,2_3/0,0,0,0/0_1,8_4/0,0,0,0,0/ false false
+kahan - -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/404d800000000000/40ae65c821cf70a1/0/1_2/404d800000000000,0///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/404d800000000000/40ae65c821cf70a1/0/0_1/404d800000000000///3fe0000000000000 -53/0/0/0/0/0/0_1/0///3fe0000000000000 false true
+kahan - 2/3fe0000000000000/0/405a381797d3352f/409fbf8bed641cbe/1/-3_4,0_3/0,3f1139a11c0c47b0,4029c00000000000,3f1957f8ddfdec34,3f2616161f28e6e8,4057000000000000,0/7_2/3f3bb45c5f61fc9c,3f467dbf73a2bf49/ -1/3f847ae147ae147b/0/4062400e93a749f1/409298566059648a/0/-2_3/3f4decfb86e52e62,4051c00000000000,3f383c3342334f1d/-11_1,1_3,2_1/3f349eb438edfb71,4041000000000000,4034000000000000,4035000000000000,3f27d0b78d32a15c/ => -1/3ff0000000000000/4063dc0fe83419c1/406f5c1a5f90e488/40a92bf126dec0a4/0/1_1/40570002c2c2c3e5/1_1/3f522bf6d1a9decc/ -1/3ff0000000000000/bcdec1c000000000/3d10000000000000/0/0/1_1/3cdcdd0000000000/1_1/bc00000000000000/ false false
+kahan - 0/255bba08cf8c979d/403da00000000000/403da00000000000/4061e31dfeaefb7a/3///// -2/3f50624dd2f1a9fc/0/0/0/1///// 2/3f50624dd2f1a9fc/4047800000000000/4047800000000000/40793b1367aead21/1///// => -2/3f50624dd2f1a9fc/4053280000000000/4053280000000000/408116513383156f/3///// -2/3f50624dd2f1a9fc/0/0/0/3///// false false
+kahan - 0/3fe0000000000000/0/0/0/0///// 1/0/3f36dee20b5558cf/4060a402dbdc416b/40c08187730384f6/2/-4_2,0_2/0,404c800000000000,4052c00000000000,3ff2000000000000/// => 0/3fe0000000000000/40608002dbdc416b/4060a402dbdc416b/40c08187730384f6/0/0_1/3ff2000000000000/// 0/3fe0000000000000/bd05398800000000/0/0/0/0_1/0/// false false
+kahan - -1/0/0/3f155254992937c7/3f661e4a31ab9d4a/2/-18_1/3f155254992937c7/// 5/3f847ae147ae147b/0/4052500a06d15d27/c086f9e75ff742f8/1///-11_3/4010000000000000,3f440da2ba4db9d9,4051500000000000/ => -1/3f847ae147ae147b/3f155254992937c7/4052500b5bf6a6ba/c086f9e1d864b68d/0///0_1/4052500a06d15d27/ -1/3f847ae147ae147b/0/bcfb20e400000000/bd08ad8000000000/0///0_1/bce189c000000000/ true false
+kahan - -53/0/0/40677c0000000000/40bf3883c569f005/0/1_3/4058000000000000,4020000000000000,4054f80000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/1_1/0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4062a00000000000/4099f97acc0acac2/0/0_3/404b800000000000,403d000000000000,4050400000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/40750e0000000000/40c2db713c36515b/3/0_4/4055000000000000,4064200000000000,4020000000000000,4054f80000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/bd60000000000000/3/0_4/0,0,0,0///3ff0000000000000,4000000000000000,4014000000000000 false true
+kahan - 2/3fe0000000000000/0/402e40357e62bf6e/c07757f14e05a772/2/-10_2/402e400000000000,3f3abf315fb70755/// 2/3f847ae147ae147b/3f44f9b759faa7ed/4064e0053e6dd67f/40a57e397c3ad2f0/2/-17_4/0,404a700000000000,405c480000000000,3ff0000000000000/// 3/3f50624dd2f1a9fc/4033000000000000/40837a0450bfd9f1/40d4f8cd58e1631e/1/-17_4,1_2,2_1/404d100000000000,4052400000000000,4041200000000000,4057c00000000000,4057400000000000,4048f00000000000,4044800000000000/2_4,1_3,1_1/4052000000000000,4047000000000000,3f40fea01c2afb71,3f487f6b641aac81,0,4045000000000000,0,3f4b8df21ec20373/ => 2/3fe0000000000000/4083b2014f9b75a0/40892b067654da8e/40d74b34c330a6de/0/-10_2/402e400000000000,3f3abf315fb70755/1_6/4052000000000000,40470010fea01c2b,3f487f6b641aac81,4045000000000000,0,3f4b8df21ec20373/ 2/3fe0000000000000/bd25604c00000000/3d2e000000000000/3d6c000000000000/2/-10_2/0,0/1_6/0,bca23c0000000000,0,0,0,0/ true false
+kahan - 1/3f847ae147ae147b/4058c00000000000/4073000000000000/40b8e0810d4a9ffa/0/0_2,1_2/4030000000000000,4056000000000000,4053800000000000,4037000000000000/// 3/3f50624dd2f1a9fc/0/4070040295243a67/40c8b9a98f93b389/3/-1_2/3f44a921d3399a69,0/-1_4/4054000000000000,4048000000000000,405c100000000000,4030000000000000/ 5/255bba08cf8c979d/4058c00000000000/407b300673c9bf50/40d6fddf9aecdad6/2/-2_1,0_3/3f4eb9c83f001915,0,3f44e485bb7b8ad0,4049000000000000/-2_3,2_4/4041800000000000,4041800000000000,4040800000000000,4047800000000000,404f000000000000,4052000000000000,4000000000000000/ => 1/3f847ae147ae147b/4068c00000000000/408f1a048476fcdc/40e4c96a5304ae4c/3/0_2,1_2/403000908edf9b6a,4061400000000000,4053800000000000,4037000000000000/0_2/406ce00000000000,4073740000000000/ 1/3f847ae147ae147b/0/bd30000000000000/3d90000000000000/3/0_2,1_2/3cdf270000000000,0,0,0/0_2/0,0/ false false
+kahan - -53/0/0/4056d80000000000/c0880d41ac24d5af/1/0_3/4050680000000000,4000000000000000,4037c00000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4054000000000000/407dfb2adab1fbb1/1/0_1/4054000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/40656c0000000000/c0721f587d97afad/3/0_2/4062740000000000,4037c00000000000///3ff0000000000000,4014000000000000 -53/0/0/0/0/1/0_2/0,0///3ff0000000000000,4014000000000000 false true
+kahan - 8/3f50624dd2f1a9fc/405a700000000000/405a700000000000/40b2decff2cb48ab/2///// 8/3f70624dd2f1a9fc/3f387a62338086e7/40882c00c3d3119c/40e4261153016ae0/0/-20_4,1_2,0_1/4341c37937e08000,0,4341c37937e08000,0,0,0,4341c37937e08000/-17_3,1_4,2_2/3fd3333333333333,0,0,3ffb333333333333,4341c37937e08000,4341c37937e08000,0,3ffb333333333333,3fd3333333333333/ 3/3f847ae147ae147b/0/4068f00000000000/40c5aa61196fbbda/1/-4_2,2_1,0_3/3ff0000000000000,403a000000000000,4033000000000000,4048800000000000,4053600000000000,403b000000000000/// => 3/3f847ae147ae147b/405a70061e988ce0/4090db0061e988ce/40ebec8397b6c2ec/0/-4_2,2_4/3ff0000000000000,403a000000000000,435aa535d3d0c005,4048800000000000,4053600000000000,403b000000000000/0_1/4351c37937e08000/ 3/3f847ae147ae147b/3ce0dce000000000/0/bd70000000000000/0/-4_2,2_4/0,0,bff0000000000000,0,0,0/0_1/4010000000000000/ false false
+kahan - -2/255bba08cf8c979d/4038000000000000/40722c0276891660/4092db3ce2f7e878/0/-1_3,1_2/0,3f43b448b2fe779a,4041000000000000,4049600000000000,0/6_1,1_2,2_1/4055000000000000,4039000000000000,4050c00000000000,4018000000000000/ 3/3f847ae147ae147b/404b800000000000/4075f6021472a5b2/40c7996cfec19532/0/-19_4,1_3/0,0,3f40a3952d8cc989,0,4051400000000000,4024000000000000,4000000000000000/1_3/405d180000000000,0,4058c00000000000/ => -2/3f847ae147ae147b/4053c00000000000/40841102457dde09/40c9f4d49b209241/0/0_2,1_1/405440122beef045,4041000000000000,4049600000000000/1_1,4_1,1_2,2_1/406aec0000000000,4055000000000000,4039000000000000,4050c00000000000,4018000000000000/ -2/3f847ae147ae147b/0/0/0/0/0_2,1_1/3d04123000000000,0,0/1_1,4_1,1_2,2_1/0,0,0,0,0/ false false
+kahan - -53/0/0/0/0/1/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4039000000000000/409597626148a8c8/2/1_1/4039000000000000///4000000000000000 -53/0/0/0/0/0/////4000000000000000 => -53/0/0/4039000000000000/409597626148a8c8/0/1_1/4039000000000000///4000000000000000 -53/0/0/0/0/0/1_1/0///4000000000000000 true true
+kahan - 8/3fe0000000000000/0/4066e0039461697b/c088821a7bdb2d72/0/-17_2/0,0/-13_4,1_3/3f3ca30b4bd872f3,0,4014000000000000,4024000000000000,4052c00000000000,4050c00000000000,403a000000000000/ -1/0/0/40734201cbe0c823/c0611b8a3ce850a1/2/-10_2,2_2/4057400000000000,403c000000000000,4033000000000000,4051800000000000/-16_2/4058880000000000,3f3cbe0c822e159b/ => -1/3fe0000000000000/40734201cbe0c823/407eb20396117ce0/c08cc8fd0b15419a/0/0_1/0/0_1/4066e0039461697b/ -1/3fe0000000000000/bcfea65000000000/3d20000000000000/bd20000000000000/0/0_1/0/0_1/3cdcbcc000000000/ false false
+kahan - 3/0/404c800000000000/4079200000000000/40d5c4d26eb0a0e2/2/-13_4,2_3/0,4341c37937e08000,3ffb333333333333,0,0,3ffb333333333333,3ffb333333333333/// -4/257bba08cf8c979d/4055400000000000/40604003c7bb85af/40b31b62c703ca9d/0/-12_2/3ffb333333333333,0/// -2/3f847ae147ae147b/0/4058880000000000/c076ed956a6e0a97/3/5_2,1_1,2_1/403b200000000000,4047800000000000,0,4038000000000000/// 1/255bba08cf8c979d/403c000000000000/40645c0000000000/40c3b1a7ec3d1c77/3/-20_3,2_3/4058c00000000000,0,0,0,4026000000000000,4036e00000000000/-12_1/4000000000000000/ => -4/3ff0000000000000/4341c37937e0809c/4088c800f1eee16c/40e20464607334cd/3/2_2/4052880000000000,4038000000000000/// -4/3ff0000000000000/bfd4ccccccccccd0/bd20000000000000/3d79000000000000/0/2_2/0,0/// false false
+kahan - -53/0/0/4038000000000000/c0634da7877cf69c/2/0_1/4038000000000000///4000000000000000 -53/0/0/0/0/0/////4000000000000000 -53/0/0/4041000000000000/40594f63cc6f25d2/1/1_1/4041000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/////4000000000000000 => -53/0/0/404d000000000000/c04a97d685158ecc/3/0_1/404d000000000000///4000000000000000 -53/0/0/0/0/0/0_1/0///4000000000000000 false true
+kahan - -53/0/0/4035000000000000/4061b44fb1a0c0dd/3/1_1,0_1/0,4035000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4035000000000000/4061b44fb1a0c0dd/3/2_1/4035000000000000///3ff0000000000000,4014000000000000 -53/0/0/0/0/3/2_1/0///3ff0000000000000,4014000000000000 false true
+kahan - 1/3f847ae147ae147b/0/406e24076d33add4/40c2f49df0aecd2a/3/8_2,0_2,2_4/4341c37937e08000,3ffb333333333333,3fd3333333333333,4341c37937e08000,0,0,4341c37937e08000,0/// 0/3fa47ae147ae147b/0/405ec00000000000/40b09988a67142af/2/-8_1/3ffb333333333333/6_1/0/ -4/3f847ae147ae147b/0/403da00000000000/4090156447607784/3/-8_1/403da00000000000/// => -4/3fa47ae147ae147b/403da00000000000/40789c03b699d6ea/40cd440eccd37d72/3/1_1/435aa535d3d0c000/1_1/0/ -4/3fa47ae147ae147b/0/0/0/3/1_1/4000000000000000/1_1/0/ false false
+kahan - -53/0/0/0/0/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/3f44af335fbc20ff/3f99b8af685e8bbe/0/0_2/0,3f44af335fbc20ff///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/3f44af335fbc20ff/3f99b8af685e8bbe/0/0_1/3f44af335fbc20ff/// -53/0/0/0/0/0/0_1/0/// false true
+kahan - -4/3f847ae147ae147b/0/40436010b181e601/c08c1773460b7dc6/3///0_2,0_2/0,3f3b5565e62b1f3e,3f1836779757e14a,4043600000000000/ 2/255bba08cf8c979d/4048000000000000/4071e0046813f282/c09190d7034db860/0/-12_4,1_2,0_1/3f3718420ffc42bb,4048000000000000,404b800000000000,403d000000000000,3f47b47e8c1505c5,4010000000000000,4031000000000000/-19_1/4055400000000000/ -1/3fe0000000000000/4055800000000000/406f4c0000000000/40b60b73cbde7e73/1/-11_4/402ec00000000000,4050800000000000,401c000000000000,4053000000000000/// => -4/3ff0000000000000/4080c3023409f941/4081f9033f2217a1/40ac489f44934144/3///1_3/3f3b5565e62b1f3e,3f1836779757e14a,4043600000000000/ -4/3ff0000000000000/3d19391400000000/3d00000000000000/3d50000000000000/3///1_3/0,0,0/ false false
+kahan - -2/3f50624dd2f1a9fc/3f4dc047aa3e3770/4050801231eea6e5/40a8113e00e71185/1/-19_3/3ffb333333333333,3fd3333333333333,3fd3333333333333/// -53/3f70624dd2f1a9fc/0/4000010347ef3b36/404eada05df7b0dd/0/1_1,0_2/4341c37937e08000,0,0///3ff0000000000000,4014000000000000,4024000000000000 => error
+kahan - 2/255bba08cf8c979d/0/406c6006258eb0d8/40c04299d29575ab/1/-10_3,2_1,0_3/0,3f4047383b91f177,4057400000000000,403c000000000000,3f309e050f9b2505,4046000000000000,404f000000000000/// -2/0/0/4050400000000000/409e59f6fc3d5884/2/3_2/4014000000000000,4045000000000000/-7_1/4032000000000000/ => -2/255bba08cf8c979d/0/4072400312c7586c/40c40dd8b21d20bc/0/0_1,2_2/406c6006258eb0d8,4014000000000000,4045000000000000/-7_1/4032000000000000/ -2/255bba08cf8c979d/0/0/bd70000000000000/0/0_1,2_2/bcef01a000000000,0,0/-7_1/0/ true false
+kahan - 2/0/0/405d000000000000/40bbe66ddd6fd06e/1/-4_2/4341c37937e08000,3fd3333333333333/// -1/257bba08cf8c979d/4051400000000000/40725c0189ca785d/40c0b43fb1f37ca4/0/-8_1/3fd3333333333333/-5_3,1_3/3fd3333333333333,3fd3333333333333,3fd3333333333333,4341c37937e08000,0,0/ => -1/257bba08cf8c979d/4051400000000000/40799c0189ca785d/40cea776a0ab64db/0/-8_1,7_1/3fd3333333333333,4341c37937e08000/-5_3,1_3/3fd3333333333333,3fd3333333333333,3fd3333333333333,4341c37937e08000,0,0/ -1/257bba08cf8c979d/0/0/0/0/-8_1,7_1/0,3fd3333333333333/-5_3,1_3/0,0,0,0,0,0/ false false
+kahan - -53/0/0/0/8000000000000000/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 0/3fe0000000000000/403b600000000000/403b600000000000/40944e15ee554bf7/1///// -53/0/0/40340012b39a18be/406044a60a8e028f/0/0_2,0_1/3f32b39a18bd8a29,4010000000000000,4030000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405dc00000000000/40b86c651fcde9d8/3/0_2,0_1/4045000000000000,4053400000000000,0///3ff0000000000000,4000000000000000,4014000000000000 => error
+kahan - -53/0/0/4047800000000000/c090d577cb84b47f/0/0_1/4047800000000000///4000000000000000 -53/0/0/4057c000de7b53a3/40b0a57fdcc2edc3/0/0_2/3f0bcf6a74699380,4057c00000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/4061c0006f3da9d2/40a8e043d3c38146/0/0_1/4061c0006f3da9d2/// -53/0/0/bd10000000000000/3d50000000000000/0/0_1/bd066c8000000000/// false true
+kahan - -1/3f847ae147ae147b/0/4082a801b869bfa7/40c662a8ec229ba1/1/4_2,2_4/4055c80000000000,4054c00000000000,3f4b869bfa6cf1bd,404e800000000000,404d700000000000,4034000000000000/-18_2,2_2,0_1/0,4054800000000000,4054000000000000,404f000000000000,404f800000000000/ 5/0/3f40e18e096c9348/4074ba04bc637320/40b1b42c0c3bea7a/3/-11_3/0,4045000000000000,3f45018d8f9578f1/-1_4,0_4/4037200000000000,4052000000000000,0,4018000000000000,4055500000000000,4035000000000000,4022000000000000,4052500000000000/ 5/0/0/4042800000000000/c0730103bf614b70/1///-11_2/4042800000000000,0/ -1/0/0/0/0/0///// => -1/3f847ae147ae147b/3f40e18e096c9348/408e2d04169b7937/40cea4b6d4458682/3/0_1,3_2,2_4/40450015018d8f95,4055c80000000000,4054c00000000000,3f4b869bfa6cf1bd,404e800000000000,404d700000000000,4034000000000000/-18_2,2_2,0_1,11_2/0,4054800000000000,4054000000000000,404f000000000000,404f800000000000,4060840000000000,4068500000000000/ -1/3f847ae147ae147b/0/0/3d70000000000000/3/0_1,3_2,2_4/3cee3c4000000000,0,0,0,0,0,0/-18_2,2_2,0_1,11_2/0,0,0,0,0,0,0/ false false
+kahan - 5/0/4050400000000000/4080ae02c9e6dd46/40cc9f305a8f71e3/0/0_3,0_4/3f381077c394f2f1,3f504b18f94c36db,4057000000000000,4056000000000000,405f300000000000,4052800000000000,4056800000000000/// 5/3fe0000000000000/4053c00000000000/4065600000000000/40c4a5ee0d72a601/0/2_1,1_1/4053c00000000000,402a000000000000/// => 5/3fe0000000000000/4062000000000000/40860602c9e6dd46/40d8a28f34010bf2/0/0_7/3f381077c394f2f1,3f504b18f94c36db,4065600000000000,4056000000000000,4061380000000000,4052800000000000,4056800000000000/// 5/3fe0000000000000/0/0/0/0/0_7/0,0,0,0,0,0,0/// false false
+kahan - 2/0/0/0/8000000000000000/1///// 8/0/4051c00000000000/4051c00000000000/c05e78923fcd138d/1///// 1/0/0/4078be05295f1d23/c0963c537108ac5f/1/-9_4,2_4,1_1/4042800000000000,4055c00000000000,404c000000000000,403c000000000000,404d800000000000,4045300000000000,3f49f933876df888,3f3ea38ac35418b1,4055a00000000000/// -2/3f847ae147ae147b/4056980000000000/4056980000000000/4054cf5a94efd749/3///// => -2/3f847ae147ae147b/40642c0000000000/40816a0294af8e92/c096d6e6ebb68023/3/-1_3/405f000000000000,40672c0a52be3a46,4055a00000000000/// -2/3f847ae147ae147b/0/bd30000000000000/bd30000000000000/1/-1_3/0,3ca3820000000000,0/// false false
+kahan - 2/3f50624dd2f1a9fc/3f3eaac25833cc92/4068e003d5584b06/403d75a87adbc252/3/-2_4,1_1,0_2/3fd3333333333333,3fd3333333333333,3ffb333333333333,3fd3333333333333,3ffb333333333333,3ffb333333333333,4341c37937e08000/// -53/3f70624dd2f1a9fc/0/4065380000000000/40bf1bacb41db33a/3/0_3,0_1/3ffb333333333333,3ffb333333333333,3fd3333333333333,3fd3333333333333///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 8/255bba08cf8c979d/4000000000000000/4000000000000000/c010f4bf35d77dba/2///// -4/3f50624dd2f1a9fc/0/40611803736d6d5b/c0ace9216d226a01/0/7_3,2_3/0,403dc00000000000,0,3f3b9b6b6ad828f8,0,0/-13_2/4051800000000000,4042800000000000/ => error
+mul 7ff0000000000000 -53/0/0/0/0/0/////4000000000000000 => -53/0/fff8000000000000/fff8000000000000/fff8000000000000/0/////4000000000000000
+mul 7ff8000000000001 5/3fe0000000000000/0/0/0/3///// => 5/3fe0000000000000/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/////
+mul 0 8/3fe0000000000000/0/4071aa0000000000/40cbd4e9919a00d4/2/8_2/400e000000000000,0/-4_3,2_3/404e000000000000,0,4057380000000000,402c000000000000,4039000000000000,4055c00000000000/ => 8/3fe0000000000000/0/0/0/2/8_2/0,0/-4_3,2_3/0,0,0,0,0,0/
+mul 1a56e1fc2f8f359 -4/3f847ae147ae147b/0/405c000000000000/40b41ec037d40ed9/3/-9_2/402c000000000000,4058800000000000/// => -4/3f847ae147ae147b/0/212c05bca99d4ee/26af2d7a3887ad9/3/-9_2/1e2c05bca99d4ee,210685051469a50///
+mul c008000000000000 -53/0/0/40570004f0c67f96/c08b1b522cba6185/1/0_2/4057000000000000,3f33c319fe56aabf///4000000000000000 => -53/0/8000000000000000/c0714003b494dfb0/40a4547da18bc924/3/0_2/c071400000000000,bf4da4a6fd82001e///4000000000000000
+mul bff0000000000000 -53/0/0/405ac80000000000/c0a41e8ca6fbe0f1/0/0_1,1_2/0,4058400000000000,4024400000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/c05ac80000000000/40a41e8ca6fbe0f1/3/0_1,1_2/8000000000000000,c058400000000000,c024400000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul 7ff8000000000001 3/255bba08cf8c979d/403ea00000000000/40763c06ca12345b/40ba413dbcffc6a9/2/-4_1,2_3,0_4/4036000000000000,3f469177e10c1d12,4039000000000000,3f3eba5c8e73b8f1,4050c00000000000,4057400000000000,0,3f4061eb7a8eb05e/-12_1/405d880000000000/ => 3/255bba08cf8c979d/7ff8000000000001/7ff8000000000001/7ff8000000000001/2/-4_1,2_3,0_4/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001/-12_1/7ff8000000000001/
+mul 4000000000000000 5/3f50624dd2f1a9fc/4046b00000000000/4048300000000000/40a32934dcbf519f/2/-9_1,2_2,2_2/4008000000000000,0,0,0,0/// => 5/3f50624dd2f1a9fc/4056b00000000000/4058300000000000/40b32934dcbf519f/2/-9_1,2_2,2_2/4018000000000000,0,0,0,0///
+mul 7ff0000000000000 -1/3f847ae147ae147b/404f500000000000/40772a047e15f233/c0c2679ca99bbea9/3/6_2,1_4,2_1/3f4ed0ea593535ae,402c000000000000,4046800000000000,4041800000000000,4010000000000000,4045800000000000,0/-20_4/4018000000000000,3f247f14e18c0a9c,4057800000000000,4050c00000000000/ => -1/3f847ae147ae147b/7ff0000000000000/7ff0000000000000/fff0000000000000/3/6_2,1_4,2_1/7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000,fff8000000000000/-20_4/7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000/
+mul 7ff0000000000000 -53/0/0/0/0/2/////4000000000000000 => -53/0/fff8000000000000/fff8000000000000/fff8000000000000/2/////4000000000000000
+mul 3fe0000000000000 5/3f847ae147ae147b/0/4067000b7d0fdedd/40b079453217bfb7/1/9_4,0_1/4042800000000000,3f2b1e65ce56f081,3e9434730ace0815,3f3b0ca8acf86ce1,3f28413d3922915f/-1_3,0_3/4026000000000000,3f43937bd4b77a82,4039000000000000,4057400000000000,4032000000000000,0/ => 5/3f847ae147ae147b/0/4057000b7d0fdedd/40a079453217bfb7/1/9_4,0_1/4032800000000000,3f1b1e65ce56f081,3e8434730ace0815,3f2b0ca8acf86ce1,3f18413d3922915f/-1_3,0_3/4016000000000000,3f33937bd4b77a82,4029000000000000,4047400000000000,4022000000000000,0/
+mul c008000000000000 -53/0/0/0/0/1/////4000000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////4000000000000000
+mul bff0000000000000 5/3fe0000000000000/403a000000000000/4073780000000000/40b78f9414ea4d30/0/-2_3,1_1/0,0,4022000000000000,403a000000000000/-8_2,1_3/0,403d800000000000,4044000000000000,404d800000000000,405e800000000000/ => 5/3fe0000000000000/c03a000000000000/c073780000000000/c0b78f9414ea4d30/3/-2_3,1_1/8000000000000000,8000000000000000,c022000000000000,c03a000000000000/-8_2,1_3/8000000000000000,c03d800000000000,c044000000000000,c04d800000000000,c05e800000000000/
+mul c008000000000000 -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////3ff0000000000000,4000000000000000,4014000000000000
+mul c008000000000000 5/0/0/40777e069229dc8d/c08072c54e773649/1/-3_2,1_4/3f4d09376c4a3e6f,4032600000000000,4051c00000000000,4018000000000000,4045000000000000,3f33c0cb6c765504/-4_1,0_2,0_3/4051c00000000000,4043600000000000,4049800000000000,0,3f3b4f6383d1e3fd,4053700000000000/ => 5/0/8000000000000000/c0919e84ed9f656a/4098ac27f5b2d16e/3/-3_2,1_4/bf65c6e99137aed3,c04b900000000000,c06aa00000000000,c032000000000000,c05f800000000000,bf4da13122b17f86/-4_1,0_2,0_3/c06aa00000000000,c05d100000000000,c063200000000000,8000000000000000,bf547b8aa2dd6afe,c06d280000000000/
+mul 3fe0000000000000 8/0/0/40756e0000000000/40c84e65f9bb77b2/1/-18_4/4022000000000000,0,405c200000000000,4054c00000000000/-15_3,1_1/404b800000000000,4032000000000000,4029c00000000000,404a400000000000/ => 8/0/0/40656e0000000000/40b84e65f9bb77b2/1/-18_4/4012000000000000,0,404c200000000000,4044c00000000000/-15_3,1_1/403b800000000000,4022000000000000,4019c00000000000,403a400000000000/
+mul c008000000000000 3/0/4054c00000000000/4054c00000000000/c09737049a5e403b/0///// => 3/0/c06f200000000000/c06f200000000000/40b1694373c6b02c/3/////
+mul 7ff8000000000001 -53/0/0/0/0/2/////4000000000000000 => -53/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/2/////4000000000000000
+mul 0 -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000
+mul 7ff0000000000000 -53/0/0/4055800000000000/40af614dde69e182/0/1_3/4051800000000000,4030000000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/fff8000000000000/7ff0000000000000/7ff0000000000000/0/1_3/7ff0000000000000,7ff0000000000000,fff8000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul c008000000000000 -53/0/0/406cc8051dead354/c0a8fa4654f963df/3/0_1,0_3/3f4477ab4d4d1bf5,4056480000000000,404c900000000000,4055000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/c0859603d6701e7f/40c2bbb4bfbb0ae7/3/0_1,0_3/bf5eb380f3f3a9f0,c070b60000000000,c0656c0000000000,c06f800000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul 7ff0000000000000 -53/0/0/405be00c9c1a6e45/40a0b527a9c2e9d4/1/0_2,0_1/4020000000000000,4059e00000000000,3f493834dc893425///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/fff8000000000000/7ff0000000000000/7ff0000000000000/1/0_2,0_1/7ff0000000000000,7ff0000000000000,7ff0000000000000///3ff0000000000000,4000000000000000,4014000000000000
+mul 4000000000000000 -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000
+mul bff0000000000000 0/3f50624dd2f1a9fc/404f000000000000/404f000000000000/40abc96230c7128c/0///// => 0/3f50624dd2f1a9fc/c04f000000000000/c04f000000000000/c0abc96230c7128c/3/////
+mul 7ff8000000000001 2/0/0/0/8000000000000000/3///// => 2/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/////
+mul 4000000000000000 2/255bba08cf8c979d/4048000000000000/4057000000000000/40b3e1d0a0154e7a/1/-18_2/0,4046000000000000/// => 2/255bba08cf8c979d/4058000000000000/4067000000000000/40c3e1d0a0154e7a/1/-18_2/0,4056000000000000///
+mul 3fe0000000000000 5/0/3f4f3de79a952b6a/407f9e03e7bcf353/40db4c3196c4f185/2/-15_3,1_4/4055400000000000,402e000000000000,4044000000000000,4032000000000000,403a000000000000,4048000000000000,4044800000000000/2_4/4035000000000000,405ef80000000000,4056000000000000,0/ => 5/0/3f3f3de79a952b6a/406f9e03e7bcf353/40cb4c3196c4f185/2/-15_3,1_4/4045400000000000,401e000000000000,4034000000000000,4022000000000000,402a000000000000,4038000000000000,4034800000000000/2_4/4025000000000000,404ef80000000000,4046000000000000,0/
+mul 4000000000000000 2/0/0/407214008065f247/c0b490bf557128f6/2/-8_2,2_3/4022400000000000,4055000000000000,405cc80000000000,4054400000000000,3f200cbe48d11e2a/// => 2/0/0/408214008065f247/c0c490bf557128f6/2/-8_2,2_3/4032400000000000,4065000000000000,406cc80000000000,4064400000000000,3f300cbe48d11e2a///
+mul 7ff8000000000001 -2/255bba08cf8c979d/404f800000000000/4070a40000000000/40c032c7b524f848/1/9_3/0,4054d00000000000,4041800000000000/5_1/4055400000000000/ => -2/255bba08cf8c979d/7ff8000000000001/7ff8000000000001/7ff8000000000001/1/9_3/7ff8000000000001,7ff8000000000001,7ff8000000000001/5_1/7ff8000000000001/
+mul 0 5/3f50624dd2f1a9fc/4046800000000000/4070420000000000/40ce97d9291f10db/0/-5_3,1_2/4044000000000000,4024000000000000,4044800000000000,4008000000000000,4037200000000000/8_3/3ff0000000000000,4041000000000000,404f800000000000/ => 5/3f50624dd2f1a9fc/0/0/0/0/-5_3,1_2/0,0,0,0,0/8_3/0,0,0/
+mul 7ff0000000000000 -53/0/0/404b800000000000/407ac3e94dff5432/1/0_1/404b800000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/fff8000000000000/7ff0000000000000/7ff0000000000000/1/0_1/7ff0000000000000///3ff0000000000000,4014000000000000,4024000000000000
+mul 7ff8000000000001 -4/3fe0000000000000/404d000000000000/406e60119cbf9488/40c11d1937d82341/3/-2_1,0_4,2_1/3f3989ab86e0c6f6,0,401c000000000000,3f3d46411cd17100,4022000000000000,4031000000000000/7_4,1_3/4038400000000000,3f4919e2ae0a186a,403a000000000000,4041800000000000,4019000000000000,3f41f125523fb5a2,404e400000000000/ => -4/3fe0000000000000/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/-2_1,0_4,2_1/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001/7_4,1_3/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001/
+mul bff0000000000000 -4/3fe0000000000000/404d800000000000/4076700000000000/409d41e88dbfcd21/0/-20_3,2_3/4056400000000000,4048000000000000,403f000000000000,4050c00000000000,403b000000000000,4043000000000000/// => -4/3fe0000000000000/c04d800000000000/c076700000000000/c09d41e88dbfcd21/3/-20_3,2_3/c056400000000000,c048000000000000,c03f000000000000,c050c00000000000,c03b000000000000,c043000000000000///
+mul 7ff8000000000001 8/0/0/4071700000000000/40c7e4a337f2e161/0/-15_1,1_2,2_4/4041800000000000,4014000000000000,0,4055400000000000,404c000000000000,0,4058800000000000/// => 8/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/0/-15_1,1_2,2_4/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001///
+mul c008000000000000 1/3f847ae147ae147b/0/403ee00000000000/c0651c055fdc2e38/2///-4_1/403ee00000000000/ => 1/3f847ae147ae147b/8000000000000000/c057280000000000/407faa080fca4554/3///-4_1/c057280000000000/
+mul c008000000000000 -2/255bba08cf8c979d/0/40887602b2003ad0/40e44506bdff0e3b/3/3_2,2_3/4052400000000000,401c800000000000,0,405e780000000000,4058800000000000/-17_3,0_3,0_4/4052800000000000,404a800000000000,4055400000000000,4051800000000000,3f396b374a4fe5e1,4046800000000000,3f4e6a6807d8b2c8,404f000000000000,402a000000000000,4054300000000000/ => -2/255bba08cf8c979d/8000000000000000/c0a2588205802c1c/c0fe678a1cfe9558/3/3_2,2_3/c06b600000000000,c035600000000000,8000000000000000,c076da0000000000,c072600000000000/-17_3,0_3,0_4/c06bc00000000000,c063e00000000000,c06fe00000000000,c06a400000000000,bf53106977bbec69,c060e00000000000,bf66cfce05e28616,c067400000000000,c043800000000000,c06e480000000000/
+mul 0 0/255bba08cf8c979d/4022000000000000/40538009133c8780/40901c0ff1b2a719/1/3_2/3f4226790eff6424,4051400000000000/// => 0/255bba08cf8c979d/0/0/0/1/3_2/0,0///
+mul 7ff0000000000000 -53/0/0/0/0/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/fff8000000000000/fff8000000000000/fff8000000000000/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul 7ff0000000000000 5/3f50624dd2f1a9fc/0/4073ec038450b5de/c06007b33cafd1a6/0///-8_2,1_4/404c800000000000,4053800000000000,4049000000000000,405d300000000000,3f4c2285aef0ebc9,4031000000000000/ => 5/3f50624dd2f1a9fc/fff8000000000000/7ff0000000000000/fff0000000000000/0///-8_2,1_4/7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000,7ff0000000000000/
+mul 4000000000000000 2/3f847ae147ae147b/4050000000000000/4081f00000000000/c0d0c295c8b4bc6b/1/-15_4,2_2/4032000000000000,0,0,403b000000000000,0,4055800000000000/-4_4,0_2/4056f80000000000,405f080000000000,4033000000000000,4057c00000000000,0,4048800000000000/ => 2/3f847ae147ae147b/4060000000000000/4091f00000000000/c0e0c295c8b4bc6b/1/-15_4,2_2/4042000000000000,0,0,404b000000000000,0,4065800000000000/-4_4,0_2/4066f80000000000,406f080000000000,4043000000000000,4067c00000000000,0,4058800000000000/
+mul 0 8/3f50624dd2f1a9fc/3f4e858a237bfef6/40729003d0b14470/c0a1a77560d49c2a/0/-9_1/4057400000000000/5_2,1_3/404b000000000000,4058c00000000000,4046000000000000,0,401c000000000000/ => 8/3f50624dd2f1a9fc/0/0/8000000000000000/0/-9_1/0/5_2,1_3/0,0,0,0,0/
+mul bff0000000000000 8/3f847ae147ae147b/403c000000000000/407a940000000000/409dae1051dae093/2/-6_1,0_1/4059e00000000000,4051c00000000000/5_1,2_1,2_3/404ee00000000000,4041000000000000,4050c00000000000,404e000000000000,0/ => 8/3f847ae147ae147b/c03c000000000000/c07a940000000000/c09dae1051dae093/3/-6_1,0_1/c059e00000000000,c051c00000000000/5_1,2_1,2_3/c04ee00000000000,c041000000000000,c050c00000000000,c04e000000000000,8000000000000000/
+mul c008000000000000 5/3f50624dd2f1a9fc/0/4057800000000000/40b40d13316c3272/3/2_2,2_3/4036000000000000,4042800000000000,0,4033000000000000,4030000000000000/// => 5/3f50624dd2f1a9fc/8000000000000000/c071a00000000000/c0ce139cca224bab/3/2_2,2_3/c050800000000000,c05bc00000000000,8000000000000000,c04c800000000000,c048000000000000///
+mul 3fe0000000000000 2/0/4034000000000000/406ad8034eb2e91e/40aeae7da816307f/2/0_4/3f3a759748f16fc5,4058c00000000000,4045100000000000,404ad00000000000/// => 2/0/4024000000000000/405ad8034eb2e91e/409eae7da816307f/2/0_4/3f2a759748f16fc5,4048c00000000000,4035100000000000,403ad00000000000///
+mul 7ff8000000000001 2/3f847ae147ae147b/0/40639c0000000000/40a22c42e4e5e436/3/-1_3,0_1,1_4/404ef00000000000,0,0,4037000000000000,404e800000000000,0,0,4026000000000000/// => 2/3f847ae147ae147b/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/-1_3,0_1,1_4/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001///
+mul c008000000000000 -53/0/0/404d800000000000/c08f304f2fcc94de/2/0_2,0_1/4044000000000000,401c000000000000,4028000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/c066200000000000/40a7643b63d96fa6/3/0_2,0_1/c05e000000000000,c035000000000000,c042000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul 1a56e1fc2f8f359 0/3f50624dd2f1a9fc/0/406a400000000000/40b90e44a377d9a0/3/-13_2,2_4/4041000000000000,0,0,4050400000000000,4049000000000000,404e800000000000/// => 0/3f50624dd2f1a9fc/0/22194560df0379f/270c796f5b47e66/3/-13_2,2_4/1f6c501bf28828f,0,0,205c3d84204d726,200be08d0527e1e,2046cf645d547f1///
+mul c008000000000000 -53/0/0/0/0/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+mul 3fe0000000000000 -2/3f847ae147ae147b/3f0c71eaeaa10515/3f0c71eaeaa10515/bf46fd6d83298c37/1///// => -2/3f847ae147ae147b/3efc71eaeaa10515/3efc71eaeaa10515/bf36fd6d83298c37/1/////
+mul 3fe0000000000000 1/3f50624dd2f1a9fc/4052c00000000000/407bf6055d25a18c/c0bb8eb092767fc1/0/3_4,0_3,1_2/3f3e7a3cb0749c06,4045000000000000,3f48b8c764a4bb9f,404d800000000000,3f179a3a7bed2e1d,4058400000000000,404c800000000000,4050880000000000,4049a00000000000/// => 1/3f50624dd2f1a9fc/4042c00000000000/406bf6055d25a18c/c0ab8eb092767fc1/0/3_4,0_3,1_2/3f2e7a3cb0749c06,4035000000000000,3f38b8c764a4bb9f,403d800000000000,3f079a3a7bed2e1d,4048400000000000,403c800000000000,4040880000000000,4039a00000000000///
+mul c008000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////3ff0000000000000,4014000000000000,4024000000000000
+mul 4000000000000000 -53/0/0/404500102a8a3de0/40971b589284dfe4/2/1_2/4045000000000000,3f402a8a3ddfeb29///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/405500102a8a3de0/40a71b589284dfe4/2/1_2/4055000000000000,3f502a8a3ddfeb29///3ff0000000000000,4000000000000000,4014000000000000
+mul 7ff8000000000001 -53/0/0/4068a40000000000/c0afe339aa954239/3/1_2/4058b00000000000,4058980000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/1_2/7ff8000000000001,7ff8000000000001///3ff0000000000000,4000000000000000,4014000000000000
+mul 0 2/3f50624dd2f1a9fc/4017800000000000/4017800000000000/3fe86df5bec98d5c/3///// => 2/3f50624dd2f1a9fc/0/0/0/3/////
+mul 0 2/3fe0000000000000/0/4055000000000000/40b1e62b83583f7a/2///4_1/4055000000000000/ => 2/3fe0000000000000/0/0/0/2///4_1/0/
+mul 1a56e1fc2f8f359 -2/3f847ae147ae147b/0/405a080000000000/40b1e41ec3fd7aa5/0/-17_3/4044000000000000,4032000000000000,4047100000000000/// => -2/3f847ae147ae147b/0/2116ed5565b03f5/267f68c38c01060/0/-17_3/1fac9a7b3b7302f,1e81be3bb5811c4,1fee3bbc808d6c3///
+mul 1a56e1fc2f8f359 3/3f50624dd2f1a9fc/404a000000000000/407d2001fb75bd29/40d56f539fbbc56a/1/-3_2,0_1,0_1/404a800000000000,4032000000000000,403d000000000000,0/-15_4,0_2,1_3/4054000000000000,401c000000000000,0,4041800000000000,0,4049000000000000,3f3fb75bd29342fa,4054000000000000,404f000000000000/ => 3/3f50624dd2f1a9fc/2016979ce6a45b8/233813c3c4c3607/28cb5a5ad75fd07/1/-3_2,0_1,0_1/201bf324d762986,1e81be3bb5811c4,1f36bccc8b19c89,0/-15_4,0_2,1_3/20ac9a7b3b7302f,1d2c05bca99d4ee,0,1f77072bd404a29,0,200be08d0527e1e,f53d7a08b3cd0e,20ac9a7b3b7302f,204c2aec4e12bbe/
+mul 1a56e1fc2f8f359 1/3f50624dd2f1a9fc/3f3796339dfe3046/405a400a5bf1b337/408f5cac73d41880/1/6_1,1_3/4053800000000000,3f31d9932edc12fc,0,403b000000000000/// => 1/3f50624dd2f1a9fc/ef977b34ac05bc/211945cfded2c43/24500beddae3b93/1/6_1,1_3/20a1e36b59f6894,e7e86c70740135,0,1f214eacc820d53///
+mul 1a56e1fc2f8f359 -53/0/0/0/0/0/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/0/////bff0000000000000,0,3fe0000000000000,4024000000000000
+mul c008000000000000 -53/0/0/4064840000000000/40928d51b8747910/3/1_3/4057800000000000,0,4051880000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/8000000000000000/c07ec60000000000/c0abd3fa94aeb598/3/1_3/c071a00000000000,8000000000000000,c06a4c0000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+mul 4000000000000000 -53/0/0/404a000000000000/c091168760aaa173/1/0_2/4034000000000000,4040000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/405a000000000000/c0a1168760aaa173/1/0_2/4044000000000000,4050000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+mul 0 -1/0/4018000000000000/406da807f559a70f/40cc46d24f95b538/3/-19_1,1_1/4046800000000000,4056800000000000/5_2,1_1/3f4fd5669c3be9f9,0,4058100000000000/ => -1/0/0/0/0/3/-19_1,1_1/0,0/5_2,1_1/0,0,0/
+mul 3fe0000000000000 2/3f50624dd2f1a9fc/0/4064640000000000/409c5a030db8305b/3/9_2/4008000000000000,4044800000000000/-15_3/401e000000000000,4040d00000000000,4053800000000000/ => 2/3f50624dd2f1a9fc/0/4054640000000000/408c5a030db8305b/3/9_2/3ff8000000000000,4034800000000000/-15_3/400e000000000000,4030d00000000000,4043800000000000/
+mul bff0000000000000 -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////3ff0000000000000,4000000000000000,4014000000000000
+mul 1a56e1fc2f8f359 -4/3f847ae147ae147b/403a000000000000/4063200ab673aca9/40bc17739b03adef/0/-1_2/3f4fdd07f736941d,4032000000000000/4_1,2_2/4056c00000000000,4032000000000000,3f35f98d76d5177a/ => -4/3f847ae147ae147b/1f16979ce6a45b8/2199db0504104cc/272d0105cfffd32/0/-1_2/10556b4a5e137e5,1e81be3bb5811c4/4_1,2_2/20e78952939fa03,1e81be3bb5811c4,ed6ec8f7d27b98/
+mul 0 5/255bba08cf8c979d/0/4053181042bd50c2/407e9e6194f2bb6a/3/-2_2,0_3,0_2/4008000000000000,0,4024000000000000,3f5042bd50c1e7b6,0,0,404fb00000000000/// => 5/255bba08cf8c979d/0/0/0/3/-2_2,0_3,0_2/0,0,0,0,0,0,0///
+mul 1a56e1fc2f8f359 -53/0/0/0/0/3/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/3/////3ff0000000000000,4000000000000000,4014000000000000
+mul 0 0/3f847ae147ae147b/4050080000000000/4050080000000000/409e018ecef5d0c3/0///// => 0/3f847ae147ae147b/0/0/0/0/////
+mul 7ff8000000000001 3/3f50624dd2f1a9fc/4050800000000000/406d380000000000/4090dfe976a37a3f/0/0_3,1_2/4056580000000000,4033600000000000,4047800000000000,4028000000000000,0/// => 3/3f50624dd2f1a9fc/7ff8000000000001/7ff8000000000001/7ff8000000000001/0/0_3,1_2/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001///
+mul 0 1/3f50624dd2f1a9fc/4046200000000000/4046202432d992b6/4099ec16445c10a0/0/-14_1,0_2/0,3f48e156dcaa4422,3f36a3056c1757d0/// => 1/3f50624dd2f1a9fc/0/0/0/0/-14_1,0_2/0,0,0///
+mul 1a56e1fc2f8f359 -1/3fe0000000000000/0/4056c00df6f95f24/40b2699298f342cd/0/3_2/4048800000000000,3f4bedf2be47792c/-14_1,2_1/4045000000000000,0/ => -1/3fe0000000000000/0/20e78a7dd7ef1ff/268a94ac5856658/0/3_2/200685051469a50,102b444f7fbfdaa/-14_1,2_1/1fc2089afe6bf65,0/
+mul 1a56e1fc2f8f359 3/3fe0000000000000/4057000000000000/407aa000648d2132/40ab21dd1a73095a/3/-5_4,0_3/404d000000000000,4055c00000000000,4056400000000000,4048000000000000,3f1923484c7391f1,404a000000000000,0/// => 3/3fe0000000000000/20ece4da845ddd0/231d4a0b08fc931/2622b986f84fc69/3/-5_4,0_3/2036bccc8b19c89,20d21b32d0a6acd,20dcd242b223268,2001297d23ab683,d0d5a9ae0a2605,2016979ce6a45b8,0///
+mul c008000000000000 1/255bba08cf8c979d/4054800000000000/407e7602411087d0/40bbcddf5500fabb/1/-4_1,1_4,0_2/3f4208843e7b08c3,4050500000000000,403c000000000000,404e000000000000,4000000000000000,0,4040a00000000000/-17_1,1_3,2_1/404d700000000000,4045000000000000,404b000000000000,4000000000000000,404e000000000000/ => 1/255bba08cf8c979d/c06ec00000000000/c096d881b0cc65dc/c0d4da677fc0bc0c/3/-4_1,1_4,0_2/bf5b0cc65db88d24,c068780000000000,c055000000000000,c066800000000000,c018000000000000,8000000000000000,c058f00000000000/-17_1,1_3,2_1/c066140000000000,c05f800000000000,c064400000000000,c018000000000000,c066800000000000/
+mul bff0000000000000 3/3f847ae147ae147b/0/0/0/1///// => 3/3f847ae147ae147b/8000000000000000/8000000000000000/8000000000000000/3/////
+mul 4000000000000000 -4/3f847ae147ae147b/0/0/0/1///// => -4/3f847ae147ae147b/0/0/0/1/////
+mul 7ff0000000000000 -4/255bba08cf8c979d/4053f00000000000/4053f00000000000/40b2f9937aa25df5/3///// => -4/255bba08cf8c979d/7ff0000000000000/7ff0000000000000/7ff0000000000000/3/////
+mul c008000000000000 -2/0/0/406aa00dcccc5a47/c0a74c525c0b3e35/0/3_4,2_2,2_4/0,4033000000000000,3f430c0054e77ff8,4040000000000000,4039000000000000,0,4057000000000000,3f353427590de1f4,4046800000000000,3f498d1d67ab695e/// => -2/0/8000000000000000/c083f80a599943b5/40c1793dc5086ea8/3/3_4,2_2,2_4/8000000000000000,c04c800000000000,bf5c92007f5b3ff4,c058000000000000,c052c00000000000,8000000000000000,c071400000000000,bf4fce3b0594d2ee,c060e00000000000,bf6329d60dc08f06///
+mul 3fe0000000000000 0/3fe0000000000000/403a000000000000/4074c00205b564a4/40d66f77ccd15acb/2/-14_3,0_3,2_3/4049000000000000,3f402dab251bb69b,4043800000000000,401c000000000000,4057000000000000,0,4051800000000000,4042800000000000,4026000000000000/// => 0/3fe0000000000000/402a000000000000/4064c00205b564a4/40c66f77ccd15acb/2/-14_3,0_3,2_3/4039000000000000,3f302dab251bb69b,4033800000000000,400c000000000000,4047000000000000,0,4041800000000000,4032800000000000,4016000000000000///
+mul 3fe0000000000000 5/3f50624dd2f1a9fc/0/405f500df829b8e5/c09cefd9226bc51f/1/1_4/4046000000000000,0,3f4bf05371c9ca7c,4054500000000000/// => 5/3f50624dd2f1a9fc/0/404f500df829b8e5/c08cefd9226bc51f/1/1_4/4036000000000000,0,3f3bf05371c9ca7c,4044500000000000///
+mul 1a56e1fc2f8f359 8/255bba08cf8c979d/0/407b300801b49efe/40dbb5b2b3dd4511/0/-18_1,2_4/0,404c000000000000,4050800000000000,4057c00000000000,4018000000000000/9_3,0_4,2_2/4053800000000000,3f46b21be9a9d8f1,3f410b936f5d2942,0,4057c00000000000,4024000000000000,0,403d000000000000,3f484ff59eeae180/ => 8/255bba08cf8c979d/0/232351558d2da69/2928e995d2dba73/0/-18_1,2_4/0,202c05bca99d4ee,2061990c110baf4,20fcf7725698938,1d01297d23ab683/9_3,0_4,2_2/20a1e36b59f6894,fe65fa303c257a,f6d482edeb20b9,0,20fcf7725698938,1dac9a7b3b7302f,0,1f36bccc8b19c89,10048242e3442fd/
+div 7ff0000000000000 -53/0/0/4050800000000000/40a07ed602bf8fa0/2/0_2/3ff0000000000000,4050400000000000///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/2/0_2/0,0///3ff0000000000000,4014000000000000,4024000000000000
+div 3fe0000000000000 1/3f50624dd2f1a9fc/0/40729402bd385f43/40a2b28fdae8f9b3/0/9_2,1_3,1_2/4056000000000000,4053400000000000,0,3f45e9c2fa1607cc,0,4046800000000000,4055d00000000000/// => 1/3f50624dd2f1a9fc/0/40829402bd385f43/40b2b28fdae8f9b3/0/9_2,1_3,1_2/4066000000000000,4063400000000000,0,3f55e9c2fa1607cc,0,4056800000000000,4065d00000000000///
+div 4000000000000000 2/3fe0000000000000/3f365a62920e64e2/4070a00472bb09c0/c0af61f31132aa5a/0/-20_2,2_3/4036000000000000,4056c00000000000,4056400000000000,3f4868a704f2eb68,4050000000000000/// => 2/3fe0000000000000/3f265a62920e64e2/4060a00472bb09c0/c09f61f31132aa5a/0/-20_2,2_3/4026000000000000,4046c00000000000,4046400000000000,3f3868a704f2eb68,4040000000000000///
+div 1a56e1fc2f8f359 3/0/0/407f800000000000/40dd87820eaba596/1/-7_1,0_2,2_2/4054000000000000,4054400000000000,403e000000000000,4054480000000000,4052000000000000/-2_1,0_2/4018000000000000,404ff00000000000,4056800000000000/ => 3/0/0/7ec784ab95e073c5/7f260c02d4c816c7/1/-7_1,0_2,2_2/7e9ddd4baa009302,7e9e3cdc9c2094d9,7e8665f8bf806e42,7e9e48ceba649514,7e9ae0c41900844f/-2_1,0_2/7e61eb2d66005835,7e97d84a69bc7561,7ea0cc7a8fa052b1/
+div bff0000000000000 0/0/0/0/8000000000000000/0///// => 0/0/8000000000000000/8000000000000000/0/3/////
+div 7ff8000000000001 -2/255bba08cf8c979d/0/0/0/3///// => -2/255bba08cf8c979d/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/////
+div 7ff8000000000001 -1/3fe0000000000000/3f41ba08ef905d23/4079f60237411df2/409d759dfbbedaf3/2/-10_3,1_1,1_4/0,403f000000000000,0,4056400000000000,4056c00000000000,405c980000000000,4056400000000000,3ff0000000000000/// => -1/3fe0000000000000/7ff8000000000001/7ff8000000000001/7ff8000000000001/2/-10_3,1_1,1_4/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001///
+div 1a56e1fc2f8f359 -53/0/0/405e580000000000/40b5df7791406273/3/0_1/405e580000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/7ea6a7ac65f66f85/7f00549f84476e65/3/0_1/7ea6a7ac65f66f85///3ff0000000000000,4000000000000000,4014000000000000
+div 1a56e1fc2f8f359 -4/0/0/4050800000000000/407375ac3efd8df7/3/-16_1/4050800000000000/// => -4/0/0/7e98a35e6c407948/7ebd0ebe0fbccc92/3/-16_1/7e98a35e6c407948///
+div 3fe0000000000000 -1/3f847ae147ae147b/4041000000000000/4041000000000000/c089975fb9ef71b1/0///// => -1/3f847ae147ae147b/4051000000000000/4051000000000000/c099975fb9ef71b1/0/////
+div 3fe0000000000000 -53/0/0/3f5a49653ea126b6/3f942500c6e98104/0/1_3/0,3f46f469a2a9f6c4,3f4d9e60da9856a8///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/3f6a49653ea126b6/3fa42500c6e98104/0/1_3/0,3f56f469a2a9f6c4,3f5d9e60da9856a8///3ff0000000000000,4000000000000000,4014000000000000
+div 7ff0000000000000 -2/3f50624dd2f1a9fc/0/404d000000000000/409b040bcaaacc50/1/-14_1/404d000000000000/// => -2/3f50624dd2f1a9fc/0/0/0/1/-14_1/0///
+div bff0000000000000 0/3f50624dd2f1a9fc/402a000000000000/408211023c598844/c0cf2fd41370a314/3/1_4,1_4,2_3/404c800000000000,0,4049900000000000,0,4037000000000000,3f233ec89a66f774,4058c00000000000,4058000000000000,4047400000000000,3f4185520176726c,0/4_3,0_2/3f3ae128b862e830,4050280000000000,404e000000000000,403d000000000000,4043700000000000/ => 0/3f50624dd2f1a9fc/c02a000000000000/c08211023c598844/40cf2fd41370a314/3/1_4,1_4,2_3/c04c800000000000,8000000000000000,c049900000000000,8000000000000000,c037000000000000,bf233ec89a66f774,c058c00000000000,c058000000000000,c047400000000000,bf4185520176726c,8000000000000000/4_3,0_2/bf3ae128b862e830,c050280000000000,c04e000000000000,c03d000000000000,c043700000000000/
+div bff0000000000000 -4/255bba08cf8c979d/0/4063cc04e2b03e08/40b8a65601edffe5/1/-19_4/3f438ac0f822403e,4058c00000000000,401d800000000000,404a000000000000/// => -4/255bba08cf8c979d/8000000000000000/c063cc04e2b03e08/c0b8a65601edffe5/3/-19_4/bf438ac0f822403e,c058c00000000000,c01d800000000000,c04a000000000000///
+div 0 -53/0/0/0/8000000000000000/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/fff8000000000000/fff8000000000000/fff8000000000000/1/////bff0000000000000,0,3fe0000000000000,4024000000000000
+div 3fe0000000000000 2/0/0/0/8000000000000000/0///// => 2/0/0/0/8000000000000000/0/////
+div 7ff0000000000000 5/255bba08cf8c979d/3f470a203f96b7dd/407fa409a7e4bc07/40c208eececd4f58/2/-4_1,2_3/4050400000000000,4051c00000000000,3f4a68fbd3c54304,0/-18_3,1_4,2_3/0,3f3701e4e7f69250,4053000000000000,4014000000000000,3f3fce80590e5290,4051500000000000,3ee8f5cb15e231ab,4051800000000000,4058400000000000,404a800000000000/ => 5/255bba08cf8c979d/0/0/0/2/-4_1,2_3/0,0,0,0/-18_3,1_4,2_3/0,0,0,0,0,0,0,0,0,0/
+div 1a56e1fc2f8f359 1/3fe0000000000000/401a000000000000/4059600000000000/c0a54a444fa91b24/3/-20_4/0,4051800000000000,0,4039000000000000/// => 1/3fe0000000000000/7e6369712e805f8e/7ea2f1fbffd85d42/feefca750b6a4ca4/3/-20_4/0,7e9a21a234c080a2,0,7e82aa4f4a405be1///
+div 7ff8000000000001 -53/0/0/0/8000000000000000/0/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/0/////3ff0000000000000,4000000000000000,4014000000000000
+div 0 5/3f847ae147ae147b/4055c00000000000/4068100000000000/40c31a4a1dea6b6f/3/9_2/4044c00000000000,4050000000000000/// => 5/3f847ae147ae147b/7ff0000000000000/7ff0000000000000/7ff0000000000000/3/////
+div c008000000000000 -53/0/0/0/0/0/////4000000000000000 => -53/0/8000000000000000/8000000000000000/8000000000000000/3/////4000000000000000
+div 0 0/255bba08cf8c979d/4056f80000000000/40713e0371fb1412/c0ab40a3c7d04f6c/3/-1_3/4055c00000000000,4054c00000000000,3f4b8fd8a08f3d1d/-10_2/0,402c000000000000/ => 0/255bba08cf8c979d/7ff0000000000000/7ff0000000000000/fff0000000000000/3/////
+div 1a56e1fc2f8f359 0/3fe0000000000000/403b000000000000/40827f01b90bdb88/c0b972629c1412b4/3/-18_3,1_3,1_2/4040000000000000,4039000000000000,4057800000000000,0,404c800000000000,405a500000000000,4058c00000000000,404f900000000000/5_2,2_2/4010000000000000,404f400000000000,3f4b90bdb885a6f3,4037000000000000/ => 0/3fe0000000000000/7e84289312c0633b/7ecb9e6a4c0c8112/ff02ffb60165e1b9/3/-18_3,1_3,1_2/7e87e43c8800759b,7e82aa4f4a405be1,7ea18b9c73e0565e,0,7e954745e92068be,7ea3a52bc5d460b4,7ea27a86d1305af6,7e97909db4247400/5_2,2_2/7e57e43c8800759b,7e9754e31cd072da,7d9494a3c8ee0dde,7e812c0b81c05488/
+div 3fe0000000000000 -53/0/0/0/8000000000000000/2/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/8000000000000000/2/////3ff0000000000000,4014000000000000,4024000000000000
+div 7ff0000000000000 8/255bba08cf8c979d/0/404b500000000000/c0830261104ef92a/3/2_1,0_3/0,0,4046d00000000000,4022000000000000/// => 8/255bba08cf8c979d/0/0/8000000000000000/3/2_1,0_3/0,0,0,0///
+div 7ff8000000000001 -2/3f50624dd2f1a9fc/0/4055d00000000000/40b0bc9e2a48ecb7/3/3_1,2_1/4037000000000000,4050100000000000/// => -2/3f50624dd2f1a9fc/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/3_1,2_1/7ff8000000000001,7ff8000000000001///
+div c008000000000000 5/3fe0000000000000/4031000000000000/4031000000000000/40865a0d2d31b685/1///// => 5/3fe0000000000000/c016aaaaaaaaaaab/c016aaaaaaaaaaab/c06dcd66e6ecf35c/3/////
+div 1a56e1fc2f8f359 2/3fe0000000000000/0/406984089b4684c0/40cb7767b0c6889e/2/-18_3,0_4,2_2/3f4be2d516196f4c,3ff0000000000000,0,3f2a2913f3a0da24,0,4055000000000000,4042000000000000,0,4054c80000000000/// => 2/3fe0000000000000/0/7eb30ce330eeab5b/7f1481b93e7881d5/2/-18_3,0_4,2_2/7d94d1ee15f3b6c2,7e37e43c8800759b,0,7d73881c8177d49a,0,7e9f5b8f72809a5c,7e8ae0c41900844f,0,7e9f07f09ea498c0///
+div 4000000000000000 5/3f847ae147ae147b/4056000000000000/4073c00000000000/40bce4bee98542da/2/-4_2,1_4/4050180000000000,403dc00000000000,4045600000000000,3ff2000000000000,0,4010000000000000/-17_2/0,4055800000000000/ => 5/3f847ae147ae147b/4046000000000000/4063c00000000000/40ace4bee98542da/2/-4_2,1_4/4040180000000000,402dc00000000000,4035600000000000,3fe2000000000000,0,4000000000000000/-17_2/0,4045800000000000/
+div 7ff0000000000000 -53/0/0/0/8000000000000000/1/////4000000000000000 => -53/0/0/0/8000000000000000/1/////4000000000000000
+div 7ff8000000000001 3/3fe0000000000000/4047000000000000/4047000000000000/40a32fcbdd848ae9/0///// => 3/3fe0000000000000/7ff8000000000001/7ff8000000000001/7ff8000000000001/0/////
+div 7ff0000000000000 1/3fe0000000000000/4057600000000000/4084e8030f1a38fc/40b9734b0a57fa87/1/-5_4,0_1,2_2/4039000000000000,3f46787729405639,0,0,4050800000000000,4049800000000000,4057800000000000/-6_4,0_1,1_4/4052580000000000,3f4a792c6676de69,4035000000000000,0,4051000000000000,4047800000000000,0,4045000000000000,4056080000000000/ => 1/3fe0000000000000/0/0/0/1/-5_4,0_1,2_2/0,0,0,0,0,0,0/-6_4,0_1,1_4/0,0,0,0,0,0,0,0,0/
+div bff0000000000000 -2/3fe0000000000000/3f41765190f842ca/40460012412e5a90/40927a89134481f8/3/-1_4,0_3/0,3ef95b9932e5a003,0,4030000000000000,0,4000000000000000,403a000000000000/// => -2/3fe0000000000000/bf41765190f842ca/c0460012412e5a90/c0927a89134481f8/3/-1_4,0_3/8000000000000000,bef95b9932e5a003,8000000000000000,c030000000000000,8000000000000000,c000000000000000,c03a000000000000///
+div 7ff8000000000001 2/3f847ae147ae147b/4056c00000000000/4072e00000000000/40d3938606d0a407/3/9_3/4050c00000000000,4047800000000000,4058400000000000/// => 2/3f847ae147ae147b/7ff8000000000001/7ff8000000000001/7ff8000000000001/3/9_3/7ff8000000000001,7ff8000000000001,7ff8000000000001///
+div 7ff0000000000000 -1/3f847ae147ae147b/404a000000000000/406500024b281148/408d197e780f6703/3/-3_4/4026000000000000,3f3259408a3f0d59,403d000000000000,4053000000000000/// => -1/3f847ae147ae147b/0/0/0/3/-3_4/0,0,0,0///
+div 4000000000000000 -53/0/0/4034800000000000/4087e8d31f1fceb8/3/1_1/4034800000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4024800000000000/4077e8d31f1fceb8/3/1_1/4024800000000000///3ff0000000000000,4000000000000000,4014000000000000
+div bff0000000000000 -53/0/0/4034000000000000/4070229d6444497f/0/0_1/4034000000000000///4000000000000000 => -53/0/8000000000000000/c034000000000000/c070229d6444497f/3/0_1/c034000000000000///4000000000000000
+div 1a56e1fc2f8f359 -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000
+div 0 8/3f847ae147ae147b/4031800000000000/4061d40c95ed9273/c09f646086c9e47c/0///1_4,0_1/403a000000000000,4030200000000000,4054c00000000000,3f423e26ba7ef909,3f500cc7c7a6fe56/ => 8/3f847ae147ae147b/7ff0000000000000/7ff0000000000000/fff0000000000000/0/////
+div 4000000000000000 1/0/4022000000000000/407d440000000000/c0b81e6c35398b81/3/-15_3/404a000000000000,4055c00000000000,4050b80000000000/-5_2,0_3/4057800000000000,0,4046400000000000,4053780000000000,4042800000000000/ => 1/0/4012000000000000/406d440000000000/c0a81e6c35398b81/3/-15_3/403a000000000000,4045c00000000000,4040b80000000000/-5_2,0_3/4047800000000000,0,4036400000000000,4043780000000000,4032800000000000/
+div 4000000000000000 8/3f50624dd2f1a9fc/4020000000000000/407d4c0000000000/c097b2dbbbefa7a6/1/-15_3,0_3/403c000000000000,0,404e000000000000,4056400000000000,4052280000000000,4054400000000000/-17_2,0_3/4056c80000000000,4042800000000000,0,4000000000000000,0/ => 8/3f50624dd2f1a9fc/4010000000000000/406d4c0000000000/c087b2dbbbefa7a6/1/-15_3,0_3/402c000000000000,0,403e000000000000,4046400000000000,4042280000000000,4044400000000000/-17_2,0_3/4046c80000000000,4032800000000000,0,3ff0000000000000,0/
+div 0 -2/3f847ae147ae147b/0/4074de0229b3e62d/40cf6acae7b0cdcb/2/-3_4,2_1,1_3/3f26e84132ff7eb0,404c800000000000,4049800000000000,405ef80000000000,4052400000000000,0,403d000000000000,3f37271dc95184f5/// => -2/3f847ae147ae147b/fff8000000000000/7ff0000000000000/7ff0000000000000/2/////
+div 7ff8000000000001 -2/0/4055a80000000000/4065f80000000000/c0ae8b0b4416a910/1/7_4/404f800000000000,4014800000000000,4035000000000000,0/// => -2/0/7ff8000000000001/7ff8000000000001/7ff8000000000001/1/7_4/7ff8000000000001,7ff8000000000001,7ff8000000000001,7ff8000000000001///
+div 4000000000000000 3/0/0/4045000000000000/40a660c513c5bc85/2/9_2/4039000000000000,4031000000000000/// => 3/0/0/4035000000000000/409660c513c5bc85/2/9_2/4029000000000000,4021000000000000///
+div 3fe0000000000000 -53/0/0/405dc00000000000/409f1e24370390ab/0/0_2,0_3/0,4010000000000000,4041000000000000,4054400000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/406dc00000000000/40af1e24370390ab/0/0_2,0_3/0,4020000000000000,4051000000000000,4064400000000000,0///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+div 4000000000000000 -53/0/0/4008014b0f804645/4060fe773c26ee19/1/0_3/3f44b0f804644cdf,0,4008000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/3ff8014b0f804645/4050fe773c26ee19/1/0_3/3f34b0f804644cdf,0,3ff8000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+div bff0000000000000 -4/3f847ae147ae147b/0/406198037275413b/40aac3b565541b43/0/2_1,0_2/4050c00000000000,403f000000000000,3f32d62153b2e148/-10_3,1_1/4028000000000000,0,403ec00000000000,3f217b116c51edd5/ => -4/3f847ae147ae147b/8000000000000000/c06198037275413b/c0aac3b565541b43/3/2_1,0_2/c050c00000000000,c03f000000000000,bf32d62153b2e148/-10_3,1_1/c028000000000000,8000000000000000,c03ec00000000000,bf217b116c51edd5/
+div 0 1/255bba08cf8c979d/4047000000000000/407178008f54aaf4/40c5b258961e7c2c/3/-16_1,0_4/403dc00000000000,4051280000000000,4051000000000000,3f21ea955e71c4cb,4050c80000000000/// => 1/255bba08cf8c979d/7ff0000000000000/7ff0000000000000/7ff0000000000000/3/////
+div 0 -53/0/0/405ac00486270629/40a9ff87debd359e/1/0_1,1_2/3f32189c18a3ea15,404c800000000000,4049000000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/fff8000000000000/7ff0000000000000/7ff0000000000000/1/////3ff0000000000000,4000000000000000,4014000000000000
+div 3fe0000000000000 -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000
+div 4000000000000000 5/3fe0000000000000/0/0/0/0///// => 5/3fe0000000000000/0/0/0/0/////
+div 3fe0000000000000 -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/1/////bff0000000000000,0,3fe0000000000000,4024000000000000
+div 1a56e1fc2f8f359 5/255bba08cf8c979d/3f39f171a3339598/4060800d8f103059/40b06ee0eacd86cd/0/-8_4,0_1/0,3f4e51cf106ef985,3f35e371beb61a86,404c000000000000,4053000000000000/// => 5/255bba08cf8c979d/7d835e9309ef775e/7ea8a372ab51b136/7ef889cd8213c3a1/0/-8_4,0_1/0,7d96a30d1165384e,7d805797b2fdedff,7e94e7b4f70066e8,7e9c5f07e1808ba9///
+div bff0000000000000 5/3f50624dd2f1a9fc/0/4071d40000000000/c097b1812ca5a24b/2/-20_2,1_3/4032e00000000000,0,4057000000000000,4050100000000000,4049100000000000/-12_1/404e000000000000/ => 5/3f50624dd2f1a9fc/8000000000000000/c071d40000000000/4097b1812ca5a24b/3/-20_2,1_3/c032e00000000000,8000000000000000,c057000000000000,c050100000000000,c049100000000000/-12_1/c04e000000000000/
+div c008000000000000 -53/0/0/4040801809b6ba0d/c08acbc1d2a5ae46/3/1_2/3f4809b6ba0d2783,4040800000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/8000000000000000/c02600200cf3a2bc/4071dd2be1c3c984/3/1_2/bf300679d15e1a57,c026000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+div 3fe0000000000000 -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000
+div bff0000000000000 2/3f847ae147ae147b/0/0/0/0///// => 2/3f847ae147ae147b/8000000000000000/8000000000000000/8000000000000000/3/////
+div 3fe0000000000000 -53/0/0/405a000000000000/40b8fb3d5c1fe3af/1/0_1,0_1/4057000000000000,4028000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/406a000000000000/40c8fb3d5c1fe3af/1/0_1,0_1/4067000000000000,4038000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+div bff0000000000000 -1/3f847ae147ae147b/0/404a3036722cd802/408605197a2463a7/1/8_4,2_2/402cc00000000000,4043000000000000,3f42c6c43c712d00,0,3f231c12bebed4f0,3f4ee463ebe124cb/// => -1/3f847ae147ae147b/8000000000000000/c04a3036722cd802/c08605197a2463a7/3/8_4,2_2/c02cc00000000000,c043000000000000,bf42c6c43c712d00,8000000000000000,bf231c12bebed4f0,bf4ee463ebe124cb///
+div c008000000000000 3/255bba08cf8c979d/404f000000000000/404f000000000000/4084102a10652819/1///// => 3/255bba08cf8c979d/c034aaaaaaaaaaab/c034aaaaaaaaaaab/c06ac03815dc3577/3/////
+div 7ff0000000000000 5/3f847ae147ae147b/0/4057c004345349df/40b34e5aefd68e70/3/9_1,1_2/403f000000000000,4050000000000000,3f30d14d277aaa36/// => 5/3f847ae147ae147b/0/0/0/3/9_1,1_2/0,0,0///
+div 1a56e1fc2f8f359 -2/0/0/40712801e670ab65/40c74a53a1608859/0/-6_4,0_1,2_1/405e600000000000,0,4058000000000000,4045000000000000,402e000000000000,3f3e670ab64ee670/// => -2/0/0/7eb99e3dbe316a54/7f116389be343967/0/-6_4,0_1,2_1/7ea6ada575186fa3,0,7ea1eb2d66005835,7e8f5b8f72809a5c,7e7665f8bf806e42,7d86b2e761c61ae2///
+div 1a56e1fc2f8f359 3/3f847ae147ae147b/0/4054c80000000000/c05c01adb7e36858/2///-6_1/4054c80000000000/ => 3/3f847ae147ae147b/0/7e9f07f09ea498c0/fea4e8f5cc16e94d/2///-6_1/7e9f07f09ea498c0/
+div bff0000000000000 3/3fe0000000000000/3f5058bc77f4fda0/407450065c643d6e/40c9041cf81f6207/1/8_1/4050800000000000/5_2,2_4/4051800000000000,3f3f76dc3b060e6c,404e000000000000,3f13b1d6f0139b52,404c000000000000,4052400000000000/ => 3/3fe0000000000000/bf5058bc77f4fda0/c07450065c643d6e/c0c9041cf81f6207/3/8_1/c050800000000000/5_2,2_4/c051800000000000,bf3f76dc3b060e6c,c04e000000000000,bf13b1d6f0139b52,c04c000000000000,c052400000000000/
+div bff0000000000000 -2/3f847ae147ae147b/0/406e4003cf262f14/c09852734f6e1bda/0/-2_3,1_2,0_4/404e900000000000,0,0,4047700000000000,4039000000000000,3f3e7931789c0afa,4054800000000000,4036000000000000,4014000000000000/// => -2/3f847ae147ae147b/8000000000000000/c06e4003cf262f14/409852734f6e1bda/3/-2_3,1_2,0_4/c04e900000000000,8000000000000000,8000000000000000,c047700000000000,c039000000000000,bf3e7931789c0afa,c054800000000000,c036000000000000,c014000000000000///
+div 1a56e1fc2f8f359 -1/255bba08cf8c979d/0/0/0/0///// => -1/255bba08cf8c979d/0/0/0/0/////
+div c008000000000000 -53/0/0/404b000cf47e299e/4092684384254a03/2/0_2/3f39e8fc533c0b6a,404b000000000000///4000000000000000 => -53/0/8000000000000000/c0320008a2fec669/c0788b04b031b804/3/0_2/bf2145fd8cd2b247,c032000000000000///4000000000000000
+div 1a56e1fc2f8f359 -4/3f50624dd2f1a9fc/0/4008000000000000/c0517b79739b8d0b/3/3_4/0,4008000000000000,0,0/// => -4/3f50624dd2f1a9fc/0/7e51eb2d66005835/fe9a1ae03c807db8/3/3_4/0,7e51eb2d66005835,0,0///
+div bff0000000000000 1/3fe0000000000000/0/406660000dabd897/c0ac40e00ee10a9d/1/-10_2,0_1,2_1/404c000000000000,3edb57b12dfcf101,4052c00000000000,4048000000000000/// => 1/3fe0000000000000/8000000000000000/c06660000dabd897/40ac40e00ee10a9d/3/-10_2,0_1,2_1/c04c000000000000,bedb57b12dfcf101,c052c00000000000,c048000000000000///
+div 7ff0000000000000 -2/0/4058080000000000/4077d40000000000/40d27ee42bde0475/1/9_2/4032e00000000000,4053400000000000/8_4/4052400000000000,0,0,405d100000000000/ => -2/0/0/0/0/1/9_2/0,0/8_4/0,0,0,0/
+div bff0000000000000 2/3f50624dd2f1a9fc/0/4073080000000000/40a001e90d7594a5/3/-4_4,0_2/404b000000000000,4044a00000000000,4014000000000000,4050400000000000,4038000000000000,0/-5_2/4028000000000000,4059d00000000000/ => 2/3f50624dd2f1a9fc/8000000000000000/c073080000000000/c0a001e90d7594a5/3/-4_4,0_2/c04b000000000000,c044a00000000000,c014000000000000,c050400000000000,c038000000000000,8000000000000000/-5_2/c028000000000000,c059d00000000000/
+div 7ff0000000000000 1/255bba08cf8c979d/401d000000000000/401d000000000000/40671dbdfa898d5d/3///// => 1/255bba08cf8c979d/0/0/0/3/////
+div c008000000000000 -53/0/0/4054d8150b94d2b3/4078311f53d604f1/1/0_1,1_3/4008000000000000,3f3bcb24d58d0d9c,4054180000000000,3f4c31973a9f5ea5///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/8000000000000000/c03bcac6ba1bc399/c06020bf8d3958a1/3/0_1,1_3/bff0000000000000,bf22876de3b35e68,c03acaaaaaaaaaab,bf32cbba2714e9c3///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+div 4000000000000000 -4/255bba08cf8c979d/4055c00000000000/40743002144150f4/40b416e4035b46cc/0/2_4,1_2/4047800000000000,3f40a20a87a04cec,403e000000000000,403c000000000000,404b000000000000,4053400000000000/// => -4/255bba08cf8c979d/4045c00000000000/40643002144150f4/40a416e4035b46cc/0/2_4,1_2/4037800000000000,3f30a20a87a04cec,402e000000000000,402c000000000000,403b000000000000,4043400000000000///
+div 0 3/3f847ae147ae147b/0/407f9e013aeb5f3c/40b939693dd31741/2/9_2,0_3/0,3f33aeb5f3c0bf07,4055800000000000,4058280000000000,405a900000000000/-7_1,1_4/4049000000000000,4057c00000000000,4052000000000000,0,0/ => 3/3f847ae147ae147b/fff8000000000000/7ff0000000000000/7ff0000000000000/2/////
+div 0 -4/3f847ae147ae147b/0/4069600000000000/40c215d36c872b38/0/-19_1,0_2,2_1/401c000000000000,0,4058c00000000000,4058400000000000/// => -4/3f847ae147ae147b/fff8000000000000/7ff0000000000000/7ff0000000000000/0/////
+div 7ff0000000000000 5/255bba08cf8c979d/0/4052c80000000000/40a0010f7ee2a610/2/5_2/402e400000000000,404e000000000000/// => 5/255bba08cf8c979d/0/0/0/2/5_2/0,0///
+div 4000000000000000 -53/0/0/405e400000000000/40ae5bd29c4fcf33/2/1_3/4043000000000000,4054c00000000000,0///3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/404e400000000000/409e5bd29c4fcf33/2/1_3/4033000000000000,4044c00000000000,0///3ff0000000000000,4014000000000000,4024000000000000
+div 7ff0000000000000 -2/3fe0000000000000/0/0/8000000000000000/0///// => -2/3fe0000000000000/0/0/8000000000000000/0/////
+div 7ff0000000000000 0/3fe0000000000000/0/407792014bd580ac/40c78e9f75c8b056/1///-17_3,1_1,1_3/405c880000000000,4054400000000000,4056800000000000,0,3f34bd580ac21b17,404e000000000000,4040000000000000/ => 0/3fe0000000000000/0/0/0/1///-17_3,1_1,1_3/0,0,0,0,0,0,0/
+compact - -1/255bba08cf8c979d/3f2ff1e409c9b20b/4077de0a029ce4ac/c0a0796f4edcc7cf/2/-15_4,2_2,2_2/4054f80000000000,405a000000000000,403c000000000000,3f45bb7aaed13ac1,4038000000000000,4046000000000000,3f4778861ae7f49c,4050c00000000000/-15_1,1_2,0_1/3f1621453fa62ae6,3f482044b13dac68,403f000000000000,0/ => -1/255bba08cf8c979d/3f2ff1e409c9b20b/4077de0a029ce4ac/c0a0796f4edcc7cf/2/-15_4,2_2,2_2/4054f80000000000,405a000000000000,403c000000000000,3f45bb7aaed13ac1,4038000000000000,4046000000000000,3f4778861ae7f49c,4050c00000000000/-15_1,1_2/3f1621453fa62ae6,3f482044b13dac68,403f000000000000/
+compact - 0/3f50624dd2f1a9fc/0/4071c000b8a7b41e/40d0886b4e580c56/2/6_1,1_2,2_4/4057c00000000000,0,3f2714f683c3dec5,0,4052a80000000000,4058580000000000,4031000000000000/// => 0/3f50624dd2f1a9fc/0/4071c000b8a7b41e/40d0886b4e580c56/2/6_1,2_1,3_3/4057c00000000000,3f2714f683c3dec5,4052a80000000000,4058580000000000,4031000000000000///
+compact - -4/3f50624dd2f1a9fc/4049000000000000/406b400000000000/40c6e7fe56eb025a/0/-1_3,0_1/4048000000000000,4038000000000000,4041000000000000,404f000000000000/// => -4/3f50624dd2f1a9fc/4049000000000000/406b400000000000/40c6e7fe56eb025a/0/-1_4/4048000000000000,4038000000000000,4041000000000000,404f000000000000///
+compact - -4/255bba08cf8c979d/0/4072a8007e1431db/40a978c7aba95040/3/0_4,0_3,2_1/3f1f850c76cb4fde,403b000000000000,4052c00000000000,4040000000000000,0,4058400000000000,404c000000000000,4027000000000000/// => -4/255bba08cf8c979d/0/4072a8007e1431db/40a978c7aba95040/3/0_4,1_2,2_1/3f1f850c76cb4fde,403b000000000000,4052c00000000000,4040000000000000,4058400000000000,404c000000000000,4027000000000000///
+compact - 0/255bba08cf8c979d/0/406ffc019de6fe2d/40c0806283902bb3/3/-8_3/4054500000000000,4053c00000000000,0/-20_2,1_2/0,4053400000000000,4032a00000000000,3f29de6fe2cceea5/ => 0/255bba08cf8c979d/0/406ffc019de6fe2d/40c0806283902bb3/3/-8_2/4054500000000000,4053c00000000000/-19_1,1_2/4053400000000000,4032a00000000000,3f29de6fe2cceea5/
+compact - 0/255bba08cf8c979d/0/4080780000000000/c08f59c6770210a2/2/-2_4/4052000000000000,4052800000000000,4058380000000000,404c800000000000/6_3/4054080000000000,4051c00000000000,4053000000000000/ => 0/255bba08cf8c979d/0/4080780000000000/c08f59c6770210a2/2/-2_4/4052000000000000,4052800000000000,4058380000000000,404c800000000000/6_3/4054080000000000,4051c00000000000,4053000000000000/
+compact - 3/3f847ae147ae147b/0/40721001b7c03838/40c8a65f4bbb446e/1/0_3,0_4/4055000000000000,4054800000000000,404c800000000000,3f3b7c038378ea36,4046800000000000,0,4035000000000000/// => 3/3f847ae147ae147b/0/40721001b7c03838/40c8a65f4bbb446e/1/0_5,1_1/4055000000000000,4054800000000000,404c800000000000,3f3b7c038378ea36,4046800000000000,4035000000000000///
+compact - -2/0/4033000000000000/4033000000000000/4092c741b67d5d53/0///// => -2/0/4033000000000000/4033000000000000/4092c741b67d5d53/0/////
+compact - -2/255bba08cf8c979d/3eff53cf386ecbbb/40714a0177c23a13/c0bea4fa8a74656c/3/-9_3,0_2,2_1/404b000000000000,3f3586e6adac6a75,4037000000000000,0,405e680000000000,4053800000000000/// => -2/255bba08cf8c979d/3eff53cf386ecbbb/40714a0177c23a13/c0bea4fa8a74656c/3/-9_3,1_1,2_1/404b000000000000,3f3586e6adac6a75,4037000000000000,405e680000000000,4053800000000000///
+compact - -2/3f847ae147ae147b/4041800000000000/405e400000000000/40b6ca8498a6d2d4/2///7_1/4055800000000000/ => -2/3f847ae147ae147b/4041800000000000/405e400000000000/40b6ca8498a6d2d4/2///7_1/4055800000000000/
+compact - -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/0/0/2/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+compact - 3/255bba08cf8c979d/0/403e000000000000/408b4897b2a4382e/2/-11_1/403e000000000000/// => 3/255bba08cf8c979d/0/403e000000000000/408b4897b2a4382e/2/-11_1/403e000000000000///
+compact - -1/3f847ae147ae147b/4052800000000000/40789a03a6bf2ae8/40d9543fa23b8260/0/-18_2,1_2,1_2/403a000000000000,3f4d35f957443ffa,4058000000000000,4058400000000000,4045d00000000000,404c800000000000/// => -1/3f847ae147ae147b/4052800000000000/40789a03a6bf2ae8/40d9543fa23b8260/0/-18_2,1_2,1_2/403a000000000000,3f4d35f957443ffa,4058000000000000,4058400000000000,4045d00000000000,404c800000000000///
+compact - -4/0/0/407710045dcd7e56/c0bc9472d8e50bae/0/-10_4,0_2/4052000000000000,0,0,0,4053000000000000,3f16fb546efeedd7/-15_2,1_4,0_2/4053000000000000,4057000000000000,0,401c000000000000,3f50035b9fb1992d,4039000000000000,3eb0944ae18ccf27,4035000000000000/ => -4/0/0/407710045dcd7e56/c0bc9472d8e50bae/0/-10_1,3_2/4052000000000000,4053000000000000,3f16fb546efeedd7/-15_2,2_5/4053000000000000,4057000000000000,401c000000000000,3f50035b9fb1992d,4039000000000000,3eb0944ae18ccf27,4035000000000000/
+compact - -1/3f847ae147ae147b/0/4070fc0000000000/40c62587e7433da2/3///8_3,1_2,1_1/404f600000000000,0,4042800000000000,4058000000000000,4042000000000000,4044000000000000/ => -1/3f847ae147ae147b/0/4070fc0000000000/40c62587e7433da2/3///8_1,1_1,1_2,1_1/404f600000000000,4042800000000000,4058000000000000,4042000000000000,4044000000000000/
+compact - -53/0/0/4053800000000000/409b4b815e4b3110/0/0_2/403d000000000000,4048800000000000///4000000000000000 => -53/0/0/4053800000000000/409b4b815e4b3110/0/0_2/403d000000000000,4048800000000000///4000000000000000
+compact - 1/255bba08cf8c979d/0/40340054ac768d8f/4077568ec1faa58a/2/-7_3/3f4a030994666715,3f405331b2610325,4034000000000000/// => 1/255bba08cf8c979d/0/40340054ac768d8f/4077568ec1faa58a/2/-7_3/3f4a030994666715,3f405331b2610325,4034000000000000///
+compact - -2/3fe0000000000000/4041800000000000/4073e401a10614d4/408463433d7d611c/2/6_3/4040c00000000000,4028400000000000,0/-5_3,1_4/4000000000000000,3f3a10614d3c58e3,4041d00000000000,4050400000000000,4046000000000000,0,4056c00000000000/ => -2/3fe0000000000000/4041800000000000/4073e401a10614d4/408463433d7d611c/2/6_2/4040c00000000000,4028400000000000/-5_3,1_2,1_1/4000000000000000,3f3a10614d3c58e3,4041d00000000000,4050400000000000,4046000000000000,4056c00000000000/
+compact - -2/3f50624dd2f1a9fc/0/407a4601b3deb2e6/40bc68cf9c806fe1/2/-18_4,1_2,1_1/404b000000000000,0,0,0,3f25bbeceb21b1b5,403e000000000000,4046000000000000/-19_4,2_4,0_1/403b200000000000,3f305ff4b8c83593,0,4022000000000000,0,4018000000000000,405c900000000000,404a800000000000,4054c00000000000/ => -2/3f50624dd2f1a9fc/0/407a4601b3deb2e6/40bc68cf9c806fe1/2/-18_1,4_2,1_1/404b000000000000,3f25bbeceb21b1b5,403e000000000000,4046000000000000/-19_2,1_1,3_4/403b200000000000,3f305ff4b8c83593,4022000000000000,4018000000000000,405c900000000000,404a800000000000,4054c00000000000/
+compact - -53/0/0/403000050242f2c8/c06dcea534bbfaa2/0/1_2/3f14090bcb2117da,4030000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/403000050242f2c8/c06dcea534bbfaa2/0/1_2/3f14090bcb2117da,4030000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+compact - 5/255bba08cf8c979d/0/407660015d0e2e86/40cec3181814ccbf/2/-6_4,0_1,0_3/4030000000000000,4020000000000000,4028000000000000,4054800000000000,4049800000000000,404a800000000000,4052000000000000,4050000000000000/5_1/3f35d0e2e8591a4b/ => 5/255bba08cf8c979d/0/407660015d0e2e86/40cec3181814ccbf/2/-6_8/4030000000000000,4020000000000000,4028000000000000,4054800000000000,4049800000000000,404a800000000000,4052000000000000,4050000000000000/5_1/3f35d0e2e8591a4b/
+compact - 1/3f50624dd2f1a9fc/0/4022000000000000/4070e79ba389878c/3/-10_1/4022000000000000/// => 1/3f50624dd2f1a9fc/0/4022000000000000/4070e79ba389878c/3/-10_1/4022000000000000///
+compact - 5/0/0/0/0/3///// => 5/0/0/0/0/3/////
+compact - -1/3fe0000000000000/0/406db80f11ab9459/40c21f6a773b668f/1/0_2,1_3,2_3/4057f80000000000,3f24fa8cd34cfde7,404a700000000000,3f4d7aeb5c3a5c88,3f407e47f86bd8bf,4056400000000000,0,3f321daf8fcf1e43/// => -1/3fe0000000000000/0/406db80f11ab9459/40c21f6a773b668f/1/0_2,1_3,2_1,1_1/4057f80000000000,3f24fa8cd34cfde7,404a700000000000,3f4d7aeb5c3a5c88,3f407e47f86bd8bf,4056400000000000,3f321daf8fcf1e43///
+compact - 3/3fe0000000000000/4054c00000000000/4054c00000000000/40b69004e0582b10/0///// => 3/3fe0000000000000/4054c00000000000/4054c00000000000/40b69004e0582b10/0/////
+compact - -2/3f50624dd2f1a9fc/4045000000000000/4045000000000000/c07aa4ed89199d43/0///// => -2/3f50624dd2f1a9fc/4045000000000000/4045000000000000/c07aa4ed89199d43/0/////
+compact - -4/3fe0000000000000/0/0/0/2///// => -4/3fe0000000000000/0/0/0/2/////
+compact - -53/0/0/0/8000000000000000/3/0_1/0///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/8000000000000000/3/////bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 0/255bba08cf8c979d/3f4292956f6ca6cc/4062600e04910742/408ac4863ac881aa/2/8_1/403d000000000000/5_4,0_1/3f4a0f822e622d99,3f36e058fe715e83,404d800000000000,4039000000000000,4041000000000000/ => 0/255bba08cf8c979d/3f4292956f6ca6cc/4062600e04910742/408ac4863ac881aa/2/8_1/403d000000000000/5_5/3f4a0f822e622d99,3f36e058fe715e83,404d800000000000,4039000000000000,4041000000000000/
+compact - 2/0/0/4070700276d4a855/40d0314bb21a5d6d/1/2_1,0_3,1_3/4008000000000000,402e000000000000,4057c00000000000,3f43b6a542a5349d,4050800000000000,402c000000000000,4051800000000000/// => 2/0/0/4070700276d4a855/40d0314bb21a5d6d/1/2_4,1_3/4008000000000000,402e000000000000,4057c00000000000,3f43b6a542a5349d,4050800000000000,402c000000000000,4051800000000000///
+compact - 1/3f847ae147ae147b/0/4053300b3845b085/409a3e0ed2fd4e4d/3/9_4,0_2/3f46708b610a75f7,4039000000000000,4038000000000000,0,4035000000000000,401b000000000000/// => 1/3f847ae147ae147b/0/4053300b3845b085/409a3e0ed2fd4e4d/3/9_3,1_2/3f46708b610a75f7,4039000000000000,4038000000000000,4035000000000000,401b000000000000///
+compact - -1/3f847ae147ae147b/404f500000000000/404f500000000000/c07feb71faad153d/2///// => -1/3f847ae147ae147b/404f500000000000/404f500000000000/c07feb71faad153d/2/////
+compact - 8/0/0/0/0/3///// => 8/0/0/0/0/3/////
+compact - 2/0/0/0/0/1///// => 2/0/0/0/0/1/////
+compact - -53/0/0/405f780000000000/40c02cbb3a403365/3/1_3/4039000000000000,4053380000000000,4038000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/405f780000000000/40c02cbb3a403365/3/1_3/4039000000000000,4053380000000000,4038000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - -53/0/0/4066a40000000000/408616e11de065a0/3/0_1,1_2,0_1/4045000000000000,404f100000000000,0,4053400000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4066a40000000000/408616e11de065a0/3/0_1,1_1,1_1/4045000000000000,404f100000000000,4053400000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000
+compact - -2/255bba08cf8c979d/0/405af80000000000/c0a5471224f2fd47/2/-11_3/404e800000000000,4044000000000000,401b800000000000/// => -2/255bba08cf8c979d/0/405af80000000000/c0a5471224f2fd47/2/-11_3/404e800000000000,4044000000000000,401b800000000000///
+compact - -53/0/0/4064a00000000000/40b133e9cb93bcaf/0/0_1,2_1/4051c00000000000,4057800000000000///3ff0000000000000,4000000000000000,4014000000000000 => -53/0/0/4064a00000000000/40b133e9cb93bcaf/0/0_1,2_1/4051c00000000000,4057800000000000///3ff0000000000000,4000000000000000,4014000000000000
+compact - -53/0/0/0/0/2/////4000000000000000 => -53/0/0/0/0/2/////4000000000000000
+compact - 5/3f847ae147ae147b/0/4078400000000000/40d67a7f3d1e47f3/3/0_1,0_3/0,4058400000000000,4052400000000000,404b800000000000/-4_1,2_1,0_2/403f000000000000,4044800000000000,4044800000000000,4049000000000000/ => 5/3f847ae147ae147b/0/4078400000000000/40d67a7f3d1e47f3/3/1_3/4058400000000000,4052400000000000,404b800000000000/-4_1,2_3/403f000000000000,4044800000000000,4044800000000000,4049000000000000/
+compact - 0/255bba08cf8c979d/4041800000000000/4067bc05e9996d68/c0b59c39a869906e/0/-10_2,2_3,1_4/4045500000000000,4018000000000000,402c000000000000,0,4044800000000000,4047a00000000000,0,4010000000000000,3f47a665b5a1dd79/// => 0/255bba08cf8c979d/4041800000000000/4067bc05e9996d68/c0b59c39a869906e/0/-10_2,2_1,1_1,1_1,1_2/4045500000000000,4018000000000000,402c000000000000,4044800000000000,4047a00000000000,4010000000000000,3f47a665b5a1dd79///
+compact - 5/255bba08cf8c979d/4043800000000000/406c7006878461a7/40b453b90d628676/0/-15_1,0_2,1_3/404c400000000000,0,4056000000000000,4046000000000000,0,3f4a1e11869cfde2/// => 5/255bba08cf8c979d/4043800000000000/406c7006878461a7/40b453b90d628676/0/-15_1,1_1,1_1,1_1/404c400000000000,4056000000000000,4046000000000000,3f4a1e11869cfde2///
+compact - -53/0/0/405c8004e14ce990/40a19cac3dc6c470/2/1_3/4057400000000000,4035000000000000,3f338533a640b650///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/405c8004e14ce990/40a19cac3dc6c470/2/1_3/4057400000000000,4035000000000000,3f338533a640b650///bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 3/3f50624dd2f1a9fc/0/405b800000000000/c0a9c78b9e62af72/0///-10_3/4045000000000000,0,4051000000000000/ => 3/3f50624dd2f1a9fc/0/405b800000000000/c0a9c78b9e62af72/0///-10_1,1_1/4045000000000000,4051000000000000/
+compact - -4/255bba08cf8c979d/0/4063200f2c9968df/40b6443076a23dd1/0/4_4,1_1,0_3/3f316f226294c7dd,4035000000000000,4036000000000000,3f43906f1624f231,4047000000000000,4050000000000000,0,3f503532ae065bce/// => -4/255bba08cf8c979d/0/4063200f2c9968df/40b6443076a23dd1/0/4_4,1_2,1_1/3f316f226294c7dd,4035000000000000,4036000000000000,3f43906f1624f231,4047000000000000,4050000000000000,3f503532ae065bce///
+compact - -53/0/0/0/8000000000000000/3/////4000000000000000 => -53/0/0/0/8000000000000000/3/////4000000000000000
+compact - 2/3fe0000000000000/403d000000000000/407ac805dacca68e/40c4724e4014c0e1/2/-9_1,2_3/4055e00000000000,3f4b947c6d075c2f,402c800000000000,0/-8_4,1_1,1_4/4033000000000000,4008000000000000,3f4341e8c768c373,0,0,4026000000000000,4055b00000000000,4058800000000000,4054000000000000/ => 2/3fe0000000000000/403d000000000000/407ac805dacca68e/40c4724e4014c0e1/2/-9_1,2_2/4055e00000000000,3f4b947c6d075c2f,402c800000000000/-8_3,4_4/4033000000000000,4008000000000000,3f4341e8c768c373,4026000000000000,4055b00000000000,4058800000000000,4054000000000000/
+compact - -1/3f847ae147ae147b/4030000000000000/40765e042d3d5e09/40cccf99cca28892/2/-4_3,1_1,2_1/3f49987224246ddc,3f2f45e330833c72,404d700000000000,4050c00000000000,4052000000000000/-10_1,0_3/4051800000000000,0,0,4052800000000000/ => -1/3f847ae147ae147b/4030000000000000/40765e042d3d5e09/40cccf99cca28892/2/-4_3,1_1,2_1/3f49987224246ddc,3f2f45e330833c72,404d700000000000,4050c00000000000,4052000000000000/-10_1,2_1/4051800000000000,4052800000000000/
+compact - -1/255bba08cf8c979d/404a800000000000/4074640154381394/40be0c0fdef35dbc/3/-10_4,1_1,0_2/4055c00000000000,4025c00000000000,0,4052580000000000,403e000000000000,3f3543813938c266,4052000000000000/// => -1/255bba08cf8c979d/404a800000000000/4074640154381394/40be0c0fdef35dbc/3/-10_2,1_1,1_3/4055c00000000000,4025c00000000000,4052580000000000,403e000000000000,3f3543813938c266,4052000000000000///
+compact - -1/3f847ae147ae147b/0/40674001e4e2f961/40c2490b676865e3/3/-7_2/4051c00000000000,4042800000000000/-3_1,2_1/4053800000000000,3f2e4e2f960ada05/ => -1/3f847ae147ae147b/0/40674001e4e2f961/40c2490b676865e3/3/-7_2/4051c00000000000,4042800000000000/-3_1,2_1/4053800000000000,3f2e4e2f960ada05/
+compact - 3/3f50624dd2f1a9fc/0/4077ec0588dcdddd/40d6b6a967cfae33/0/9_4,1_3,2_1/0,3f479000360b4d17,0,3f44b6e6b8db3705,4058800000000000,0,4051400000000000,4054400000000000/-2_4,1_1/4047800000000000,0,4051700000000000,4032000000000000,0/ => 3/3f50624dd2f1a9fc/0/4077ec0588dcdddd/40d6b6a967cfae33/0/10_1,1_1,1_1,1_1,2_1/3f479000360b4d17,3f44b6e6b8db3705,4058800000000000,4051400000000000,4054400000000000/-2_1,1_2/4047800000000000,4051700000000000,4032000000000000/
+compact - 5/255bba08cf8c979d/0/0/8000000000000000/1///// => 5/255bba08cf8c979d/0/0/8000000000000000/1/////
+compact - 1/3f50624dd2f1a9fc/4025400000000000/40556804e6610178/40b175437a4b65a7/3/-9_4/3f33998405e0b592,0,4043000000000000,4042800000000000/// => 1/3f50624dd2f1a9fc/4025400000000000/40556804e6610178/40b175437a4b65a7/3/-9_1,1_2/3f33998405e0b592,4043000000000000,4042800000000000///
+compact - 8/3fe0000000000000/4045000000000000/4045000000000000/407081b122690c06/3///// => 8/3fe0000000000000/4045000000000000/4045000000000000/407081b122690c06/3/////
+compact - 0/3f847ae147ae147b/0/0/0/1///// => 0/3f847ae147ae147b/0/0/0/1/////
+compact - 8/255bba08cf8c979d/0/406c380000000000/40b3f94f5f044178/0///-20_3,1_1/4024000000000000,405ef00000000000,4056c00000000000,3ff0000000000000/ => 8/255bba08cf8c979d/0/406c380000000000/40b3f94f5f044178/0///-20_3,1_1/4024000000000000,405ef00000000000,4056c00000000000,3ff0000000000000/
+compact - -53/0/0/0/0/2/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/2/////bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 1/3fe0000000000000/4044800000000000/4078e60157f946be/40c0d068cea7209e/0/9_2,1_4,1_3/4000000000000000,4052e80000000000,4042800000000000,404ee00000000000,3ef85b0f0ed6e947,4024000000000000,3f33f9e37af00ef0,4055000000000000,4055c00000000000/// => 1/3fe0000000000000/4044800000000000/4078e60157f946be/40c0d068cea7209e/0/9_2,1_4,1_3/4000000000000000,4052e80000000000,4042800000000000,404ee00000000000,3ef85b0f0ed6e947,4024000000000000,3f33f9e37af00ef0,4055000000000000,4055c00000000000///
+compact - -1/3fe0000000000000/0/0/0/1///// => -1/3fe0000000000000/0/0/0/1/////
+compact - -2/0/0/40528002cd4523e8/40b08f846d26322c/0/-9_3/0,3f266a291f3ee024,4052800000000000/// => -2/0/0/40528002cd4523e8/40b08f846d26322c/0/-8_2/3f266a291f3ee024,4052800000000000///
+compact - -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 2/3f50624dd2f1a9fc/0/405da00000000000/c0a97638999d3745/3/-1_3,1_4/4040800000000000,4020000000000000,401c000000000000,4041300000000000,4010800000000000,4040000000000000,0/// => 2/3f50624dd2f1a9fc/0/405da00000000000/c0a97638999d3745/3/-1_3,1_3/4040800000000000,4020000000000000,401c000000000000,4041300000000000,4010800000000000,4040000000000000///
+compact - -53/0/0/0/0/0/////4000000000000000 => -53/0/0/0/0/0/////4000000000000000
+compact - -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 0/255bba08cf8c979d/0/0/0/3/-8_1/0/// => 0/255bba08cf8c979d/0/0/0/3/////
+compact - -53/0/0/3f36f0948ce80946/bf795e6ed9368634/1/1_1/3f36f0948ce80946///4000000000000000 => -53/0/0/3f36f0948ce80946/bf795e6ed9368634/1/1_1/3f36f0948ce80946///4000000000000000
+compact - -4/3f50624dd2f1a9fc/4050000000000000/405f80082aafd679/40a913f9a319b918/1///9_4/4026000000000000,3f40555facf198b1,4038000000000000,403b000000000000/ => -4/3f50624dd2f1a9fc/4050000000000000/405f80082aafd679/40a913f9a319b918/1///9_4/4026000000000000,3f40555facf198b1,4038000000000000,403b000000000000/
+compact - 0/3fe0000000000000/3f218f3777c06c8b/404e0020e76fe879/c0995307d55896ad/3/-19_4/3f37d8ec907a2a4e,4049000000000000,3f40972bc24b9bfe,4024000000000000/// => 0/3fe0000000000000/3f218f3777c06c8b/404e0020e76fe879/c0995307d55896ad/3/-19_4/3f37d8ec907a2a4e,4049000000000000,3f40972bc24b9bfe,4024000000000000///
+compact - -2/3f847ae147ae147b/0/4058800000000000/c08e43688e58b607/3/-4_2,2_1/4044800000000000,4031000000000000,4044000000000000/// => -2/3f847ae147ae147b/0/4058800000000000/c08e43688e58b607/3/-4_2,2_1/4044800000000000,4031000000000000,4044000000000000///
+compact - 0/3f50624dd2f1a9fc/0/4034000000000000/c05877fdaa12229a/2///-7_2/4032000000000000,4000000000000000/ => 0/3f50624dd2f1a9fc/0/4034000000000000/c05877fdaa12229a/2///-7_2/4032000000000000,4000000000000000/
+compact - -53/0/0/40696002dc08829d/40bf4e6ab49eca97/3/0_2,0_2,0_1/4050400000000000,3f36e04414e8f6dc,4028000000000000,4043000000000000,4056000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => -53/0/0/40696002dc08829d/40bf4e6ab49eca97/3/0_5/4050400000000000,3f36e04414e8f6dc,4028000000000000,4043000000000000,4056000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000
+compact - 3/3fe0000000000000/4051c00000000000/4072f8039e8e6b8e/c0b1b9a7cf1f5710/0/6_2,2_3,0_2/0,3f27fba919547ea7,404a000000000000,3f37a543cca0417e,4055600000000000,3f3645ce5f868032,4057c00000000000/// => 3/3fe0000000000000/4051c00000000000/4072f8039e8e6b8e/c0b1b9a7cf1f5710/0/7_1,2_5/3f27fba919547ea7,404a000000000000,3f37a543cca0417e,4055600000000000,3f3645ce5f868032,4057c00000000000///
+compact - -1/3f847ae147ae147b/4050000000000000/406ab00afcd4bcb0/c0b025131d529b26/0/-1_4/404b000000000000,0,3f3f787e7b060819,4024000000000000/6_1,1_2,1_2/0,4051a00000000000,3f4c3713b53de3ff,402e000000000000,0/ => -1/3f847ae147ae147b/4050000000000000/406ab00afcd4bcb0/c0b025131d529b26/0/-1_1,1_2/404b000000000000,3f3f787e7b060819,4024000000000000/8_2,1_1/4051a00000000000,3f4c3713b53de3ff,402e000000000000/
+compact - -1/0/0/0/8000000000000000/2/-15_1/0/// => -1/0/0/0/8000000000000000/2/////
+compact - 0/3f847ae147ae147b/0/40811e004e88deea/c0a53bd09670ca5d/0/-15_2,0_3/404ce00000000000,3f23a237ba81fc9f,4055800000000000,4042800000000000,404e000000000000/-16_2,2_2,1_4/0,403b000000000000,404b800000000000,0,4057400000000000,4055c00000000000,0,4046800000000000/ => 0/3f847ae147ae147b/0/40811e004e88deea/c0a53bd09670ca5d/0/-15_5/404ce00000000000,3f23a237ba81fc9f,4055800000000000,4042800000000000,404e000000000000/-15_1,2_1,2_2,1_1/403b000000000000,404b800000000000,4057400000000000,4055c00000000000,4046800000000000/
+compact - -1/3f50624dd2f1a9fc/0/4039000000000000/4077197ec06e5f1e/3/-14_1/4039000000000000/// => -1/3f50624dd2f1a9fc/0/4039000000000000/4077197ec06e5f1e/3/-14_1/4039000000000000///
+compact - -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 => -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000
+compact - 5/255bba08cf8c979d/0/40761801bc170baf/c0beaf6f89aef545/2/-6_1,2_3,2_4/401c000000000000,402e000000000000,4052800000000000,3f3bc170baeec5f7,4054400000000000,4013000000000000,0,403c000000000000/8_3,2_1,1_1/404e000000000000,403f000000000000,0,404a600000000000,0/ => 5/255bba08cf8c979d/0/40761801bc170baf/c0beaf6f89aef545/2/-6_1,2_3,2_2,1_1/401c000000000000,402e000000000000,4052800000000000,3f3bc170baeec5f7,4054400000000000,4013000000000000,403c000000000000/8_2,3_1/404e000000000000,403f000000000000,404a600000000000/
+compact - -53/0/0/4041800000000000/40945e359c571c3e/3/1_1/4041800000000000///4000000000000000 => -53/0/0/4041800000000000/40945e359c571c3e/3/1_1/4041800000000000///4000000000000000
+compact - -1/3f847ae147ae147b/4057000000000000/4073e8080a6e943c/40d11040e3c61bdf/0/-14_3,1_1/0,4035800000000000,0,4018800000000000/-8_1,0_2,1_4/3f45b5b386499efb,3f37a828f2ca91d0,4059700000000000,0,3f4ec9aca22f7d6b,4058480000000000,0/ => -1/3f847ae147ae147b/4057000000000000/4073e8080a6e943c/40d11040e3c61bdf/0/-13_1,2_1/4035800000000000,4018800000000000/-8_3,2_2/3f45b5b386499efb,3f37a828f2ca91d0,4059700000000000,3f4ec9aca22f7d6b,4058480000000000/
+schema -1 -1/3f847ae147ae147b/0/4075d005a7a59ba1/40d51f9b7dd9e4de/1/-14_4/3f3245c2646ac083,4046800000000000,4058400000000000,4056000000000000/-7_4/4036000000000000,4058400000000000,3f3e0765aa21a566,3f451698d5c621af/ => -1/3f847ae147ae147b/0/4075d005a7a59ba1/40d51f9b7dd9e4de/1/-14_4/3f3245c2646ac083,4046800000000000,4058400000000000,4056000000000000/-7_4/4036000000000000,4058400000000000,3f3e0765aa21a566,3f451698d5c621af/
+schema -2 -2/3f847ae147ae147b/4033400000000000/4033400000000000/4094aec1a2c8dbd8/2///// => -2/3f847ae147ae147b/4033400000000000/4033400000000000/4094aec1a2c8dbd8/2/////
+schema -4 -2/255bba08cf8c979d/0/406bdc05dc2fd1af/40a49af4797d0569/3/-13_2/4058c00000000000,4053c00000000000/1_1,2_1,1_2/4033c00000000000,402c400000000000,4026000000000000,3f4770bf46bce66c/ => -4/255bba08cf8c979d/0/406bdc05dc2fd1af/40a49af4797d0569/0/-3_1/4066400000000000/1_2/4040f00000000000,4026005dc2fd1af4/
+schema -4 -2/0/0/40723403bb42c688/40cd645830b0bf12/2/5_1,0_4,1_4/4056800000000000,4054c00000000000,4028000000000000,0,4038400000000000,404a800000000000,3f4dda16343f40a3,0,403d000000000000/// => -4/0/0/40723403bb42c688/40cd645830b0bf12/0/2_3/4067200000000000,4053500eed0b1a20,403d000000000000///
+schema 3 5/255bba08cf8c979d/0/407386015a292f0f/40a794584af0cd53/3/-17_1,2_1,2_4/0,3f35a292f0f0063e,4028000000000000,0,0,404f800000000000/2_2,0_1/4051000000000000,405e580000000000,4048000000000000/ => 3/255bba08cf8c979d/0/407386015a292f0f/40a794584af0cd53/0/-4_3/0,3f35a292f0f0063e,4052c00000000000/1_1/406dac0000000000/
+schema 3 3/0/4032000000000000/4067540000000000/c0a4e66e8fc0d5f4/3/-7_1/4031000000000000/-15_1,1_3/0,403a000000000000,4043d00000000000,4055800000000000/ => 3/0/4032000000000000/4067540000000000/c0a4e66e8fc0d5f4/3/-7_1/4031000000000000/-15_1,1_3/0,403a000000000000,4043d00000000000,4055800000000000/
+schema -4 -1/255bba08cf8c979d/0/408613029ce5b708/40cc90b6a2824a80/1/-20_4,0_1/405a800000000000,4057000000000000,4033000000000000,0,0/-6_4,1_3,1_4/3f4698a5cf1a3040,3f4335b5a161d764,4055400000000000,4053000000000000,0,4055c00000000000,4057000000000000,4030000000000000,4045100000000000,4056d00000000000,0/ => -4/255bba08cf8c979d/0/408613029ce5b708/40cc90b6a2824a80/0/-2_1/406b200000000000/0_2/406f000a7396dc1f,406e2c0000000000/
+schema -4 -4/3fe0000000000000/4034000000000000/4077a40000000000/c0a69343fd41b945/0///-5_3,2_4,0_1/0,4041000000000000,4050400000000000,404e800000000000,403b000000000000,404a200000000000,4051000000000000,4049800000000000/ => -4/3fe0000000000000/4034000000000000/4077a40000000000/c0a69343fd41b945/0///-5_3,2_4,0_1/0,4041000000000000,4050400000000000,404e800000000000,403b000000000000,404a200000000000,4051000000000000,4049800000000000/
+schema 0 3/3f847ae147ae147b/0/4070dc0000000000/40c8893115ba663d/3/-18_1/4037600000000000/8_3,1_2,0_3/4058200000000000,404cf00000000000,0,4010000000000000,4044800000000000,4040000000000000,401c000000000000,4020000000000000/ => 0/3f847ae147ae147b/0/4070dc0000000000/40c8893115ba663d/0/-2_1/4037600000000000/1_2/4058200000000000,4062bc0000000000/
+schema -1 1/255bba08cf8c979d/403b000000000000/4072420072b41d7a/c09d5fab9cee1e25/2/-4_3/4050c00000000000,0,3f1cad075e9f5f5d/-17_2,1_2,0_1/4010000000000000,4058d00000000000,4014000000000000,4055380000000000,4014000000000000/ => -1/255bba08cf8c979d/403b000000000000/4072420072b41d7a/c09d5fab9cee1e25/0/-1_2/4050c00000000000,3f1cad075e9f5f5d/-4_2/4059d00000000000,4057b80000000000/
+schema -1 2/3fe0000000000000/0/4082bd0000000000/c0bd3319ef36efb0/0/-13_4,2_1,1_1/4031000000000000,4055c00000000000,404a000000000000,4010800000000000,404fd00000000000,4035000000000000/6_2,1_4,1_2/4020000000000000,0,0,4051c00000000000,4053c00000000000,402c000000000000,404e800000000000,405e780000000000/ => -1/3fe0000000000000/0/4082bd0000000000/c0bd3319ef36efb0/0/-1_2/4064040000000000,4055280000000000/1_2/4020000000000000,4075ae0000000000/
+schema -4 -4/0/0/405360069bb543a9/40aea9e1f3d01172/0/-18_1,2_3,0_2/3f3a6ed50ea23194,401a000000000000,0,4051c00000000000,0,0/// => -4/0/0/405360069bb543a9/40aea9e1f3d01172/0/-18_1,2_3,0_2/3f3a6ed50ea23194,401a000000000000,0,4051c00000000000,0,0///
+schema 0 0/3fe0000000000000/0/406d00025e9095d0/40cbc4c1457af593/2/-15_2,0_3/4051c00000000000,4052400000000000,4056000000000000,3f32f484ae81f198,0/// => 0/3fe0000000000000/0/406d00025e9095d0/40cbc4c1457af593/2/-15_2,0_3/4051c00000000000,4052400000000000,4056000000000000,3f32f484ae81f198,0///
+schema -4 -2/255bba08cf8c979d/3f360aef87ccf47f/407dd80986f3a912/c0be127a5380d87d/1/8_4,2_3,1_4/0,3f4d7e179307486e,4047000000000000,3f2221fa495edd4c,4053c00000000000,404e000000000000,3ef137dcd585865d,4049800000000000,4057200000000000,4055400000000000,3f4ea1d0789c089f/-6_1/4050000000000000/ => -4/255bba08cf8c979d/3f360aef87ccf47f/407dd80986f3a912/c0be127a5380d87d/0/2_5/0,404700220696255f,40616000226fb9ab,406c900000000000,3f4ea1d0789c089f/-1_1/4050000000000000/
+schema 8 8/3fe0000000000000/0/406950074ed128cb/40ba80a920a01d25/0///-9_2,2_4/3f4d3b44a32bf510,4043000000000000,402e000000000000,403c000000000000,4008000000000000,405da00000000000/ => 8/3fe0000000000000/0/406950074ed128cb/40ba80a920a01d25/0///-9_2,2_4/3f4d3b44a32bf510,4043000000000000,402e000000000000,403c000000000000,4008000000000000,405da00000000000/
+schema 0 1/3f847ae147ae147b/0/4076420000000000/40c04a5134d386e6/2/5_1,2_1,0_3/405c800000000000,4055c00000000000,0,4048800000000000,405a880000000000/// => 0/3f847ae147ae147b/0/4076420000000000/40c04a5134d386e6/0/3_4/405c800000000000,4055c00000000000,4048800000000000,405a880000000000///
+schema -2 -1/0/4051800000000000/406340034e312bb1/40a519687d8db256/0/5_3/4034000000000000,4048800000000000,3f3a71895d851e41/-16_1/402e000000000000/ => -2/0/4051800000000000/406340034e312bb1/40a519687d8db256/0/3_2/4051400000000000,3f3a71895d851e41/-8_1/402e000000000000/
+schema 8 8/255bba08cf8c979d/4054800000000000/40763a03c8e0d6ac/40a032fca6d15d2d/2/-7_3,0_3/3f4e4706b55bcea7,4000000000000000,4056000000000000,404b800000000000,405ae80000000000,4035000000000000/// => 8/255bba08cf8c979d/4054800000000000/40763a03c8e0d6ac/40a032fca6d15d2d/2/-7_3,0_3/3f4e4706b55bcea7,4000000000000000,4056000000000000,404b800000000000,405ae80000000000,4035000000000000///
+schema -2 -2/255bba08cf8c979d/0/4074900000000000/40ce8c0f13c5d000/2/0_3,1_3/4024000000000000,4057800000000000,403e000000000000,4058400000000000,0,4058800000000000/// => -2/255bba08cf8c979d/0/4074900000000000/40ce8c0f13c5d000/2/0_3,1_3/4024000000000000,4057800000000000,403e000000000000,4058400000000000,0,4058800000000000///
+schema -1 0/3f50624dd2f1a9fc/4033000000000000/40809401b7048570/40d03ab0f8a202b3/0/6_4,1_3/405ab80000000000,4056800000000000,4056c00000000000,404d800000000000,4058000000000000,3f4b7048570b225d,4051280000000000/// => -1/3f50624dd2f1a9fc/4033000000000000/40809401b7048570/40d03ab0f8a202b3/0/3_5/405ab80000000000,4066a00000000000,404d800000000000,4058000db8242b86,4051280000000000///
+schema -4 -4/255bba08cf8c979d/0/4079780000000000/40c510da0628781c/3///-2_4,0_2,1_3/4056b80000000000,4030000000000000,4041000000000000,4049600000000000,4037000000000000,4044800000000000,0,4051000000000000,4054f80000000000/ => -4/255bba08cf8c979d/0/4079780000000000/40c510da0628781c/3///-2_4,0_2,1_3/4056b80000000000,4030000000000000,4041000000000000,4049600000000000,4037000000000000,4044800000000000,0,4051000000000000,4054f80000000000/
+schema -3 -2/255bba08cf8c979d/0/4050b80000000000/40b016532ef2a597/0/-13_1/4050b80000000000/// => -3/255bba08cf8c979d/0/4050b80000000000/40b016532ef2a597/0/-6_1/4050b80000000000///
+schema -1 -1/0/4039000000000000/4039000000000000/4072f2d21fc49cb0/0///// => -1/0/4039000000000000/4039000000000000/4072f2d21fc49cb0/0/////
+schema -2 -2/3f847ae147ae147b/4034000000000000/40805c0000000000/c0ac5f1a6783e9ab/1/8_2,0_4,2_2/4058200000000000,4049000000000000,4050800000000000,0,4053400000000000,4052400000000000,4056800000000000,4049800000000000/// => -2/3f847ae147ae147b/4034000000000000/40805c0000000000/c0ac5f1a6783e9ab/1/8_2,0_4,2_2/4058200000000000,4049000000000000,4050800000000000,0,4053400000000000,4052400000000000,4056800000000000,4049800000000000///
+schema 0 1/3f50624dd2f1a9fc/0/0/0/0///// => 0/3f50624dd2f1a9fc/0/0/0/0/////
+schema 1 1/3f847ae147ae147b/0/4053c00c3f4dd030/40a5dbecce29dfe8/0/-18_4/0,4031000000000000,404f000000000000,3f487e9ba05fe849/// => 1/3f847ae147ae147b/0/4053c00c3f4dd030/40a5dbecce29dfe8/0/-18_4/0,4031000000000000,404f000000000000,3f487e9ba05fe849///
+schema -1 -1/255bba08cf8c979d/4052400000000000/4052400000000000/40a213b071a0444f/1///// => -1/255bba08cf8c979d/4052400000000000/4052400000000000/40a213b071a0444f/1/////
+schema -1 2/3f50624dd2f1a9fc/404e800000000000/40826d02523ab24e/40e2358e289dd194/3/6_2,1_3,2_1/3f39d3cdb46f899a,4048000000000000,4050800000000000,0,404a000000000000,404c800000000000/-8_3,0_2,2_3/3f4839c44aa7be47,0,0,404e000000000000,4052280000000000,4054000000000000,4057400000000000,0/ => -1/3f50624dd2f1a9fc/404e800000000000/40826d02523ab24e/40e2358e289dd194/0/1_2/4048000ce9e6da38,4065e00000000000/-1_3/3f4839c44aa7be47,40731a0000000000,0/
+schema 1 1/0/4056c00000000000/406f540000000000/c0b4fe6da09892b4/1/6_3/405aa80000000000,404a800000000000,0/// => 1/0/4056c00000000000/406f540000000000/c0b4fe6da09892b4/1/6_3/405aa80000000000,404a800000000000,0///
+schema 3 5/3f50624dd2f1a9fc/0/4061c400b3a15b0a/40bde531e4f7e78d/3/-4_4/4047900000000000,4044000000000000,404b800000000000,3f16742b613959f4/// => 3/3f50624dd2f1a9fc/0/4061c400b3a15b0a/40bde531e4f7e78d/0/-1_2/4047900000000000,4057c0016742b614///
+schema -4 -4/3f847ae147ae147b/0/4059000cde82815d/40b12882d44188d4/1///-19_4/404c800000000000,4038000000000000,3f49bd0502b90af6,4033000000000000/ => -4/3f847ae147ae147b/0/4059000cde82815d/40b12882d44188d4/1///-19_4/404c800000000000,4038000000000000,3f49bd0502b90af6,4033000000000000/
+schema -3 -1/0/0/407250060a321ef1/40c2ff1f199a697d/1/-10_1,1_4,1_3/0,4041000000000000,3f474fa1f338d332,0,404b800000000000,3f4901ef044eeb41,4056c80000000000,404df00000000000/-7_2/404a800000000000,0/ => -3/0/0/407250060a321ef1/40c2ff1f199a697d/0/-2_3/4041000000000000,404b80174fa1f339,4062e006407bc114/-1_1/404a800000000000/
+schema 3 5/0/0/406cd80ae7e2a192/40cbc60a53acfd40/0/-13_4,2_4,2_3/4051400000000000,4059b00000000000,0,3f3bee888cca6f30,3f4da8463fe479e9,4014000000000000,4047800000000000,0,401c000000000000,0,0/// => 3/0/0/406cd80ae7e2a192/40cbc60a53acfd40/0/-3_5/4065780000000000,3f3bee888cca6f30,404a001da8463fe4,401c000000000000,0///
+schema 8 8/3f847ae147ae147b/3f33c3a2b5df1d16/4087d500f6859e8e/40e19a23042f6c52/3/-18_2,1_2,2_2/405d780000000000,4026800000000000,4047300000000000,405a180000000000,4048000000000000,3f22e34ad6a0419f/4_3,1_4,1_4/4008000000000000,3ef9b6bb0a0cc8e6,4043900000000000,0,405ab80000000000,4040000000000000,4053400000000000,0,405bf00000000000,402c000000000000,4049800000000000/ => 8/3f847ae147ae147b/3f33c3a2b5df1d16/4087d500f6859e8e/40e19a23042f6c52/3/-18_2,1_2,2_2/405d780000000000,4026800000000000,4047300000000000,405a180000000000,4048000000000000,3f22e34ad6a0419f/4_3,1_4,1_4/4008000000000000,3ef9b6bb0a0cc8e6,4043900000000000,0,405ab80000000000,4040000000000000,4053400000000000,0,405bf00000000000,402c000000000000,4049800000000000/
+schema 4 5/0/0/40701e0000000000/c0b4b11771e1881e/3/-6_2/4048000000000000,405c780000000000/8_3/0,4049800000000000,4046800000000000/ => 4/0/0/40701e0000000000/c0b4b11771e1881e/0/-3_2/4048000000000000,405c780000000000/4_2/0,4058000000000000/
+schema 2 2/255bba08cf8c979d/0/4064200000000000/40a3bfbe06bf6bc3/3/-18_3/405ca80000000000,4047300000000000,0/// => 2/255bba08cf8c979d/0/4064200000000000/40a3bfbe06bf6bc3/3/-18_3/405ca80000000000,4047300000000000,0///
+schema 5 5/0/403b000000000000/407252025712ee45/40c624b554e3d00a/3/6_1,2_4,0_1/0,4058c00000000000,4051880000000000,3f06c4568e3faee2,3f414c52094294e9,4058400000000000/// => 5/0/403b000000000000/407252025712ee45/40c624b554e3d00a/3/6_1,2_4,0_1/0,4058c00000000000,4051880000000000,3f06c4568e3faee2,3f414c52094294e9,4058400000000000///
+schema -3 0/3fe0000000000000/3f4abb058b8b3215/407d980a8bdb9df3/40ddde471b6de4f5/2/-19_4/4042800000000000,4056400000000000,3f4f1d81e4a106d0,0/-20_4,2_4/4059580000000000,4057c00000000000,3f39f524ebce6677,3f3b17861304de95,4049700000000000,4041000000000000,4050900000000000,0/ => -3/3fe0000000000000/3f4abb058b8b3215/407d980a8bdb9df3/40ddde471b6de4f5/0/-2_1/405f800f8ec0f251/-2_2/40688c06a1955fdb,4062e40000000000/
+schema 5 5/3f847ae147ae147b/0/405a5009a7681f2f/4080b0b33c0c6dab/3/1_1,1_2,2_2/0,3f37df64000be76f,4045a00000000000,404d800000000000,3f2d7c78f96328ac/-6_1/4008000000000000/ => 5/3f847ae147ae147b/0/405a5009a7681f2f/4080b0b33c0c6dab/3/1_1,1_2,2_2/0,3f37df64000be76f,4045a00000000000,404d800000000000,3f2d7c78f96328ac/-6_1/4008000000000000/
+schema -4 -4/3f50624dd2f1a9fc/4051400000000000/4051400000000000/40b045e7f51b5af9/0///// => -4/3f50624dd2f1a9fc/4051400000000000/4051400000000000/40b045e7f51b5af9/0/////
+schema -4 -2/3f847ae147ae147b/4034000000000000/4070ac02969e90ee/40d017d5d6f37f37/3///-15_4,1_4/4058000000000000,4015800000000000,3f44b4f487738fed,402c000000000000,404a800000000000,4045300000000000,4031000000000000,4033000000000000/ => -4/3f847ae147ae147b/4034000000000000/4070ac02969e90ee/40d017d5d6f37f37/0///-3_3/405cd80a5a7a43ba,405c180000000000,4033000000000000/
+schema -2 -2/0/0/405db809bc2c973d/40b3a1c1cef0203a/2/-3_4/3f326d30ce335153,3f3483818ec14256,402a000000000000,4030000000000000/-16_1,0_4/0,4037000000000000,0,403ee00000000000,4042000000000000/ => -2/0/0/405db809bc2c973d/40b3a1c1cef0203a/2/-3_4/3f326d30ce335153,3f3483818ec14256,402a000000000000,4030000000000000/-16_1,0_4/0,4037000000000000,0,403ee00000000000,4042000000000000/
+schema -4 -4/3f847ae147ae147b/4041000000000000/4066640adb78ed8e/c0a61b29bff8311b/2/-8_2,1_2/3f3cdfd4bea58e1a,4049b00000000000,4057700000000000,3f4cfdf956e397c2/// => -4/3f847ae147ae147b/4041000000000000/4066640adb78ed8e/c0a61b29bff8311b/2/-8_2,1_2/3f3cdfd4bea58e1a,4049b00000000000,4057700000000000,3f4cfdf956e397c2///
+schema -4 -1/3f847ae147ae147b/0/4061c00000000000/c09ca0dda2399580/3/6_4,0_2/4051800000000000,3ff0000000000000,404d800000000000,4028000000000000,0,0/// => -4/3f847ae147ae147b/0/4061c00000000000/c09ca0dda2399580/0/1_2/4060400000000000,4028000000000000///
+schema 1 1/3f50624dd2f1a9fc/4049000000000000/404f600cd50676a7/c09756f32a52d3c3/0/-12_3/0,3f39aa0ced4da6a0,4029800000000000/// => 1/3f50624dd2f1a9fc/4049000000000000/404f600cd50676a7/c09756f32a52d3c3/0/-12_3/0,3f39aa0ced4da6a0,4029800000000000///
+schema 1 3/3fe0000000000000/0/407ca002bee8d828/40b720607d2b82fb/0/-6_1,1_4/4051800000000000,4058c00000000000,404f000000000000,3ede15a6a791ea3f,4054c00000000000/-1_3,1_2/402e000000000000,403c000000000000,4031000000000000,3f45bb1b73ef93d4,4055000000000000/ => 1/3fe0000000000000/0/407ca002bee8d828/40b720607d2b82fb/0/-1_2/4065200000000000,406220000f0ad354/0_2/4045800000000000,4059400add8db9f8/
+schema 5 5/255bba08cf8c979d/0/0/0/0///// => 5/255bba08cf8c979d/0/0/0/0/////
+schema 8 8/3fe0000000000000/0/4066440fa704cb18/c0b040f7863e0518/1/-13_2,0_4,1_3/3f385b459c357813,0,4043000000000000,4058000000000000,4032000000000000,4030000000000000,3f433f98bb893da9,3f4f2ed7a2bbe502,4024400000000000/// => 8/3fe0000000000000/0/4066440fa704cb18/c0b040f7863e0518/1/-13_2,0_4,1_3/3f385b459c357813,0,4043000000000000,4058000000000000,4032000000000000,4030000000000000,3f433f98bb893da9,3f4f2ed7a2bbe502,4024400000000000///
+schema 2 3/3f50624dd2f1a9fc/3f193076751f1248/4070e8028e3ceeb4/40a77c21db6de4c7/2/5_2,2_2,1_2/3f366f43ab83e9a4,3f2850db44dd8308,405f200000000000,4049000000000000,0,4032000000000000/-7_3/4045200000000000,4018000000000000,403dc00000000000/ => 2/3f50624dd2f1a9fc/3f193076751f1248/4070e8028e3ceeb4/40a77c21db6de4c7/0/3_1,1_3/3f414bd8a6f95594,4065d00000000000,0,4032000000000000/-3_2/4048200000000000,403dc00000000000/
+schema 0 1/3f50624dd2f1a9fc/0/403a00158b66a157/4096d605e464ef95/3///-3_3/3f358b66a1571fb3,403a000000000000,0/ => 0/3f50624dd2f1a9fc/0/403a00158b66a157/4096d605e464ef95/0///-1_2/403a00158b66a157,0/
+schema -2 -1/255bba08cf8c979d/0/0/0/3///// => -2/255bba08cf8c979d/0/0/0/0/////
+schema -3 0/3f50624dd2f1a9fc/4053000000000000/405cc8125f8a1d1a/40b942422d34988a/3///-6_1,2_2/3f413992edee92dd,4043900000000000,3f4385814c464700/ => -3/3f50624dd2f1a9fc/4053000000000000/405cc8125f8a1d1a/40b942422d34988a/0///0_1/40439024bf143a35/
+schema 1 2/3fe0000000000000/4008000000000000/40725e03a48c9a6c/408bcd20c73b1b0c/0/4_4,0_4/4050780000000000,3ffe000000000000,0,4049000000000000,3f4d2464d364c57d,4049800000000000,405a080000000000,4032000000000000/// => 1/3fe0000000000000/4008000000000000/40725e03a48c9a6c/408bcd20c73b1b0c/0/2_5/4050780000000000,3ffe000000000000,4049001d2464d365,4063640000000000,4032000000000000///
+schema 0 2/3fe0000000000000/4057800000000000/406ca00b9e7deca6/c0b484987778174b/1/6_1/3f42309aa20c87c3/-6_1,0_1,2_3/402e000000000000,3f4c495d108b7bee,4044000000000000,4010000000000000,4053000000000000/ => 0/3fe0000000000000/4057800000000000/406ca00b9e7deca6/c0b484987778174b/0/2_1/3f42309aa20c87c3/-1_2/402e00712574422e,405e000000000000/
+schema -4 -2/3f50624dd2f1a9fc/4054c00000000000/4054c00000000000/40b440de02b7cdca/0///// => -4/3f50624dd2f1a9fc/4054c00000000000/4054c00000000000/40b440de02b7cdca/0/////
+schema 0 2/3f847ae147ae147b/0/40709c0000000000/40bde73ed50e681c/2/-20_1/403b000000000000/7_1,1_1,0_3/404a800000000000,4043800000000000,404b800000000000,4056f00000000000,0/ => 0/3f847ae147ae147b/0/40709c0000000000/40bde73ed50e681c/0/-5_1/403b000000000000/2_2/404a800000000000,4067380000000000/
+schema -2 -2/3f50624dd2f1a9fc/0/406180081938ea3c/4074e771e5f12221/1/-12_1/4048800000000000/-6_4,1_3/4000000000000000,3f4cb95b4182191d,3f1d5c433b788510,0,4053400000000000,4028000000000000,0/ => -2/3f50624dd2f1a9fc/0/406180081938ea3c/4074e771e5f12221/1/-12_1/4048800000000000/-6_4,1_3/4000000000000000,3f4cb95b4182191d,3f1d5c433b788510,0,4053400000000000,4028000000000000,0/
+schema -4 -4/255bba08cf8c979d/4051f80000000000/4065f40000000000/40b3dc8bbeea659f/3/-13_3/404e800000000000,0,4045600000000000/// => -4/255bba08cf8c979d/4051f80000000000/4065f40000000000/40b3dc8bbeea659f/3/-13_3/404e800000000000,0,4045600000000000///
+schema 1 3/3f847ae147ae147b/0/407e06073348f30e/c096cd25db8b914c/2/-1_4,2_3/0,3f31a601b980ebd5,4050800000000000,4043000000000000,402a000000000000,3f4269b8c5ee5b12,4018000000000000/-16_4,2_2,2_4/4057180000000000,0,403c000000000000,0,3f46a343534a3789,404e800000000000,4039000000000000,404a500000000000,4058980000000000,3f2ee92a89cdb3c9/ => 1/3f847ae147ae147b/0/407e06073348f30e/c096cd25db8b914c/0/0_3/3f31a601b980ebd5,405a000000000000,40330024d3718bdc/-4_5/4057180000000000,403c000000000000,404e8016a343534a,4066000000000000,3f2ee92a89cdb3c9/
+schema -3 -2/3fe0000000000000/3f1acd9084c32390/4062f806c0a1700c/404071064f58f21d/3/0_3/0,4051800000000000,4054700000000000/9_2/0,3f47a8d3af99219a/ => -3/3fe0000000000000/3f1acd9084c32390/4062f806c0a1700c/404071064f58f21d/0/0_2/0,4062f80000000000/5_1/3f47a8d3af99219a/
+schema -4 -4/3f847ae147ae147b/0/0/0/2///// => -4/3f847ae147ae147b/0/0/0/2/////
+schema 0 2/0/0/4060400000000000/c08bc57b2e21f581/0/0_2/0,4043800000000000/-11_1,2_1/404a800000000000,4043000000000000/ => 0/0/0/4060400000000000/c08bc57b2e21f581/0/0_2/0,4043800000000000/-2_1/4056c00000000000/
+schema 3 5/3f50624dd2f1a9fc/0/0/0/1///// => 3/3f50624dd2f1a9fc/0/0/0/0/////
+schema 5 8/255bba08cf8c979d/0/405cb816efdf21e1/c070a3c0584664b7/1/-3_1,2_2,0_4/4036600000000000,4051600000000000,3f3db843699a1da3,4037000000000000,3f40ad205e0d2a2e,3ea59b080e721704,3f3ca22addc55f30/// => 5/255bba08cf8c979d/0/405cb816efdf21e1/c070a3c0584664b7/0/0_2/4056f80000000000,4037005bbf7c8780///
+schema 5 8/3f847ae147ae147b/4010000000000000/4056c02bd8e56a77/c09d52d80132622e/0/-7_3,1_2,2_4/3f48529a29e70074,4008000000000000,3f4bd530bfb8f542,4040000000000000,3f45389aa8b9f208,0,4041000000000000,3f3ca2ca85286280,4032000000000000/// => 5/3f847ae147ae147b/4010000000000000/4056c02bd8e56a77/c09d52d80132622e/0/0_2/404180496065925a,404a000e51654294///
+schema 3 5/3f50624dd2f1a9fc/404b000000000000/4060400000000000/c095af2cb4278429/0/-8_3/4051800000000000,4018000000000000,0/// => 3/3f50624dd2f1a9fc/404b000000000000/4060400000000000/c095af2cb4278429/0/-2_2/4051800000000000,4018000000000000///
+schema 1 3/3f50624dd2f1a9fc/4047000000000000/4067b8043ccb2cd5/c0b0a2e39ae85954/1/-15_1,1_4/3f40f32cb3543579,4037000000000000,4038c00000000000,4028000000000000,4055000000000000/// => 1/3f50624dd2f1a9fc/4047000000000000/4067b8043ccb2cd5/c0b0a2e39ae85954/0/-3_2/4047e010f32cb354,4058000000000000///
+schema 2 2/0/0/4060400000000000/40ba8dfa061a92ab/0/-4_2,2_1/4033000000000000,4051c00000000000,4044000000000000/// => 2/0/0/4060400000000000/40ba8dfa061a92ab/0/-4_2,2_1/4033000000000000,4051c00000000000,4044000000000000///
+schema -4 -2/3f847ae147ae147b/0/405ea01748021947/40b5efafdd021b41/0/-6_4,2_1/3f4a2f0b07a3914d,4033000000000000,4042800000000000,4050a00000000000,3f4460f92ae9f5fc/// => -4/3f847ae147ae147b/0/405ea01748021947/40b5efafdd021b41/0/-1_2/404c001a2f0b07a4,4050a00a307c9575///
+schema 4 5/3fe0000000000000/0/0/8000000000000000/1///// => 4/3fe0000000000000/0/0/8000000000000000/0/////
+schema 6 8/3fe0000000000000/4052f00000000000/405e080efc5983e6/c0a5f0101f171b1d/2/9_2/3f4df8b307cb3807,4046300000000000/// => 6/3fe0000000000000/4052f00000000000/405e080efc5983e6/c0a5f0101f171b1d/0/3_1/4046301df8b307cb///
+schema 2 2/3f847ae147ae147b/0/0/0/0///// => 2/3f847ae147ae147b/0/0/0/0/////
+schema -4 -4/3f50624dd2f1a9fc/0/4083fd0291f635e6/40b5dab8618cc694/1/4_4,2_4,1_1/405c900000000000,4042800000000000,404ac00000000000,4054c00000000000,4056000000000000,3f4d997b87626f23,3f11b021684239d9,3f329fc753df22af,403b000000000000/6_4/4049800000000000,4040800000000000,405ab80000000000,4047000000000000/ => -4/3f50624dd2f1a9fc/0/4083fd0291f635e6/40b5dab8618cc694/1/4_4,2_4,1_1/405c900000000000,4042800000000000,404ac00000000000,4054c00000000000,4056000000000000,3f4d997b87626f23,3f11b021684239d9,3f329fc753df22af,403b000000000000/6_4/4049800000000000,4040800000000000,405ab80000000000,4047000000000000/
+schema -3 -2/0/405b000000000000/40770c0257d38d30/40c260fc1ea0e08b/2/8_1,0_3/4022000000000000,3f2cd05875cc3db4,403a000000000000,0/-12_2,0_2,2_3/3f2f0b37047ef46e,4044e00000000000,3f0ce1de581b6740,404c800000000000,4047800000000000,3f0f99aa56f0e904,4054000000000000/ => -3/0/405b000000000000/40770c0257d38d30/40c260fc1ea0e08b/0/4_3/4022000000000000,403a000e682c3ae6,0/-6_5/3f2f0b37047ef46e,4044e001ce1de582,404c800000000000,4047800000000000,40540000fccd52b8/
+schema 3 5/3f50624dd2f1a9fc/4052000000000000/4074e0075dab675d/c0b34f12a2dfbb23/2///-1_4,2_4/4053400000000000,4024000000000000,3f4e3c2e289c25df,3f4cb12d124b5e48,404f000000000000,4054c00000000000,4037000000000000,401c000000000000/ => 3/3f50624dd2f1a9fc/4052000000000000/4074e0075dab675d/c0b34f12a2dfbb23/0///0_3/4055c00000000000,3f5d76ad9d73c214,4065e00000000000/
+schema 2 5/3f50624dd2f1a9fc/0/406f4c14bc9aca90/40b53c2279ab7102/3/-17_3,0_3,2_2/3f464bc204777eda,402a000000000000,4033000000000000,0,3f3b23e2b10c8da3,4034000000000000,0,4053800000000000/-16_2,2_3/3f3fb27e838e3e68,0,4053180000000000,4046000000000000,3f4f3b788b76b35d/ => 2/3f50624dd2f1a9fc/0/406f4c14bc9aca90/40b53c2279ab7102/0/-2_2/402a00592f0811de,405d4006c8f8ac43/-2_2/3f3fb27e838e3e68,405e180f9dbc45bb/
+schema -4 -1/255bba08cf8c979d/0/0/0/2///// => -4/255bba08cf8c979d/0/0/0/0/////
+schema -3 0/0/4032000000000000/4032000000000000/40664f2c24f6dcee/3///// => -3/0/4032000000000000/4032000000000000/40664f2c24f6dcee/0/////
+schema -1 1/3f50624dd2f1a9fc/0/4082740000000000/40d31617571f210a/1/-6_3,2_2,2_3/4050700000000000,4058400000000000,4055000000000000,0,404a800000000000,4057400000000000,403d600000000000,4056000000000000/1_3/0,4054180000000000,0/ => -1/3f50624dd2f1a9fc/0/4082740000000000/40d31617571f210a/0/-1_4/406ed80000000000,404a800000000000,405e980000000000,4056000000000000/1_1/4054180000000000/
+schema -2 -2/0/0/407e5800c341405c/c0bad121c0942d3b/2/-15_1/405eb00000000000/-15_1,1_4,1_2/4055000000000000,4051c00000000000,404d000000000000,4058400000000000,404a600000000000,0,3f2868280b817cc9/ => -2/0/0/407e5800c341405c/c0bad121c0942d3b/2/-15_1/405eb00000000000/-15_1,1_4,1_2/4055000000000000,4051c00000000000,404d000000000000,4058400000000000,404a600000000000,0,3f2868280b817cc9/
+reset - 1/255bba08cf8c979d/0/4043800000000000/40a23827af1a1a4c/0/-18_1/4043800000000000/// 1/255bba08cf8c979d/0/4043800000000000/40a23827af1a1a4c/1/-18_1/4043800000000000/// => false
+reset - -4/255bba08cf8c979d/0/407178042590605e/40c21b862221608a/0/-14_1/4051400000000000/5_1,0_3,1_4/4040800000000000,4033800000000000,0,404e800000000000,0,3f4e6e4614cd461a,3f15f1e7712049c8,4058400000000000/ -4/255bba08cf8c979d/0/407178042590605e/40c21b862221608a/3/-14_1/4051400000000000/5_1,0_3,1_4/4040800000000000,4033800000000000,0,404e800000000000,0,3f4e6e4614cd461a,3f15f1e7712049c8,4058400000000000/ => false
+reset - 2/0/4045d00000000000/40744e0000000000/40d3dd25e284e69c/0/-10_4,2_2/403b400000000000,0,4038000000000000,4050c00000000000,4058580000000000,4036000000000000/// 2/0/4055d00000000000/40744e0000000000/40d3dd25e284e69c/3/-10_4,2_2/403b400000000000,0,4038000000000000,4050c00000000000,4058580000000000,4036000000000000/// => true
+reset - 5/3f847ae147ae147b/0/4071060000000000/40d247e9e0bd5244/1/-5_2/403c200000000000,0/-17_3/4057d00000000000,4054b80000000000,4043000000000000/ 5/3f847ae147ae147b/0/4071060000000000/40d247e9e0bd5244/3/-5_2/404c200000000000,0/-17_3/4057d00000000000,4054b80000000000,4043000000000000/ => true
+reset - 3/255bba08cf8c979d/4033000000000000/40802d002a1a2b5a/40913f5f65953449/0/-4_4/405e080000000000,4052800000000000,4053000000000000,4051c00000000000/1_1,2_4,1_2/404c800000000000,404b800000000000,4020000000000000,3effb0121d8935e1,4014800000000000,402ac00000000000,3f0a42224ae2c7f3/ 3/255bba08cf8c979d/4043000000000000/40802d002a1a2b5a/40913f5f65953449/3/-4_4/405e080000000000,4052800000000000,4053000000000000,4051c00000000000/1_1,2_4,1_2/404c800000000000,404b800000000000,4020000000000000,3effb0121d8935e1,4014800000000000,402ac00000000000,3f0a42224ae2c7f3/ => true
+reset - -2/0/0/4070f600254fedb2/40c445a2785b3cd0/0/-20_2,0_1/4018000000000000,4051000000000000,0/7_1,0_2,0_2/4048000000000000,4059580000000000,3f02a7f6d9527fd2,0,4048000000000000/ 1/3fe0000000000000/403d000000000000/4075fa0000000000/40c2e7df0281b13f/0///-9_1,0_3/4055800000000000,4048000000000000,405ce80000000000,4052400000000000/ => true
+reset - 6/255bba08cf8c979d/0/4042802015383d71/40933ec89221f11d/0/-3_1,2_1/0,4032802015383d71/// 8/255bba08cf8c979d/0/4042802015383d71/40933ec89221f11d/3/-2_2/4042800000000000,3f500a9c1eb89cfe/// => true
+reset - 3/3f50624dd2f1a9fc/0/4087c3035e4be340/40bc4196c4145f9e/0/-11_1,2_3,0_4,2_3,2_4/3f2dd2df7ee6181e,3f45b39d647a1ae8,404b000000000000,3f487c437eeec312,405c000000000000,405a800000000000,4057a00000000000,405ba00000000000,403f000000000000,4049000000000000,0,3ee0095c35bff1c7,4056080000000000,4041200000000000,4054000000000000/// 3/3f50624dd2f1a9fc/0/406bb00d692630c9/40b80591a74d6d15/3/-11_1,2_3,0_3/3f2dd2df7ee6181e,3f45b39d647a1ae8,404b000000000000,3f487c437eeec312,404d800000000000,4047800000000000,404ec00000000000/// => false
+reset - -53/0/0/404b800000000000/409743fc2e65993f/0/1_1/404b800000000000///3ff0000000000000,4014000000000000 -53/0/0/404b800000000000/409743fc2e65993f/2/1_2/404b800000000000,0///3ff0000000000000,4014000000000000,4024000000000000 => false
+reset - -4/3f50624dd2f1a9fc/4042000000000000/406d6403a1b35f65/40b87b5e5dca48de/1/9_3,2_4/3f3d0d9afb266285,4018000000000000,0,4051c00000000000,4046100000000000,4032000000000000,404e000000000000/// -4/0/4051400000000000/40791a03c21b2118/40c0038621369979/1/-14_2,2_4/4059680000000000,3f377b4a37f18099,0,404e800000000000,4051400000000000,404c800000000000/-13_4/3f401468d1a49c26,3f11f658d9196e04,4031000000000000,403b000000000000/ => true
+reset - 8/3fe0000000000000/405ec00000000000/408ff50199e66dab/40e143e14adbd6c6/0/3_2,0_3,0_2/4053400000000000,4051c00000000000,0,401c000000000000,4053f80000000000,406b680000000000,4060080000000000/-18_4,2_1,0_3/3f41f8b58ed6249b,4057e00000000000,404ae00000000000,4054000000000000,3f2e96c52f36d820,4056000000000000,0,0/ 8/3fe0000000000000/4054000000000000/4086e40199e66dab/40def358cb533f6f/2/3_2,0_1,2_2/4053400000000000,4051c00000000000,0,4058000000000000,4056d00000000000/-18_4,2_1,0_3/3f41f8b58ed6249b,4057e00000000000,404ae00000000000,4054000000000000,3f2e96c52f36d820,4056000000000000,0,0/ => false
+reset - -4/255bba08cf8c979d/0/3f3a2aefef9b2dcc/bf7edb5c328a8927/0/-8_1/3f2a2aefef9b2dcc/// -4/255bba08cf8c979d/0/0/0/3///// => false
+reset - 2/3f60624dd2f1a9fc/412e848000000000/416312d000000000/c0c11abe72c580df/0/-1_2,0_1,2_1/4045800000000000,4057400000000000,4036000000000000,3f42ff168ee146c0/-14_1,2_3,2_3/4050800000000000,4057000000000000,4051000000000000,4030000000000000,0,4030000000000000,0/ 2/3f50624dd2f1a9fc/0/407a00025fe2d1dc/c0c11abe72c580df/1/-1_2,0_1,2_1/4045800000000000,4057400000000000,4036000000000000,3f42ff168ee146c0/-14_1,2_3,2_3/4050800000000000,4057000000000000,4051000000000000,4030000000000000,0,4030000000000000,0/ => false
+reset - -53/0/0/4046800000000000/40a09f1dc02b717e/0/1_1/4036800000000000///3ff0000000000000,4014000000000000 -53/0/0/4046800000000000/40a09f1dc02b717e/1/1_1/4046800000000000///3ff0000000000000,4014000000000000,4024000000000000 => true
+reset - 0/3f847ae147ae147b/0/40735a025a530077/409dec52f0bf39b4/0/-3_1/403a8ccccccccccd/1_3/4059c00000000000,4066240000000000,3f42d29803ba32b5/ 2/3f847ae147ae147b/0/40735a025a530077/409dec52f0bf39b4/1/-13_2/401e000000000000,4036000000000000/2_4,1_2,0_1/4041000000000000,4050c00000000000,4000000000000000,4045800000000000,405b880000000000,4038000000000000,3f42d29803ba32b5/ => true
+reset - -2/3f847ae147ae147b/0/405e801375ddb4c3/40a93fb9ef710a80/0/-16_1,2_1,0_3/3f3582db06c7b3bd,3f4c2a4de6219f4f,405e800000000000,0,0/// -2/3f847ae147ae147b/0/405e801375ddb4c3/40a93fb9ef710a80/2/-16_1,2_1,0_3/3f3582db06c7b3bd,3f4c2a4de6219f4f,405e800000000000,0,0/// => false
+reset - -1/3f847ae147ae147b/0/4077e00000000000/40bfa1a481a1dc29/0/-3_1/4053480000000000/-3_3/4049800000000000,4053780000000000,4066000000000000/ 1/3f847ae147ae147b/0/4077e00000000000/40bfa1a481a1dc29/3/-15_3/4047900000000000,403e000000000000,0/-14_3,0_4,0_4/0,4049800000000000,0,0,403de00000000000,4048000000000000,0,0,404c800000000000,4039000000000000,4057800000000000/ => false
+reset - -2/255bba08cf8c979d/401c000000000000/40856503ad323c59/40d702b0ea714289/0/-12_2,1_2,2_3/4056000000000000,4031000000000000,4052400000000000,3f4c7e21f82eb01a,404e800000000000,4058d00000000000,4053400000000000/-16_1,1_4/404fb00000000000,404e000000000000,3f4e5501cd654c7c,4054800000000000,4048000000000000/ -2/255bba08cf8c979d/401c000000000000/40856503ad323c59/40d702b0ea714289/2/-12_2,1_3,1_4/4056000000000000,4031000000000000,4052400000000000,3f4c7e21f82eb01a,0,404e800000000000,4058d00000000000,4053400000000000,4022000000000000/-16_1,1_4/404fb00000000000,404e000000000000,3f4e5501cd654c7c,4054800000000000,4048000000000000/ => true
+reset - -1/3fe0000000000000/0/40718400f419c85b/c0985cd7922fd15b/0/-4_3,1_4/403c600000000000,4051400000000000,4050380000000000,0,4042000000000000,4054800000000000,3f2e83390b5c9c43/// -1/3fe0000000000000/0/40718400f419c85b/c0985cd7922fd15b/0/-4_3,1_4/403c600000000000,4051400000000000,4050380000000000,0,4042000000000000,4054800000000000,3f2e83390b5c9c43/// => false
+reset - 1/3f50624dd2f1a9fc/0/406fdc0000000000/c0a82e54c3bf290c/0/-7_4/4043800000000000,4055000000000000,405ab80000000000,4039000000000000/// 2/3f50624dd2f1a9fc/0/406fdc0000000000/c0a82e54c3bf290c/2/-15_1,2_4/4043800000000000,4055000000000000,404ef00000000000,4046800000000000,4039000000000000/// => false
+reset - -53/0/0/405de00000000000/40b9e1910b9613ac/0/0_1/4026000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405de00000000000/40b9e1910b9613ac/2/0_2/4026000000000000,405b200000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+reset - -53/0/0/0/8000000000000000/0/////4000000000000000 -53/0/0/0/8000000000000000/2/////4000000000000000 => false
+reset - -53/0/0/0/0/0/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/1/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => false
+reset - 2/3fe0000000000000/4022000000000000/4083c201d5baf644/40c8b392fbcca4fa/0/-3_7,0_1/4000000000000000,4057800000000000,0,4062200000000000,3f2ba173735f7df6,404f800000000000,4034000000000000,4022000000000000/-3_4/3f45d236030e8189,0,4056c00000000000,3ef423908bf25d29/ 2/3fe0000000000000/0/406360072182b8f4/40a0e08ecdb33217/2/-2_4,2_1/0,0,404b800000000000,3f284ae1718880ec,4022000000000000/-3_4/3f45d236030e8189,0,4056c00000000000,3ef423908bf25d29/ => false
+reset - -2/3f847ae147ae147b/0/40714003e5941c56/c0a44994947a9589/0/-5_1,1_1/0,0/-4_4/4056400000000000,4058400000000000,4053000f96507159,402c000000000000/ -1/3f847ae147ae147b/0/40714003e5941c56/c0a44994947a9589/3/-10_1,2_1/0,0/-9_3,0_4/4008000000000000,4055800000000000,404b000000000000,4045800000000000,4053000000000000,3f4f2ca0e2b2ee2a,402c000000000000/ => false
+reset - -4/3f50624dd2f1a9fc/0/4069200814429140/40cae8d7c959e134/0/2_3,0_4/4020000000000000,4055800000000000,4018000000000000,3f502885227f4d43,4056000000000000,402a000000000000,0/// -4/3f50624dd2f1a9fc/0/4069200814429140/40cae8d7c959e134/1/2_3,0_4/4020000000000000,4055800000000000,4018000000000000,3f502885227f4d43,4056000000000000,402a000000000000,0/// => false
+reset - -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/3/////3ff0000000000000,4014000000000000,4024000000000000 => false
+reset - 1/255bba08cf8c979d/403c000000000000/407b9a0000000000/40d4627506e56493/0/-19_2,25_2,1_3,0_1/0,4054c00000000000,4046800000000000,404a800000000000,4038000000000000,0,4055000000000000,405f280000000000/// 1/255bba08cf8c979d/403c000000000000/40766a0000000000/40d2d9c9d1f58740/2/8_2,1_3,0_1/4046800000000000,404a800000000000,4038000000000000,0,4055000000000000,405f280000000000/// => false
+reset - -1/3f50624dd2f1a9fc/0/4033801eb0f3d617/40865d359029cc30/3///-15_2,2_2/401b000000000000,4029800000000000,3f3eb0f3d61681fe,0/ 2/3f847ae147ae147b/404c800000000000/404c800000000000/c08199b0b1556d2b/3///// => true
+reset - -3/0/0/4062c40f4459d01e/408978b532ba3038/0/-2_1,1_2/401d400000000000,3f42657079c7c939,404b001a506abc34/-6_1,1_1,1_2/3f405b8c0a7ae26a,4053400000000000,4026000000000000,0/ -2/0/0/4062c40f4459d01e/408978b532ba3038/0/-4_1,2_1,1_2/4020400000000000,3f42657079c7c939,3f4a506abc340ed7,404b000000000000/-12_1,2_2,2_3/3f405b8c0a7ae26a,4018000000000000,4051c00000000000,4000000000000000,4022000000000000,0/ => true
+reset - -2/255bba08cf8c979d/3f297a5cc13479bc/4062600197a5cc13/c095040da874438d/0/-16_3,0_2/404b800000000000,0,0,4054400000000000,4026000000000000/// 5/3f847ae147ae147b/0/40839b0000000000/c0b838eef98841d9/0///-18_4,1_1,2_2/405a800000000000,4044000000000000,404b000000000000,405b600000000000,4058c00000000000,405f380000000000,4057800000000000/ => true
+reset - -53/0/0/4026000000000000/406d7db8b4e951df/3/0_1,0_1/0,4026000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 8/3fe0000000000000/0/4076a0010f5719e8/40d2583a16979f35/3/8_4,2_3/4051c00000000000,3f30f5719e7ad704,4021800000000000,4057000000000000,4057c00000000000,0,4057d00000000000/// => true
+reset - -4/3fe0000000000000/0/40813b01c69c9adf/40e2d7731803f877/0/2_2,2_4,1_4/0,3f24dc2f115738e2,405bf00000000000,4051400000000000,0,3ee3377dbc9cc25e,404f000000000000,4057000000000000,0,4053c00000000000/-11_3,1_2,0_2/4010000000000000,404d000000000000,4046000000000000,0,3f45a6b4ac4ba388,3f03f2b4655e770d,403fa00000000000/ -4/3fe0000000000000/0/40813b01c69c9adf/40e2d7731803f877/3/2_2,2_4,1_4/0,3f24dc2f115738e2,405bf00000000000,4051400000000000,0,3ee3377dbc9cc25e,404f000000000000,4057000000000000,0,4053c00000000000/-11_3,1_2,0_2/4010000000000000,404d000000000000,4046000000000000,0,3f45a6b4ac4ba388,3f03f2b4655e770d,403fa00000000000/ => false
+reset - 0/0/4040100000000000/406f140000000000/c0b65f915ab75980/0/-1099_1/4010000000000000/// 0/0/4040100000000000/406f140000000000/c0b65f915ab75980/3/-1100_2/4008000000000000,4010000000000000/// => true
+reset - -4/255bba08cf8c979d/402c000000000000/405ac00000000000/4099f68b8be9588e/0/-1_2/4018000000000000,4055c00000000000/// -4/255bba08cf8c979d/402c000000000000/405ac00000000000/4099f68b8be9588e/2/-1_3,2_2/4018000000000000,4055c00000000000,0,0,0/// => false
+reset - 0/3fe0000000000000/0/40776602e85b9034/40d85f179288d917/0/-1_2/404e900000000000,4018000000000000/5_3,1_3/4033000000000000,3f4742dc819e363c,4011000000000000,4052280000000000,4057000000000000,4053180000000000/ 0/3fe0000000000000/0/40776602e85b9034/40d85f179288d917/3/-1_3,0_1/404e900000000000,4018000000000000,0,4045800000000000/5_4,0_3/4033000000000000,3f4742dc819e363c,4011000000000000,0,4052280000000000,4057000000000000,4053180000000000/ => true
+reset - 0/255bba08cf8c979d/0/4084440000000000/40e43e7814210e6c/0/-17_2,2_1/4020000000000000,4051000000000000,404f000000000000/1_2,3_6/4035000000000000,4053800000000000,4048800000000000,4028000000000000,4035000000000000,404fb00000000000,4052980000000000,4059300000000000/ 0/255bba08cf8c979d/0/4084440000000000/40e43e7814210e6c/2/-17_2,2_2/4020000000000000,4051000000000000,404f000000000000,4056c00000000000/1_3,2_2,0_4/4035000000000000,4053800000000000,0,4048800000000000,4028000000000000,4035000000000000,404fb00000000000,4052980000000000,4059300000000000/ => true
+reset - -2/255bba08cf8c979d/0/40803f02f98ec8da/40e06d117a9b32be/0/-19_4/405f080000000000,4056800000000000,4056000000000000,4054c00000000000/9_4,1_3/401e800000000000,404cc00000000000,3f4aa42a45d79547,404e500000000000,4022000000000000,3f44f4c247ba65c6,0/ -2/255bba08cf8c979d/0/40803f02f98ec8da/40e06d117a9b32be/3/-19_4/405f080000000000,4056800000000000,4056000000000000,4054c00000000000/9_4,1_3/401e800000000000,404cc00000000000,3f4aa42a45d79547,404e500000000000,4022000000000000,3f44f4c247ba65c6,0/ => false
+reset - 3/3fe0000000000000/403e00004f89b8ed/408633026a6c1ef5/40d9eb692b0ecdb0/0/-1_2,1_3/4054000000000000,40526403ba9d1d64,4054000000000000,3f4794889d4a3c9e,4052900000000000/-1_2/4064000000000000,4061600000000000/ 5/3fe0000000000000/3ed3e26e3b397ac3/40634805ef135e70/c08bb36d7c67fca0/3/6_4,1_1,1_2/0,4054000000000000,0,0,3f4794889d4a3c9e,4049a00000000000,4037000000000000/// => false
+reset - 8/3fe0000000000000/404d000000000000/40760007d48baa28/40bfb2e19ca758dc/0/-5_2,2_5/4053800000000000,4046000000000000,3f5004d3c79c5a3c,3f295183279f11b7,3f41f1f42e3383a5,4054c00000000000,4056400000000000/// 8/3fe0000000000000/404d000000000000/404d000000000000/40935d576adc99c0/1///// => false
+reset - -53/0/0/3f308a8afdc91116/3f904ced411bdef4/1/1_1/3f308a8afdc91116///4000000000000000 -53/0/0/4033000000000000/c08144da425ab29c/1/0_1/4033000000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+reset - -4/3fe0000000000000/0/405c400000000000/c0907d8c073b2ebe/0///-14_4,2_1/4000000000000000,0,4020000000000000,404f000000000000,4044800000000000/ -4/3fe0000000000000/0/405c400000000000/c0907d8c073b2ebe/2///-14_4,2_1/4000000000000000,0,4020000000000000,404f000000000000,4044800000000000/ => false
+reset - -4/0/0/4063a0072078a673/40bff321d6c94308/0/-1099_1/4010000000000000/9_4,0_1/0,4026000000000000,3f33e94dc124571f,4041000000000000,3f1e4f87571edf20/ -4/0/0/4063a0072078a673/40bff321d6c94308/2/-1100_2/4008000000000000,4010000000000000/9_4,0_1/0,4026000000000000,3f33e94dc124571f,4041000000000000,3f1e4f87571edf20/ => true
+reset - 1/3f60624dd2f1a9fc/412e848000000000/416312d000000000/40c186022a49dfe4/0/1_1/404c000000000000/// 1/0/405b200000000000/4064900000000000/40c186022a49dfe4/3/1_1/404c000000000000/// => false
+reset - -1/3f50624dd2f1a9fc/0/3f4d1b62d237281f/3f9f3c70cfcfe15c/0/2_1/3f4a323f56cb3db6/// 0/3f50624dd2f1a9fc/0/3f4d1b62d237281f/3f9f3c70cfcfe15c/0/4_1/3f4d1b62d237281f/// => true
+reset - 3/3f60624dd2f1a9fc/412e848000000000/416312d000000000/40c56453244c3bcf/0/-11_4,1_1/4044800000000000,0,4053400000000000,3ff0000000000000,4055c00000000000/// 3/0/0/4069c00000000000/40c56453244c3bcf/3/-11_4,1_1/4044800000000000,0,4053400000000000,3ff0000000000000,4055c00000000000/// => false
+reset - -53/0/0/4078880000000000/40d40f2fb80b9652/0/0_1/4078880000000000/// -53/0/0/4061c00000000000/40b511b8a7213f54/1/0_2/404a800000000000,4056400000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => false
+reset - -3/3fe0000000000000/3f4f5a297004d77f/407ff209e22d62fe/40dd9ee665d12831/0/0_7/4053000000000000,0,4065a40000000000,4052c00000000000,404de00000000000,404a800000000000,3f4af272a19e07c6/// -2/3fe0000000000000/3f4c7935ed8ebea5/406b980ddaea23cc/40c88b176da859fa/3/4_3,0_1,2_2/4040800000000000,0,4052c00000000000,404de00000000000,404a800000000000,3f4af272a19e07c6/// => false
+reset - 4/3f847ae147ae147b/405ca00000000000/4072380000000000/40c80a96be3ffcdf/0/4_1/4054400000000000/-3_1/4058000000000000/ 5/3f847ae147ae147b/405ca00000000000/4072380000000000/40c80a96be3ffcdf/3/8_1/4054400000000000/-7_1/4058000000000000/ => false
+reset - 0/3f60624dd2f1a9fc/412e848000000000/416312d000000000/40a3034a81e27877/0/0_2/4018000000000000,4045800000000000/// 0/0/0/4048800000000000/40a3034a81e27877/1/0_2/4018000000000000,4045800000000000/// => false
+reset - -53/0/0/3f423c3ae31ee361/bf7b65589bf8b43c/1/0_3/0,3f423c3ae31ee361,0///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/3f423c3ae31ee361/bf7b65589bf8b43c/1/0_3/0,3f423c3ae31ee361,0///3ff0000000000000,4000000000000000,4014000000000000 => true
+reset - 8/3f847ae147ae147b/0/4053801af206d495/4097c3de3b6b9b21/0///-16_3,1_2/3f4e61e575b30ba4,4053800000000000,0,3f47822833768b70,0/ 8/3f847ae147ae147b/0/4053801af206d495/4097c3de3b6b9b21/2///-16_3,1_2/3f4e61e575b30ba4,4053800000000000,0,3f47822833768b70,0/ => false
+reset - -2/255bba08cf8c979d/404de00000000000/4085d802a9b8f1f9/40db4d7125ad51ee/0/-20_3,2_1,1_3,14_4,2_2/4042800000000000,0,403c000000000000,4050800000000000,4047800000000000,405e080000000000,0,0,4050800000000000,4050800000000000,4055c00000000000,3f3bd109f025b890,4047300000000000/-16_4,1_2,2_2/4026000000000000,402c000000000000,403f000000000000,0,4008000000000000,3f4cb30a278192d0,401c000000000000,4023800000000000/ -2/255bba08cf8c979d/4047000000000000/407832055371e3f2/40d0ebf79a681c96/1/4_4,2_2/0,4050800000000000,4050800000000000,4055c00000000000,3f3bd109f025b890,4047300000000000/-16_4,1_2,2_2/4026000000000000,402c000000000000,403f000000000000,0,4008000000000000,3f4cb30a278192d0,401c000000000000,4023800000000000/ => false
+reset - 2/3fe0000000000000/0/0/0/0///// 2/3fe0000000000000/0/0/0/2///// => false
+reset - 1/3fe0000000000000/4043c00000000000/407c7c02c108b30f/40c3e3e353504773/0/-10_2/4052c00000000000,4052800000000000/-15_4,2_4/4037000000000000,3f3619cc074be96d,4054c00000000000,3f35f6bf29ae1615,0,4031c00000000000,4035000000000000,4054c00000000000/ 1/3fe0000000000000/4053c00000000000/407c7c02c108b30f/40c3e3e353504773/3/-10_2/4052c00000000000,4052800000000000/-15_4,2_4/4037000000000000,3f3619cc074be96d,4054c00000000000,3f35f6bf29ae1615,0,4031c00000000000,4035000000000000,4054c00000000000/ => true
+reset - 5/3f847ae147ae147b/0/4020000000000000/407c5ce8caf04bcd/0/-12_1/4020000000000000/// -1/3f847ae147ae147b/3f2f623c6628326b/406a6001f623c662/c0a8c1f0ee48f1e3/1/-18_4/4055800000000000,4050000000000000,404e800000000000,0/// => true
+reset - -53/0/0/0/0/0/////4000000000000000 -53/0/0/0/0/0/////4000000000000000 => false
+reset - 2/255bba08cf8c979d/0/4063300000000000/40c2dc8bb07840b4/0/-3_2/404c000000000000,4058600000000000/// 3/255bba08cf8c979d/0/4063300000000000/40c2dc8bb07840b4/2/-6_3/404c000000000000,4054400000000000,4030800000000000/// => false
+reset - -1/3f50624dd2f1a9fc/3f50a97112736f6c/4069240c21ecfe01/c0b6259adc7d2260/0/-1_1,0_4/405a080000000000,4053400000000000,4030000000000000,4010000000000000,3f3e69a3a6379fee/// -1/3f50624dd2f1a9fc/3f4b7b1c0f741447/4069240aabfb78a4/c0b6259a3213d4ea/0/-1_1,0_4/405a080000000000,4053400000000000,4030000000000000,4010000000000000,3f3e69a3a6379fee/// => false
+reset - -53/0/0/4056c003f9219a09/40b33adc58be43f6/0/0_3/404c8007f2433413,0,4031000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/3f2fc90cd04a8897/bf707404426db297/3/0_2/3f2fc90cd04a8897,0///3ff0000000000000,4014000000000000,4024000000000000 => false
+reset - -53/0/0/404c701c459ce558/4094dfd6e343d585/0/0_3/4046800000000000,4027c03caac981c9,3f3a35d509cc163e///3ff0000000000000,4014000000000000 -53/0/0/0/0/0/////3ff0000000000000,4014000000000000,4024000000000000 => false
+reset - -3/3f847ae147ae147b/0/406d3c06e2eeb086/40c32f29690a8a91/0/-6_1,1_4/4050000000000000,4055400000000000,402fc00000000000,4051400058c9c5f6,3f4ada27362aa8e3/// -2/3f847ae147ae147b/0/406d3c06e2eeb086/40c32f29690a8a91/0/-12_1,2_4,0_3/4050000000000000,4055000000000000,3ff0000000000000,4024000000000000,4017800000000000,3ef632717d8dec13,4051400000000000,3f4ada27362aa8e3/// => false
+reset - -4/0/0/0/8000000000000000/0///// 2/3f847ae147ae147b/0/407a5a08316a71f8/40c03c7a9b3b886f/3/9_1,1_2,2_3/4051400000000000,3f470e92a37c6b80,3f4c2a31caa11c1f,0,4040800000000000,4039000000000000/5_4,2_4,0_3/0,3f3ca51e434753c9,0,0,0,4037000000000000,405c400000000000,404d000000000000,4051e80000000000,4039000000000000,4010000000000000/ => true
+reset - -2/0/0/405ad81127db2fee/40b28a4cc380a1d5/0/-1099_1/4010000000000000/// -2/0/0/405ad81127db2fee/40b28a4cc380a1d5/1/-1100_2/4008000000000000,4010000000000000/// => true
+reset - 3/3f847ae147ae147b/4042000000000000/4068140000000000/4090959552c103c7/0/1_3/4048000000000000,0,405b280000000000/// 5/3f847ae147ae147b/4042000000000000/4068140000000000/4090959552c103c7/3/4_1,1_1,2_3/4048000000000000,0,4018000000000000,0,4059a80000000000/// => false
+reset - -2/3fe0000000000000/0/4064c00777cf3e6f/40ad81bee3982381/0/-8_1,1_3,0_1/0,4054800000000000,4055000000000000,3f2762483d6c3f6e,3f4806aaea60ad00/// -2/3fe0000000000000/0/4064c00777cf3e6f/40ad81bee3982381/1/-8_1,1_3,0_1/0,4054800000000000,4055000000000000,3f2762483d6c3f6e,3f4806aaea60ad00/// => false
+reset - -4/3f847ae147ae147b/0/4058a815833b7a70/40bacef5c138f62c/0/-7_4,1_2/3f449925f55d7c30,4035000000000000,404ad00000000000,4038000000000000,0,3f466d50ff816e42/// -4/3f847ae147ae147b/0/4058a815833b7a70/40bacef5c138f62c/3/-7_4,1_2/3f449925f55d7c30,4035000000000000,404ad00000000000,4038000000000000,0,3f466d50ff816e42/// => false
+reset - -2/0/0/4063bc0000000000/40af9ea900aed8f7/2/-6_1,1_4,1_1/0,4024000000000000,0,0,4039c00000000000,405e880000000000/// 5/3fe0000000000000/3f3e0461f0da5ce7/40789005ada683f8/c0c34580f54df972/1/-8_2,2_4,0_3/4052c00000000000,4026000000000000,3f4e6b03274efcf0,0,4050000000000000,4041000000000000,4057800000000000,4040800000000000,4054800000000000/// => false
+reset - 0/0/0/406ea0015f53ec8c/406cb28bea6595bd/0/-1099_1/4010000000000000/// 0/0/0/406ea0015f53ec8c/406cb28bea6595bd/1/-1100_2/4008000000000000,4010000000000000/// => true
+reset - 2/3ff0000000000000/412e848000000000/416312d000000000/40d35d01cd3c463a/0/8_2,0_3,1_1/4057e00000000000,4053400000000000,4035000000000000,404b200000000000,4044000000000000,4042200000000000/// 2/3fe0000000000000/0/4074400000000000/40d35d01cd3c463a/2/8_2,0_3,1_1/4057e00000000000,4053400000000000,4035000000000000,404b200000000000,4044000000000000,4042200000000000/// => false
+reset - 8/3f947ae147ae147b/412e848000000000/416312d000000000/0/0///// 8/3f847ae147ae147b/0/0/0/0///// => false
+reset - -1/3fe0000000000000/4050000000000000/4050000000000000/40a0a3662e2958bd/0///// 0/3fe0000000000000/4050000000000000/4050000000000000/40a0a3662e2958bd/2///// => false
+reset - -53/0/0/404f000000000000/409540cbde9cb91d/0/0_1/404f000000000000///4000000000000000 -53/0/0/0/8000000000000000/3/////4000000000000000 => false
+reset - 3/0/4060000000000000/406ea004126c51f8/40c0bbe850a37b19/0/-10_1,0_3,2_1/3f4049b147de77aa,0,4047800000000000,4051800000000000,0/// 3/0/4059000000000000/406b2004126c51f8/40c156c195227304/1/-10_1,0_3,2_1/3f4049b147de77aa,0,4047800000000000,4051800000000000,0/// => false
+reset - -4/3f847ae147ae147b/4010800000000000/4051481185c66f6e/40a32c306fe8fe45/0/5_1/3f262e30c50f2eef/// -4/3f847ae147ae147b/0/3f262e30c50f2eef/3f80e0f16fa0f0fb/0/5_1/3f262e30c50f2eef/// => false
+reset - -2/0/0/40617807f1a03a3f/40a6909b48bdbca5/0/-1099_1/4010000000000000/-13_3/401c000000000000,3f4fc680e8fb6d9b,4053200000000000/ -2/0/0/40617807f1a03a3f/40a6909b48bdbca5/3/-1100_2/4008000000000000,4010000000000000/-13_3/401c000000000000,3f4fc680e8fb6d9b,4053200000000000/ => true
+reset - 8/3ff0000000000000/412e848000000000/416312d000000000/405989729aac957a/0/6_2,1_4,2_2/0,3f02e2510ebc090b,4050800000000000,4052400000000000,4054400000000000,4019800000000000,4041800000000000,4052800000000000/// 8/3fe0000000000000/0/4074f60025c4a21e/405989729aac957a/3/6_2,1_4,2_2/0,3f02e2510ebc090b,4050800000000000,4052400000000000,4054400000000000,4019800000000000,4041800000000000,4052800000000000/// => false
+reset - 0/255bba08cf8c979d/0/404f000000000000/408c22d35cc84836/0/4_1,1_1/0,404f000000000000/// 1/255bba08cf8c979d/0/404f000000000000/408c22d35cc84836/0/8_1,2_1/0,404f000000000000/// => false
+reset - -1/3f50624dd2f1a9fc/403c000000000000/407a8604e0a317a0/c0b01be4d45e5138/0/-6_4,3_3/4028000000000000,4058c009efe96010,4049800000000000,403a000000000000,4050000000000000,4050d00000000000,4043480000000000/4_1/3f432545fcdddac6/ 0/3f50624dd2f1a9fc/0/40678009c1462f3f/c0a32394b3b84786/1/-13_4,1_2/0,4028000000000000,3f43dfd2c020def4,4058c00000000000,4049800000000000,403a000000000000/8_1/3f432545fcdddac6/ => false
+reset - -53/0/0/0/0/3/////4000000000000000 -53/0/0/0/0/0/////4000000000000000 => false
+equals - -2/255bba08cf8c979d/0/4064400000000000/c0b0126199bb31ca/2/-1_3,2_3/0,0,4050400000000000,4050c00000000000,403e000000000000,0/// -2/255bba08cf8c979d/0/4064400000000000/c0b0126199bb31ca/2/-1_3,2_3/8000000000000000,0,4050400000000000,4050c00000000000,403e000000000000,0/// => false
+equals - 8/3fe0000000000000/0/406f300000000000/c0b53f9b1398ab96/3/3_3,2_2,2_2/0,4043000000000000,0,0,0,4058000000000000,4048400000000000/// 8/3fe0000000000000/0/406f300000000000/c0b53f9b1398ab96/3/3_3,2_2,2_2/8000000000000000,4043000000000000,0,0,0,4058000000000000,4048400000000000/// => false
+equals - -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/0/3/////bff0000000000000,0,3fe0000000000000,4024000000000000 => true
+equals - -2/255bba08cf8c979d/3f1b9c015a4a8cac/3f1b9c015a4a8cac/3f73acc75511da9b/2///// 2/3f50624dd2f1a9fc/0/404b000000000000/40ab5e87392ee242/1/-11_2/404b000000000000,0/// => false
+equals - 5/255bba08cf8c979d/4047000000000000/4047000000000000/409b7f19e51e950a/2///// 5/255bba08cf8c979d/4047000000000000/4047000000000000/409b7f19e51e950a/2///// => true
+equals - 8/3f847ae147ae147b/0/40650007bdac69a3/c0b23f8c9c9d35a3/1/2_2/4042400000000000,403c000000000000/-5_3,2_3/404f400000000000,3f46f0bd1cd3662b,0,4033000000000000,4036000000000000,3f300be913702e76/ 8/3f847ae147ae147b/0/40650007bdac69a3/c0b23f8c9c9d35a3/1/2_2/4042400000000000,403c000000000000/-5_2,3_3/404f400000000000,3f46f0bd1cd3662b,4033000000000000,4036000000000000,3f300be913702e76/ => false
+equals - 3/3f847ae147ae147b/4050400000000000/405cc004fb9490c8/409ec5467e0280ce/2/2_2,2_1/3f33ee52431f05cc,4047000000000000,4010000000000000/// 1/255bba08cf8c979d/0/4075d60002a51574/40a41bc256d5b04a/2///-16_1,0_4,2_2/4042300000000000,4054780000000000,4054800000000000,4010000000000000,3ec528aba2e0b760,4057800000000000,4049900000000000/ => false
+equals - -53/0/0/0/0/0/////4000000000000000 -53/0/0/0/0/0/////4000000000000000 => true
+equals - 0/255bba08cf8c979d/3ff0000000000000/405d180a8a16c3d7/408375e3b355f476/3/-20_1,1_2,1_3/0,3f44b046c5751d17,4050c00000000000,3ee8f9b08e013814,4043800000000000,4022c00000000000/// 0/255bba08cf8c979d/3ff0000000000000/405d180a8a16c3d7/408375e3b355f476/3/-20_1,1_2,1_3/8000000000000000,3f44b046c5751d17,4050c00000000000,3ee8f9b08e013814,4043800000000000,4022c00000000000/// => false
+equals - 8/3f50624dd2f1a9fc/3f2d66a05b1ec9d5/404a0026c69b72a9/40a33343d667473e/3/-3_1,2_1/404a000000000000,3f4f6cf35be0bfae/// 8/3f50624dd2f1a9fc/3f2d66a05b1ec9d5/404a0026c69b72a9/40a33343d667473e/3/-3_1,2_1/404a000000000000,3f4f6cf35be0bfae/// => true
+equals - -53/0/0/4042b00000000000/c04cdc5d6f682bc5/1/0_1/4042b00000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4042b00000000000/c04cdc5d6f682bc5/1/0_1/4042b00000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 5/3fe0000000000000/0/4067300000000000/c0ab897d5fe09f3a/2/-15_1,2_3/0,4034000000000000,4059100000000000,4047a00000000000/// 5/3fe0000000000000/0/4067300000000000/c0ab897d5fe09f3a/2/-15_1,2_3/8000000000000000,4034000000000000,4059100000000000,4047a00000000000/// => false
+equals - 5/255bba08cf8c979d/0/4069c00949e31bad/40b0a45461f1912b/3/1_3,2_2,2_3/4010000000000000,4042800000000000,4024000000000000,4038000000000000,4044000000000000,3f230033b16a6305,0,402c000000000000/5_1,1_1/4053400000000000,3f5033bfc12d5455/ 5/255bba08cf8c979d/0/4069c00949e31bad/40b0a45461f1912b/3/1_3,2_2,2_1,1_1/4010000000000000,4042800000000000,4024000000000000,4038000000000000,4044000000000000,3f230033b16a6305,402c000000000000/5_1,1_1/4053400000000000,3f5033bfc12d5455/ => false
+equals - 2/255bba08cf8c979d/4055800000000000/406ba00000000000/40a8a1fe3c43e281/3/4_2/0,4056c00000000000/8_1/4046000000000000/ 2/255bba08cf8c979d/4055800000000000/406ba00000000000/40a8a1fe3c43e281/3/4_2/8000000000000000,4056c00000000000/8_1/4046000000000000/ => false
+equals - -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/0/////3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - -2/3f50624dd2f1a9fc/404e000000000000/4065800000000000/40c685d3d2392045/0/8_3/4057000000000000,0,4034000000000000/// -2/3f50624dd2f1a9fc/404e000000000000/4065800000000000/40c685d3d2392045/0/8_1,1_1/4057000000000000,4034000000000000/// => false
+equals - -53/0/0/0/0/1/1_1/0///bff0000000000000,0,3fe0000000000000,4024000000000000 -53/0/0/0/0/1/1_1/8000000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => false
+equals - 2/3f847ae147ae147b/0/40771c0000000000/40d22c550365442b/3///0_4,0_2,1_2/4055d00000000000,4056400000000000,405eb80000000000,4042500000000000,0,0,4041000000000000,0/ -4/3fe0000000000000/4057000000000000/406668033223e1be/40b7f4cdc7faf86f/3///-1_2/4055d00000000000,3f39911f0dedae2c/ => false
+equals - -1/3f847ae147ae147b/0/40778207222382fa/40d3840afb034669/1/-20_4,0_3,0_2/3f4940b6691ced4d,4057c00000000000,0,3f4fd065aeafcc67,405f100000000000,4038000000000000,4031400000000000,401c000000000000,405b280000000000/// -2/0/402a800000000000/4066680000000000/40bc2f10bb7da01c/1/9_1,2_3/4044000000000000,4050800000000000,0,4044000000000000/-4_1/4034000000000000/ => false
+equals - -1/0/4014000000000000/4014000000000000/406add692e2b65c1/0///// -1/0/4014000000000000/4014000000000000/406add692e2b65c1/0///// => true
+equals - 1/0/3f3abcb272b72dc6/40745e0699240bf5/c094e4a1634cc93c/3/3_1,2_2,0_3/3f335b9a24a51208,4030000000000000,4045700000000000,4036000000000000,4058000000000000,0/-17_4,0_2,0_1/404f800000000000,3f35b68427a11737,3f30a477719e97d7,0,3f351ef88eb02837,4055800000000000,0/ 1/0/3f3abcb272b72dc6/40745e0699240bf5/c094e4a1634cc93c/3/3_1,2_4/3f335b9a24a51208,4030000000000000,4045700000000000,4036000000000000,4058000000000000/-17_3,1_2/404f800000000000,3f35b68427a11737,3f30a477719e97d7,3f351ef88eb02837,4055800000000000/ => false
+equals - -1/255bba08cf8c979d/0/406160077b5cc802/c0a55c12090ff9e3/3/-20_4,0_2,1_1/4048000000000000,3ff0000000000000,3f4ded732007f394,0,0,0,4056800000000000/// -1/255bba08cf8c979d/0/406160077b5cc802/c0a55c12090ff9e3/3/-20_3,4_1/4048000000000000,3ff0000000000000,3f4ded732007f394,4056800000000000/// => false
+equals - -53/0/0/405c000000000000/40a2099422d11d43/2/1_3/4043000000000000,4044800000000000,4040800000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405c000000000000/40a2099422d11d43/2/1_3/4043000000000000,4044800000000000,4040800000000000///3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - -2/0/0/0/0/3/-15_1/0/// -2/0/0/0/0/3/-15_1/8000000000000000/// => false
+equals - 5/3f50624dd2f1a9fc/4034200000000000/4034200000000000/c08101fc5eff7d4b/0///// 5/3f50624dd2f1a9fc/4034200000000000/4034200000000000/c08101fc5eff7d4b/0///// => true
+equals - 0/0/0/4084c603a9c75207/40e3516002ad4413/1/-5_2,1_4/4053400000000000,4055400000000000,4022000000000000,0,3f4d05efbe635f9a,4058400000000000/-7_4,2_4/4052400000000000,4058700000000000,4014000000000000,0,405cd00000000000,3f4d96856208abf9,4011000000000000,4059600000000000/ 0/0/0/4084c603a9c75207/40e3516002ad4413/1/-5_2,1_1,1_2/4053400000000000,4055400000000000,4022000000000000,3f4d05efbe635f9a,4058400000000000/-7_3,3_4/4052400000000000,4058700000000000,4014000000000000,405cd00000000000,3f4d96856208abf9,4011000000000000,4059600000000000/ => false
+equals - 8/0/0/0/8000000000000000/2///// -2/3f50624dd2f1a9fc/0/4069200017f343fb/40b10719abb48945/2/3_3,2_4/0,0,3ff0000000000000,404a800000000000,4053c00000000000,3ee7f343fb4786e8,4051000000000000/// => false
+equals - 2/3f847ae147ae147b/0/4055000000000000/40af3bdf4ee3d42b/3/-3_2/4047000000000000,4043000000000000/// 2/3f847ae147ae147b/0/4055000000000000/40af3bdf4ee3d42b/3/-3_2/4047000000000000,4043000000000000/// => true
+equals - -53/0/0/40658c0000000000/c0a0facc2c0ebcd1/1/0_3/4053800000000000,4052b00000000000,4033a00000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/40658c0000000000/c0a0facc2c0ebcd1/1/0_3/4053800000000000,4052b00000000000,4033a00000000000///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 0/255bba08cf8c979d/3f453b21f4d42f4c/3f453b21f4d42f4c/3fa3c8696907ea09/2///8_1/0/ 0/255bba08cf8c979d/3f453b21f4d42f4c/3f453b21f4d42f4c/3fa3c8696907ea09/2///8_1/0/ => true
+equals - -53/0/0/4038000000000000/40798905fe920e9e/2/1_1/4038000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4038000000000000/40798905fe920e9e/2/1_1/4038000000000000///3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - -53/0/0/3f472db10700449c/3fa3f36dbb150444/0/0_1/3f472db10700449c///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/3f472db10700449c/3fa3f36dbb150444/0/0_1/3f472db10700449c///3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 5/3fe0000000000000/403e000000000000/405c800000000000/4094e700b1d74519/0/-11_2/0,4055000000000000/// 5/3fe0000000000000/403e000000000000/405c800000000000/4094e700b1d74519/0/-11_2/0,4055000000000000/// => true
+equals - 1/0/3f4faf82e0158416/4059b01fb09c3428/40b23d90a95ff270/1/-12_3,1_2,1_2/0,0,3f4fb1b5883b78f0,4033000000000000,0,4044600000000000,0/// 1/0/3f4faf82e0158416/4059b01fb09c3428/40b23d90a95ff270/1/-12_3,1_2,1_2/8000000000000000,0,3f4fb1b5883b78f0,4033000000000000,0,4044600000000000,0/// => false
+equals - 8/0/0/0/8000000000000000/2///1_1,0_1/0,0/ 8/0/0/0/8000000000000000/2///// => false
+equals - -53/0/0/4044000000000000/c08d2a9b156837e2/1/0_2/0,4044000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/4044000000000000/c08d2a9b156837e2/1/1_1/4044000000000000///3ff0000000000000,4014000000000000,4024000000000000 => false
+equals - 5/3f847ae147ae147b/3f502cb86ccce032/40634008165c3666/c091fb48158dd12c/3/0_3/0,404e800000000000,4056800000000000/// 5/3f847ae147ae147b/3f502cb86ccce032/40634008165c3666/c091fb48158dd12c/3/0_3/8000000000000000,404e800000000000,4056800000000000/// => false
+equals - -53/0/0/405b900000000000/40ba976f7f553953/2/0_2/4059d00000000000,401c000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/405b900000000000/40ba976f7f553953/2/0_2/4059d00000000000,401c000000000000///3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - -53/0/0/0/0/2/////4000000000000000 -53/0/0/0/0/2/////4000000000000000 => true
+equals - -2/0/0/0/0/3///// -2/0/0/0/0/3///// => true
+equals - 8/0/0/407d820539702c75/40d16ecab023d890/0///-9_3,1_4,1_3/4040000000000000,4036e00000000000,405cd00000000000,3f4675ba8b5777b8,404b800000000000,4052c00000000000,4047000000000000,3f4355c6d85252e4,4054400000000000,4046800000000000/ 8/0/0/407d820539702c75/40d16ecab023d890/0///-9_3,1_4,1_3/4040000000000000,4036e00000000000,405cd00000000000,3f4675ba8b5777b8,404b800000000000,4052c00000000000,4047000000000000,3f4355c6d85252e4,4054400000000000,4046800000000000/ => true
+equals - -53/0/0/4056c00000000000/40b2b3b00143762e/3/0_1/4056c00000000000///4000000000000000 -53/0/0/4056c00000000000/40b2b3b00143762e/3/0_1/4056c00000000000///4000000000000000 => true
+equals - 1/0/0/4064c40000000000/c0861cb896add205/2///-12_4,1_1/4030000000000000,4045800000000000,403e000000000000,4051400000000000,4020400000000000/ -1/3f50624dd2f1a9fc/0/40652002bbdfbbfe/407338515c1041ec/3/-15_4,2_3,2_1/4050000000000000,4040800000000000,0,0,3f35defddff45099,0,401c000000000000,4050400000000000/// => false
+equals - 3/3f50624dd2f1a9fc/3f44caf6455707a7/3f44caf6455707a7/3f91ff9e4c85a0e1/2///// 3/3f50624dd2f1a9fc/3f44caf6455707a7/3f44caf6455707a7/3f91ff9e4c85a0e1/2///// => true
+equals - 5/255bba08cf8c979d/0/0/0/3///// -1/255bba08cf8c979d/4051000000000000/4087440735f2fa5f/c0c30adcf3223021/1/-17_4,0_3,2_4/402a000000000000,3f4619b9cf6ed76b,4014000000000000,4042000000000000,3f3bd7fae25880ca,0,4058000000000000,4030000000000000,4021000000000000,4052c00000000000,3f43989eaa370450/-2_4,0_4,0_3/3f42d18ee83bb0f0,4053c00000000000,4051980000000000,4053000000000000,3f3911ed968f176c,3f2d30cfe2e6efd5,401a800000000000,4049800000000000,404e800000000000,4054c00000000000,3f451a200ef25300/ => false
+equals - -1/3f847ae147ae147b/3efe089e949fd4a4/40796e05c4d7173c/40bdfee931e72249/3/-6_3/4054800000000000,3f4634db3a3d9494,4056780000000000/0_1,0_4,0_2/4058400000000000,3f40101924fda0b7,3f2bc5fd97f59eda,0,4047000000000000,4033800000000000,4052200000000000/ -2/3f50624dd2f1a9fc/404e800000000000/4074b00000000000/40d5e0c287ca29b0/1/1_3,0_1/4018000000000000,405d000000000000,4056000000000000,404e000000000000/// => false
+equals - -53/0/0/4057800d5d0fb78b/40b91f062f0b7a12/2/0_2/3f4aba1f6f16c966,4057800000000000///4000000000000000 -53/0/0/4057800d5d0fb78b/40b91f062f0b7a12/2/0_2/3f4aba1f6f16c966,4057800000000000///4000000000000000 => true
+equals - 8/255bba08cf8c979d/0/0/0/1///// 5/3fe0000000000000/0/4065600000000000/c0a49b798dab681e/0/-16_2,0_2/4036000000000000,404c800000000000,4050400000000000,403b000000000000/// => false
+equals - 0/3fe0000000000000/4028000000000000/4028000000000000/407554a52523c74f/1///// 1/3fe0000000000000/0/0/0/0///// => false
+equals - -53/0/0/0/8000000000000000/0/////4000000000000000 -53/0/0/0/8000000000000000/0/////4000000000000000 => true
+equals - -53/0/0/0/0/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/3/////3fe0000000000000,3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - -4/0/3f0237972520c7ad/3f0237972520c7ad/bf2bb79f0d65e9c3/2///// 3/3f50624dd2f1a9fc/4053180000000000/4053180000000000/4091072cca239ffa/3///// => false
+equals - -53/0/0/0/0/3/////4000000000000000 -53/0/0/0/0/3/////4000000000000000 => true
+equals - -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/0/0/2/////3ff0000000000000,4014000000000000,4024000000000000 => true
+equals - -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/0/0/2/////3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 1/0/4039000000000000/4060200a4c30bee9/40c0ff348d2dc451/1/-15_2,1_2/404f800000000000,4044800000000000,3f33dcd6e1addb9e,3f4f42578acd3a8b/// 1/0/4039000000000000/4060200a4c30bee9/40c0ff348d2dc451/1/-15_2,1_2/404f800000000000,4044800000000000,3f33dcd6e1addb9e,3f4f42578acd3a8b/// => true
+equals - -2/3fe0000000000000/0/40741a03fa25fadb/40b1f6c34441a3e5/2/8_1,2_2,0_2/4020000000000000,4035000000000000,402c000000000000,404c000000000000,3f40b9c714394544/7_3,1_4/0,3f3e2ed18541cc2d,4047800000000000,404d800000000000,4046800000000000,4051880000000000,3ff8000000000000/ -2/3fe0000000000000/0/40741a03fa25fadb/40b1f6c34441a3e5/2/8_1,2_2,0_2/4020000000000000,4035000000000000,402c000000000000,404c000000000000,3f40b9c714394544/7_3,1_4/0,3f3e2ed18541cc2d,4047800000000000,404d800000000000,4046800000000000,4051880000000000,3ff8000000000000/ => true
+equals - 1/0/0/4072d600e475c282/40b8f007f8607875/0/-3_4,1_3,2_2/0,404f000000000000,403ea00000000000,4058000000000000,3f2c8eb8503bec6f,4045e00000000000,4039000000000000,0,0/// 1/0/0/4072d600e475c282/40b8f007f8607875/0/-3_4,1_3,2_2/8000000000000000,404f000000000000,403ea00000000000,4058000000000000,3f2c8eb8503bec6f,4045e00000000000,4039000000000000,0,0/// => false
+equals - -4/3f50624dd2f1a9fc/0/4072280000000000/40c1cbb4fecb1032/1/-3_2,1_3/0,4057800000000000,4049000000000000,4044000000000000,405aa00000000000/// -4/3f50624dd2f1a9fc/0/4072280000000000/40c1cbb4fecb1032/1/-2_1,1_3/4057800000000000,4049000000000000,4044000000000000,405aa00000000000/// => false
+equals - -1/3f847ae147ae147b/404e800000000000/4067540000000000/c09aaab8088c5039/0/-2_4/4031a00000000000,404b800000000000,404a800000000000,0/// -1/3f847ae147ae147b/404e800000000000/4067540000000000/c09aaab8088c5039/0/-2_4/4031a00000000000,404b800000000000,404a800000000000,0/// => true
+equals - -2/3f847ae147ae147b/403e000000000000/403e000000000000/405a2bbec80ab759/2///// -2/3f847ae147ae147b/403e000000000000/403e000000000000/405a2bbec80ab759/2///// => true
+equals - 3/3fe0000000000000/0/0/0/0///// 3/3fe0000000000000/0/0/0/0///// => true
+equals - 2/3f50624dd2f1a9fc/3f21b68272619648/40811f015c677b8d/c0922cd0948c3aa5/1/6_2,1_4,0_4/4055000000000000,3f4158d71c39af74,4049000000000000,4058800000000000,4048000000000000,4052400000000000,4045700000000000,4044000000000000,4034000000000000,4057000000000000/// 2/3f50624dd2f1a9fc/3f21b68272619648/40811f015c677b8d/c0922cd0948c3aa5/1/6_2,1_4,0_4/4055000000000000,3f4158d71c39af74,4049000000000000,4058800000000000,4048000000000000,4052400000000000,4045700000000000,4044000000000000,4034000000000000,4057000000000000/// => true
+equals - 2/3fe0000000000000/3f4dec65539189e5/4073b40c781f18b1/40d02f3c71e3baa5/1/-11_4,2_4,0_3/4040600000000000,3f426870abbee820,0,4050000000000000,3f40937fc1da3410,3f4bd1e920e14658,0,3f13add0dc95905c,3f2243ff1fa9f817,4054c00000000000,405a200000000000/-3_1/403f000000000000/ 8/3fe0000000000000/4028000000000000/4074f402d799414b/40d4427da40fefce/1///-18_4,0_2,1_3/4041200000000000,404c800000000000,404d800000000000,0,3f46bcca0a582a15,4042800000000000,4052c00000000000,4045000000000000,4033000000000000/ => false
+equals - -2/3f50624dd2f1a9fc/3f340947981abd35/407f0003da46a96e/40e0e3727cb9d49b/1/5_3,0_2/0,4044000000000000,0,404d800000000000,4056800000000000/2_4,2_4,1_2/4008000000000000,404f000000000000,3f44cd917f69b32f,403b000000000000,4043000000000000,4044000000000000,4037000000000000,4055000000000000,403a000000000000,4010000000000000/ -2/3fe0000000000000/0/4071800000000000/40d26ed9539dbd64/2/-4_4,1_4/4045000000000000,4047800000000000,4024000000000000,4028000000000000,404b000000000000,4050800000000000,401c000000000000,4045000000000000/// => false
+equals - 1/0/4049000000000000/40792803e5d72b40/40c1efde1901cc9e/1///-2_4,2_4,1_2/0,4052800000000000,4057c00000000000,4033000000000000,0,4039e00000000000,4042000000000000,4059a80000000000,3f4f2eb95a02be6c,0/ 0/255bba08cf8c979d/0/406bc80450ccdf90/c0b42528c8184fb4/0/3_1/3f4143337e41f043/0_1,0_4,0_1/4042800000000000,0,404d000000000000,0,4051d00000000000,404c000000000000/ => false
+equals - 3/3fe0000000000000/0/0/8000000000000000/2///// 2/3fe0000000000000/4053700000000000/4062f00000000000/40b1d7a2c8ba2f5b/1/5_1,2_1,1_1/4045900000000000,0,402a000000000000/-7_1/4031a00000000000/ => false
+equals - 0/0/3f491ad8ce51d0a0/3f491ad8ce51d0a0/3f976bc03837004d/0///// 0/3fe0000000000000/0/4066c40bbdd94480/40c894e31355ea51/1/-19_2,2_4/4000000000000000,0,3f4e493670f06e3e,4052000000000000,3f40ae2ea10e5816,405b080000000000/// => false
+equals - 8/3f847ae147ae147b/4049300000000000/405ed80000000000/40b9c1d9f77c7397/1/-19_2/404a800000000000,4034000000000000/// 8/3f847ae147ae147b/4049300000000000/405ed80000000000/40b9c1d9f77c7397/1/-19_2/404a800000000000,4034000000000000/// => true
+equals - -1/3f50624dd2f1a9fc/0/0/8000000000000000/2///// -1/3f50624dd2f1a9fc/0/0/8000000000000000/2///// => true
+equals - -53/0/0/4050000000000000/40937ab7fd78645e/3/1_1/4050000000000000///3ff0000000000000,4000000000000000,4014000000000000 -53/0/0/4050000000000000/40937ab7fd78645e/3/1_1/4050000000000000///3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 1/3f847ae147ae147b/3f380e6899725d94/407ca20688393176/40b8ec11f66a6e17/1/-8_2,2_1/404e700000000000,4055000000000000,3f4b759b4e23316f/-3_3,1_3/3f3989f3e1ad2946,4034000000000000,404f000000000000,4056c00000000000,405f100000000000,4030000000000000/ -53/0/0/405b4006374d3d06/40680cffe8e41eef/3/0_3,0_1/3f38dd34f41810db,4022000000000000,403a000000000000,4052800000000000///3ff0000000000000,4014000000000000,4024000000000000 => false
+equals - -53/0/0/0/0/2/0_1/0///4000000000000000 -53/0/0/404cd00000000000/40793ae4920377cb/3/0_3/0,4016800000000000,404a000000000000///bff0000000000000,0,3fe0000000000000,4024000000000000 => false
+equals - 8/0/0/4074220000000000/40ca4a960fddc099/0/-4_3,1_2/4058400000000000,4052880000000000,4058000000000000,404b800000000000,0/// 8/255bba08cf8c979d/4052c00000000000/4071de0407d0abeb/40c2c239d0f32216/2/-17_2,1_2/4043f00000000000,4052c00000000000,4058000000000000,3f501f42afaa71ad/// => false
+equals - -53/0/0/0/0/2/////4000000000000000 -53/0/0/0/0/2/////4000000000000000 => true
+equals - 5/0/0/407416038714f43e/c0b1e8c3ec0f3be1/1/3_3,0_3/3f412f7676c7f714,0,0,4052000000000000,4041800000000000,4040000000000000/-13_3/405df00000000000,404f500000000000,3f36126256570a77/ 5/0/0/407416038714f43e/c0b1e8c3ec0f3be1/1/3_3,0_3/3f412f7676c7f714,0,0,4052000000000000,4041800000000000,4040000000000000/-13_3/405df00000000000,404f500000000000,3f36126256570a77/ => true
+equals - -1/3f50624dd2f1a9fc/0/0/0/0///// -1/3f50624dd2f1a9fc/0/0/0/0///// => true
+equals - 8/3fe0000000000000/0/406864072e6a508e/c0a663116f242b7f/1/7_4,2_2/404b900000000000,404c000000000000,403c000000000000,404c000000000000,3f4cb9a94238558c,0/// 8/3fe0000000000000/0/406864072e6a508e/c0a663116f242b7f/1/7_4,2_2/404b900000000000,404c000000000000,403c000000000000,404c000000000000,3f4cb9a94238558c,0/// => true
+equals - 1/3f847ae147ae147b/0/407dd004320a916e/c0a79fc853b70fc4/1/-9_2,0_1/4049000000000000,3f344c31b1a6b4c8,4055800000000000/-19_3,2_2,0_1/4055000000000000,404b800000000000,3f476a3bb29e3e44,4055000000000000,404e000000000000,404d000000000000/ 0/255bba08cf8c979d/404c100000000000/407d8e0000000000/40d254bc069a7b8e/3/-19_1,0_3,1_2/4032000000000000,4055b00000000000,4051000000000000,4058c00000000000,4050400000000000,4054000000000000/// => false
+equals - -53/0/0/0/0/0/////4000000000000000 -53/0/0/0/0/1/////4000000000000000 => true
+reset - -53/0/0/402e000000000000/0/0/0_2/4028000000000000,4008000000000000///3ff0000000000000,4014000000000000,4024000000000000 -53/0/0/402e000000000000/0/0/0_3/4024000000000000,0,4014000000000000///3ff0000000000000,4000000000000000,4014000000000000 => true
+equals - 0/0/0/4018000000000000/0/0/1_1,0_2/3ff0000000000000,4000000000000000,4008000000000000/// 0/0/0/4018000000000000/0/0/1_3/3ff0000000000000,4000000000000000,4008000000000000/// => false
+kahan - 0/3f50624dd2f1a9fc/0/4341c37937e08000/4341c37937e08000/0/3_1/4341c37937e08000/// 0/3f50624dd2f1a9fc/0/3fd3333333333333/3fd3333333333333/0/3_1/3fd3333333333333/// 0/3f50624dd2f1a9fc/0/4341c37937e08000/c341c37937e08000/0/3_1/c341c37937e08000/// 0/3fe0000000000000/0/3ff0000000000000/3ff0000000000000/0/3_1/3ff0000000000000/// => 0/3fe0000000000000/0/4351c37937e08000/3ff0000000000000/0/3_1/3ff0000000000000/// 0/3fe0000000000000/0/3ff4cccccccccccd/3fd3333333333333/0/3_1/3fd3333333333333/// false false

src/promql/src/histogram_eval/bounds.rs

@@ -0,0 +1,167 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Prometheus `exponentialBounds` (`model/histogram/generic.go`): the bucket bounds in [0.5, 1)
+//! of exponential schemas 0 to 8, which `getBoundExponential` scales by a power of two.
+
+#[rustfmt::skip]
+pub(super) const EXPONENTIAL_BOUNDS: [&[f64]; 9] = [
+    &[
+        0.5,
+    ],
+    &[
+        0.5, 0.7071067811865475,
+    ],
+    &[
+        0.5, 0.5946035575013605, 0.7071067811865475, 0.8408964152537144,
+    ],
+    &[
+        0.5, 0.5452538663326288, 0.5946035575013605, 0.6484197773255048,
+        0.7071067811865475, 0.7711054127039704, 0.8408964152537144, 0.9170040432046711,
+    ],
+    &[
+        0.5, 0.5221368912137069, 0.5452538663326288, 0.5693943173783458,
+        0.5946035575013605, 0.620928906036742, 0.6484197773255048, 0.6771277734684463,
+        0.7071067811865475, 0.7384130729697496, 0.7711054127039704, 0.805245165974627,
+        0.8408964152537144, 0.8781260801866495, 0.9170040432046711, 0.9576032806985735,
+    ],
+    &[
+        0.5, 0.5109485743270583, 0.5221368912137069, 0.5335702003384117,
+        0.5452538663326288, 0.5571933712979462, 0.5693943173783458, 0.5818624293887887,
+        0.5946035575013605, 0.6076236799902344, 0.620928906036742, 0.6345254785958666,
+        0.6484197773255048, 0.6626183215798706, 0.6771277734684463, 0.6919549409819159,
+        0.7071067811865475, 0.7225904034885232, 0.7384130729697496, 0.7545822137967112,
+        0.7711054127039704, 0.7879904225539431, 0.805245165974627, 0.8228777390769823,
+        0.8408964152537144, 0.8593096490612387, 0.8781260801866495, 0.8973545375015533,
+        0.9170040432046711, 0.9370838170551498, 0.9576032806985735, 0.9785720620876999,
+    ],
+    &[
+        0.5, 0.5054446430258502, 0.5109485743270583, 0.5165124395106142,
+        0.5221368912137069, 0.5278225891802786, 0.5335702003384117, 0.5393803988785598,
+        0.5452538663326288, 0.5511912916539204, 0.5571933712979462, 0.5632608093041209,
+        0.5693943173783458, 0.5755946149764913, 0.5818624293887887, 0.5881984958251406,
+        0.5946035575013605, 0.6010783657263515, 0.6076236799902344, 0.6142402680534349,
+        0.620928906036742, 0.6276903785123455, 0.6345254785958666, 0.6414350080393891,
+        0.6484197773255048, 0.6554806057623822, 0.6626183215798706, 0.6698337620266515,
+        0.6771277734684463, 0.6845012114872953, 0.6919549409819159, 0.6994898362691555,
+        0.7071067811865475, 0.7148066691959849, 0.7225904034885232, 0.7304588970903234,
+        0.7384130729697496, 0.7464538641456323, 0.7545822137967112, 0.762799075372269,
+        0.7711054127039704, 0.7795022001189185, 0.7879904225539431, 0.7965710756711334,
+        0.805245165974627, 0.8140137109286738, 0.8228777390769823, 0.8318382901633681,
+        0.8408964152537144, 0.8500531768592616, 0.8593096490612387, 0.8686669176368529,
+        0.8781260801866495, 0.8876882462632604, 0.8973545375015533, 0.9071260877501991,
+        0.9170040432046711, 0.9269895625416926, 0.9370838170551498, 0.9472879907934827,
+        0.9576032806985735, 0.9680308967461471, 0.9785720620876999, 0.9892280131939752,
+    ],
+    &[
+        0.5, 0.5027149505564014, 0.5054446430258502, 0.5081891574554764,
+        0.5109485743270583, 0.5137229745593818, 0.5165124395106142, 0.5193170509806894,
+        0.5221368912137069, 0.5249720429003435, 0.5278225891802786, 0.5306886136446309,
+        0.5335702003384117, 0.5364674337629877, 0.5393803988785598, 0.5423091811066545,
+        0.5452538663326288, 0.5482145409081883, 0.5511912916539204, 0.5541842058618393,
+        0.5571933712979462, 0.5602188762048033, 0.5632608093041209, 0.5663192597993595,
+        0.5693943173783458, 0.572486072215902, 0.5755946149764913, 0.5787200368168754,
+        0.5818624293887887, 0.585021884841625, 0.5881984958251406, 0.5913923554921704,
+        0.5946035575013605, 0.5978321960199137, 0.6010783657263515, 0.6043421618132907,
+        0.6076236799902344, 0.6109230164863786, 0.6142402680534349, 0.6175755319684665,
+        0.620928906036742, 0.6243004885946023, 0.6276903785123455, 0.6310986751971253,
+        0.6345254785958666, 0.637970889198196, 0.6414350080393891, 0.6449179367033329,
+        0.6484197773255048, 0.6519406325959679, 0.6554806057623822, 0.659039800633032,
+        0.6626183215798706, 0.6662162735415805, 0.6698337620266515, 0.6734708931164728,
+        0.6771277734684463, 0.6808045103191123, 0.6845012114872953, 0.688217985377265,
+        0.6919549409819159, 0.6957121878859629, 0.6994898362691555, 0.7032879969095076,
+        0.7071067811865475, 0.7109463010845827, 0.7148066691959849, 0.718687998724491,
+        0.7225904034885232, 0.7265139979245261, 0.7304588970903234, 0.7344252166684908,
+        0.7384130729697496, 0.7424225829363761, 0.7464538641456323, 0.7505070348132126,
+        0.7545822137967112, 0.7586795205991071, 0.762799075372269, 0.7669409989204777,
+        0.7711054127039704, 0.7752924388424999, 0.7795022001189185, 0.7837348199827764,
+        0.7879904225539431, 0.7922691326262467, 0.7965710756711334, 0.8008963778413465,
+        0.805245165974627, 0.8096175675974316, 0.8140137109286738, 0.8184337248834821,
+        0.8228777390769823, 0.8273458838280969, 0.8318382901633681, 0.8363550898207981,
+        0.8408964152537144, 0.8454623996346523, 0.8500531768592616, 0.8546688815502312,
+        0.8593096490612387, 0.8639756154809185, 0.8686669176368529, 0.8733836930995842,
+        0.8781260801866495, 0.8828942179666361, 0.8876882462632604, 0.8925083056594671,
+        0.8973545375015533, 0.9022270839033115, 0.9071260877501991, 0.9120516927035263,
+        0.9170040432046711, 0.9219832844793128, 0.9269895625416926, 0.9320230241988943,
+        0.9370838170551498, 0.9421720895161669, 0.9472879907934827, 0.9524316709088368,
+        0.9576032806985735, 0.9628029718180622, 0.9680308967461471, 0.9732872087896164,
+        0.9785720620876999, 0.9838856116165875, 0.9892280131939752, 0.9945994234836328,
+    ],
+    &[
+        0.5, 0.5013556375251013, 0.5027149505564014, 0.5040779490592088,
+        0.5054446430258502, 0.5068150424757447, 0.5081891574554764, 0.509566998038869,
+        0.5109485743270583, 0.5123338964485679, 0.5137229745593818, 0.5151158188430205,
+        0.5165124395106142, 0.5179128468009786, 0.5193170509806894, 0.520725062344158,
+        0.5221368912137069, 0.5235525479396449, 0.5249720429003435, 0.526395386502313,
+        0.5278225891802786, 0.5292536613972564, 0.5306886136446309, 0.5321274564422321,
+        0.5335702003384117, 0.5350168559101208, 0.5364674337629877, 0.5379219445313954,
+        0.5393803988785598, 0.5408428074966075, 0.5423091811066545, 0.5437795304588847,
+        0.5452538663326288, 0.5467321995364429, 0.5482145409081883, 0.549700901315111,
+        0.5511912916539204, 0.5526857228508706, 0.5541842058618393, 0.5556867516724088,
+        0.5571933712979462, 0.5587040757836845, 0.5602188762048033, 0.5617377836665098,
+        0.5632608093041209, 0.564787964283144, 0.5663192597993595, 0.5678547070789026,
+        0.5693943173783458, 0.5709381019847808, 0.572486072215902, 0.5740382394200894,
+        0.5755946149764913, 0.5771552102951081, 0.5787200368168754, 0.5802891060137493,
+        0.5818624293887887, 0.5834400184762408, 0.585021884841625, 0.5866080400818185,
+        0.5881984958251406, 0.5897932637314379, 0.5913923554921704, 0.5929957828304968,
+        0.5946035575013605, 0.5962156912915756, 0.5978321960199137, 0.5994530835371903,
+        0.6010783657263515, 0.6027080545025619, 0.6043421618132907, 0.6059806996384005,
+        0.6076236799902344, 0.6092711149137041, 0.6109230164863786, 0.6125793968185725,
+        0.6142402680534349, 0.6159056423670379, 0.6175755319684665, 0.6192499490999082,
+        0.620928906036742, 0.622612415087629, 0.6243004885946023, 0.6259931389331581,
+        0.6276903785123455, 0.6293922197748583, 0.6310986751971253, 0.6328097572894031,
+        0.6345254785958666, 0.6362458516947014, 0.637970889198196, 0.6397006037528346,
+        0.6414350080393891, 0.6431741147730128, 0.6449179367033329, 0.6466664866145447,
+        0.6484197773255048, 0.6501778216898253, 0.6519406325959679, 0.6537082229673385,
+        0.6554806057623822, 0.6572577939746774, 0.659039800633032, 0.6608266388015788,
+        0.6626183215798706, 0.6644148621029772, 0.6662162735415805, 0.6680225691020727,
+        0.6698337620266515, 0.6716498655934177, 0.6734708931164728, 0.6752968579460171,
+        0.6771277734684463, 0.6789636531064505, 0.6808045103191123, 0.6826503586020058,
+        0.6845012114872953, 0.6863570825438342, 0.688217985377265, 0.690083933630119,
+        0.6919549409819159, 0.6938310211492645, 0.6957121878859629, 0.6975984549830999,
+        0.6994898362691555, 0.7013863456101023, 0.7032879969095076, 0.7051948041086352,
+        0.7071067811865475, 0.7090239421602076, 0.7109463010845827, 0.7128738720527471,
+        0.7148066691959849, 0.7167447066838943, 0.718687998724491, 0.7206365595643126,
+        0.7225904034885232, 0.7245495448210174, 0.7265139979245261, 0.7284837772007218,
+        0.7304588970903234, 0.7324393720732029, 0.7344252166684908, 0.7364164454346837,
+        0.7384130729697496, 0.7404151139112358, 0.7424225829363761, 0.7444354947621984,
+        0.7464538641456323, 0.7484777058836176, 0.7505070348132126, 0.7525418658117031,
+        0.7545822137967112, 0.7566280937263048, 0.7586795205991071, 0.7607365094544071,
+        0.762799075372269, 0.7648672334736434, 0.7669409989204777, 0.7690203869158282,
+        0.7711054127039704, 0.7731960915705107, 0.7752924388424999, 0.7773944698885442,
+        0.7795022001189185, 0.7816156449856788, 0.7837348199827764, 0.7858597406461707,
+        0.7879904225539431, 0.7901268813264122, 0.7922691326262467, 0.7944171921585818,
+        0.7965710756711334, 0.7987307989543135, 0.8008963778413465, 0.8030678282083853,
+        0.805245165974627, 0.8074284071024302, 0.8096175675974316, 0.8118126635086642,
+        0.8140137109286738, 0.8162207259936375, 0.8184337248834821, 0.820652723822003,
+        0.8228777390769823, 0.8251087869603088, 0.8273458838280969, 0.8295890460808079,
+        0.8318382901633681, 0.8340936325652911, 0.8363550898207981, 0.8386226785089391,
+        0.8408964152537144, 0.8431763167241966, 0.8454623996346523, 0.8477546807446661,
+        0.8500531768592616, 0.8523579048290255, 0.8546688815502312, 0.8569861239649629,
+        0.8593096490612387, 0.8616394738731368, 0.8639756154809185, 0.8663180910111553,
+        0.8686669176368529, 0.871022112577578, 0.8733836930995842, 0.8757516765159389,
+        0.8781260801866495, 0.8805069215187917, 0.8828942179666361, 0.8852879870317771,
+        0.8876882462632604, 0.890095013257712, 0.8925083056594671, 0.8949281411607002,
+        0.8973545375015533, 0.8997875124702672, 0.9022270839033115, 0.9046732696855155,
+        0.9071260877501991, 0.909585556079304, 0.9120516927035263, 0.9145245157024483,
+        0.9170040432046711, 0.9194902933879467, 0.9219832844793128, 0.9244830347552253,
+        0.9269895625416926, 0.92950288621441, 0.9320230241988943, 0.9345499949706191,
+        0.9370838170551498, 0.93962450902828, 0.9421720895161669, 0.9447265771954693,
+        0.9472879907934827, 0.9498563490882775, 0.9524316709088368, 0.9550139751351947,
+        0.9576032806985735, 0.9601996065815236, 0.9628029718180622, 0.9654133954938133,
+        0.9680308967461471, 0.9706554947643201, 0.9732872087896164, 0.9759260581154889,
+        0.9785720620876999, 0.9812252401044634, 0.9838856116165875, 0.9865531961276168,
+        0.9892280131939752, 0.9919100824251095, 0.9945994234836328, 0.9972960560854698,
+    ],
+];

src/promql/src/histogram_eval/classic.rs

@@ -0,0 +1,235 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Prometheus `BucketQuantile` and `BucketFraction` over the buckets of a classic histogram at
+//! one point.
+
+/// Relative difference under which neighbouring bucket counts are taken as equal.
+const SMALL_DELTA_TOLERANCE: f64 = 1e-12;
+
+/// Go's `strconv.ParseFloat`, which rejects finite literals out of the f64 range and a signed
+/// NaN, and accepts `_` between digits. Hexadecimal literals are not supported.
+pub(super) fn parse_bound(text: &str) -> Option<f64> {
+    let unsigned = text.trim_start_matches(['+', '-']);
+    if unsigned.len() != text.len() && unsigned.eq_ignore_ascii_case("nan") {
+        return None;
+    }
+    let value: f64 = if text.contains('_') {
+        if !underscores_ok(text) {
+            return None;
+        }
+        text.replace('_', "").parse().ok()?
+    } else {
+        text.parse().ok()?
+    };
+    if value.is_infinite() {
+        let unsigned = text.trim_start_matches(['+', '-']);
+        if !unsigned.eq_ignore_ascii_case("inf") && !unsigned.eq_ignore_ascii_case("infinity") {
+            return None;
+        }
+    }
+    Some(value)
+}
+
+/// Go's `strconv.underscoreOK` for a decimal literal: every `_` sits between two digits.
+fn underscores_ok(text: &str) -> bool {
+    let digits = text.strip_prefix(['+', '-']).unwrap_or(text).as_bytes();
+    digits.iter().enumerate().all(|(i, &byte)| {
+        byte != b'_'
+            || (i > 0
+                && digits[i - 1].is_ascii_digit()
+                && digits.get(i + 1).is_some_and(u8::is_ascii_digit))
+    })
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct Bucket {
+    pub(super) upper_bound: f64,
+    pub(super) count: f64,
+}
+
+/// Prometheus `BucketQuantile` over buckets sorted by upper bound.
+pub(super) fn bucket_quantile(q: f64, buckets: &mut Vec<Bucket>) -> f64 {
+    if q.is_nan() {
+        return f64::NAN;
+    }
+    if q < 0.0 {
+        return f64::NEG_INFINITY;
+    }
+    if q > 1.0 {
+        return f64::INFINITY;
+    }
+    if buckets.last().unwrap().upper_bound != f64::INFINITY {
+        return f64::NAN;
+    }
+    coalesce(buckets);
+    ensure_monotonic(buckets);
+    if buckets.len() < 2 {
+        return f64::NAN;
+    }
+    let observations = buckets.last().unwrap().count;
+    if observations == 0.0 {
+        return f64::NAN;
+    }
+    let mut rank = q * observations;
+    let b = go_search(buckets.len() - 1, |i| buckets[i].count >= rank);
+    if b == buckets.len() - 1 {
+        return buckets[buckets.len() - 2].upper_bound;
+    }
+    if b == 0 && buckets[0].upper_bound <= 0.0 {
+        return buckets[0].upper_bound;
+    }
+    let mut bucket_start = 0.0;
+    let bucket_end = buckets[b].upper_bound;
+    let mut count = buckets[b].count;
+    if b > 0 {
+        bucket_start = buckets[b - 1].upper_bound;
+        count -= buckets[b - 1].count;
+        rank -= buckets[b - 1].count;
+    }
+    bucket_start + (bucket_end - bucket_start) * (rank / count)
+}
+
+/// Prometheus `BucketFraction` over buckets sorted by upper bound.
+pub(super) fn bucket_fraction(lower: f64, upper: f64, buckets: &mut Vec<Bucket>) -> f64 {
+    if buckets.last().unwrap().upper_bound != f64::INFINITY {
+        return f64::NAN;
+    }
+    coalesce(buckets);
+    let count = buckets.last().unwrap().count;
+    if count == 0.0 || lower.is_nan() || upper.is_nan() {
+        return f64::NAN;
+    }
+    if lower >= upper {
+        return 0.0;
+    }
+
+    let (mut rank, mut lower_rank, mut upper_rank) = (0.0, 0.0, 0.0);
+    let (mut lower_set, mut upper_set) = (false, false);
+    let mut lower_bound = if buckets[0].upper_bound <= 0.0 {
+        f64::NEG_INFINITY
+    } else {
+        0.0
+    };
+    for (i, bucket) in buckets.iter().enumerate() {
+        if i > 0 {
+            lower_bound = buckets[i - 1].upper_bound;
+        }
+        let upper_bound = bucket.upper_bound;
+        // An infinite-width bucket contributes nothing to the interpolation.
+        let interpolate = |value: f64| {
+            if lower_bound == f64::NEG_INFINITY {
+                bucket.count
+            } else {
+                rank + (bucket.count - rank) * (value - lower_bound) / (upper_bound - lower_bound)
+            }
+        };
+        if !lower_set && lower_bound >= lower {
+            lower_rank = rank;
+            lower_set = true;
+        }
+        if !upper_set && lower_bound >= upper {
+            upper_rank = rank;
+            upper_set = true;
+        }
+        if lower_set && upper_set {
+            break;
+        }
+        if !lower_set && lower_bound < lower && upper_bound > lower {
+            lower_rank = interpolate(lower);
+            lower_set = true;
+        }
+        if !upper_set && lower_bound < upper && upper_bound > upper {
+            upper_rank = interpolate(upper);
+            upper_set = true;
+        }
+        if lower_set && upper_set {
+            break;
+        }
+        rank = bucket.count;
+    }
+    if !lower_set || lower_rank > count {
+        lower_rank = count;
+    }
+    if !upper_set || upper_rank > count {
+        upper_rank = count;
+    }
+    (upper_rank - lower_rank) / count
+}
+
+/// Merges buckets with the same upper bound.
+fn coalesce(buckets: &mut Vec<Bucket>) {
+    let mut last = buckets[0];
+    let mut i = 0;
+    for j in 1..buckets.len() {
+        let bucket = buckets[j];
+        if bucket.upper_bound == last.upper_bound {
+            last.count += bucket.count;
+        } else {
+            buckets[i] = last;
+            last = bucket;
+            i += 1;
+        }
+    }
+    buckets[i] = last;
+    buckets.truncate(i + 1);
+}
+
+/// Prometheus `ensureMonotonicAndIgnoreSmallDeltas`: counts that differ from the previous one by
+/// a negligible relative amount, or are lower, are raised to it.
+fn ensure_monotonic(buckets: &mut [Bucket]) {
+    let mut prev = buckets[0].count;
+    for bucket in &mut buckets[1..] {
+        let curr = bucket.count;
+        if curr == prev {
+            continue;
+        }
+        if almost_equal(prev, curr, SMALL_DELTA_TOLERANCE) || curr < prev {
+            bucket.count = prev;
+            continue;
+        }
+        prev = curr;
+    }
+}
+
+/// Prometheus `almost.Equal`.
+fn almost_equal(a: f64, b: f64, epsilon: f64) -> bool {
+    if a.is_nan() && b.is_nan() {
+        return true;
+    }
+    if a == b {
+        return true;
+    }
+    let abs_sum = a.abs() + b.abs();
+    let diff = (a - b).abs();
+    if a == 0.0 || b == 0.0 || abs_sum < f64::MIN_POSITIVE {
+        return diff < epsilon * f64::MIN_POSITIVE;
+    }
+    diff / abs_sum.min(f64::MAX) < epsilon
+}
+
+/// Go's `sort.Search`: the smallest index in `[0, n)` where `f` holds, or `n`, found by the same
+/// bisection, so a predicate that is not monotonic (NaN counts) picks the same index.
+fn go_search(n: usize, f: impl Fn(usize) -> bool) -> usize {
+    let (mut i, mut j) = (0, n);
+    while i < j {
+        let h = (i + j) / 2;
+        if !f(h) {
+            i = h + 1;
+        } else {
+            j = h;
+        }
+    }
+    i
+}

src/promql/src/histogram_eval/float_histogram.rs

@@ -0,0 +1,981 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Arithmetic on owned native histograms, following Prometheus `FloatHistogram`
+//! (`model/histogram/float_histogram.go`): `Add`, `KahanAdd`, `Sub`, `Mul`, `Div`, `Compact`,
+//! `CopyToSchema`, `DetectReset` and `Equals`, including zero bucket reconciliation, resolution
+//! reduction and the intersection of mismatched custom bounds.
+//!
+//! Each side is a list of `(bucket index, count)` sorted by index. Go splices span layouts in
+//! place; the bucket indices and the order of additions to each bucket do not depend on the
+//! layout, so the results are the same.
+
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::histogram::{
+    BucketSideView, CounterResetHint, HistogramBatchBuilder, HistogramView,
+};
+
+use crate::functions::kahan_inc;
+use crate::histogram_eval::native::{CUSTOM_BUCKETS_SCHEMA, bound};
+
+type Buckets = Vec<(i32, f64)>;
+
+/// A native histogram with absolute bucket counts.
+#[derive(Debug, Clone)]
+pub(crate) struct FloatHistogram {
+    pub(crate) reset_hint: CounterResetHint,
+    pub(crate) schema: i32,
+    pub(crate) zero_threshold: f64,
+    pub(crate) zero_count: f64,
+    pub(crate) count: f64,
+    pub(crate) sum: f64,
+    pub(crate) positive: Buckets,
+    pub(crate) negative: Buckets,
+    pub(crate) custom_values: Vec<f64>,
+    /// The positive and negative spans of a histogram read from a view, kept until its buckets
+    /// change, because Go `Equals` compares span layouts. Otherwise consecutive indices form one
+    /// span, the layout Go `Compact` produces.
+    layout: Option<[Vec<(i32, i32)>; 2]>,
+}
+
+/// What an addition or subtraction reports besides its result.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub(crate) struct AddOutcome {
+    /// One side was a counter reset and the other was not.
+    pub(crate) counter_reset_collision: bool,
+    /// Custom bounds differed and the result uses their intersection.
+    pub(crate) custom_bounds_reconciled: bool,
+}
+
+impl FloatHistogram {
+    pub(crate) fn try_from_view(view: &HistogramView<'_>) -> Result<Self> {
+        Ok(Self {
+            reset_hint: view.reset_hint,
+            schema: view.schema,
+            zero_threshold: view.zero_threshold,
+            zero_count: view.zero_count,
+            count: view.count,
+            sum: view.sum,
+            positive: side_from_view(view.positive)?,
+            negative: side_from_view(view.negative)?,
+            custom_values: view.custom_values.to_vec(),
+            layout: Some([view.positive, view.negative].map(|side| {
+                side.span_offsets
+                    .iter()
+                    .copied()
+                    .zip(side.span_lengths.iter().copied())
+                    .collect()
+            })),
+        })
+    }
+
+    /// The spans of each side.
+    fn spans(&self) -> [Vec<(i32, i32)>; 2] {
+        self.layout
+            .clone()
+            .unwrap_or_else(|| [&self.positive, &self.negative].map(canonical_spans))
+    }
+
+    /// Appends the histogram to `builder`; consecutive bucket indices share a span.
+    pub(crate) fn push_to(&self, builder: &mut HistogramBatchBuilder) -> Result<u32> {
+        let [positive_spans, negative_spans] = self.spans();
+        let (positive_offsets, positive_lengths): (Vec<_>, Vec<_>) =
+            positive_spans.into_iter().unzip();
+        let (negative_offsets, negative_lengths): (Vec<_>, Vec<_>) =
+            negative_spans.into_iter().unzip();
+        let positive_counts: Vec<f64> = self.positive.iter().map(|&(_, count)| count).collect();
+        let negative_counts: Vec<f64> = self.negative.iter().map(|&(_, count)| count).collect();
+        builder
+            .push(HistogramView {
+                schema: self.schema,
+                zero_threshold: self.zero_threshold,
+                sum: self.sum,
+                count: self.count,
+                zero_count: self.zero_count,
+                reset_hint: self.reset_hint,
+                start_timestamp: None,
+                custom_values: &self.custom_values,
+                positive: BucketSideView {
+                    span_offsets: &positive_offsets,
+                    span_lengths: &positive_lengths,
+                    buckets: &positive_counts,
+                },
+                negative: BucketSideView {
+                    span_offsets: &negative_offsets,
+                    span_lengths: &negative_lengths,
+                    buckets: &negative_counts,
+                },
+            })
+            .map_err(|error| DataFusionError::External(Box::new(error)))
+    }
+
+    /// A histogram with no observations and the bucket layout of `self`, like Go's
+    /// `&FloatHistogram{Schema: h.Schema, CustomValues: h.CustomValues}`.
+    pub(crate) fn empty_like(&self) -> Self {
+        Self {
+            reset_hint: CounterResetHint::Unknown,
+            schema: self.schema,
+            zero_threshold: 0.0,
+            zero_count: 0.0,
+            count: 0.0,
+            sum: 0.0,
+            positive: Vec::new(),
+            negative: Vec::new(),
+            custom_values: self.custom_values.clone(),
+            layout: None,
+        }
+    }
+
+    pub(crate) fn uses_custom_buckets(&self) -> bool {
+        self.schema == CUSTOM_BUCKETS_SCHEMA
+    }
+
+    /// Go `Mul`.
+    pub(crate) fn mul(&mut self, factor: f64) {
+        self.zero_count *= factor;
+        self.count *= factor;
+        self.sum *= factor;
+        for (_, count) in self.positive.iter_mut().chain(self.negative.iter_mut()) {
+            *count *= factor;
+        }
+        if factor < 0.0 {
+            self.reset_hint = CounterResetHint::Gauge;
+        }
+    }
+
+    /// Go `Div`; dividing by zero removes every bucket.
+    pub(crate) fn div(&mut self, scalar: f64) {
+        self.zero_count /= scalar;
+        self.count /= scalar;
+        self.sum /= scalar;
+        if scalar == 0.0 {
+            self.positive.clear();
+            self.negative.clear();
+            self.layout = None;
+            return;
+        }
+        for (_, count) in self.positive.iter_mut().chain(self.negative.iter_mut()) {
+            *count /= scalar;
+        }
+        if scalar < 0.0 {
+            self.reset_hint = CounterResetHint::Gauge;
+        }
+    }
+
+    /// Go `HasOverflow`: whether any count, the sum or a custom bound is infinite.
+    pub(crate) fn has_overflow(&self) -> bool {
+        [self.zero_count, self.count, self.sum]
+            .into_iter()
+            .chain(
+                self.positive
+                    .iter()
+                    .chain(&self.negative)
+                    .map(|&(_, count)| count),
+            )
+            .chain(self.custom_values.iter().copied())
+            .any(f64::is_infinite)
+    }
+
+    /// Go `Compact(0)`: drops empty buckets.
+    pub(crate) fn compact(&mut self) {
+        self.positive.retain(|&(_, count)| count != 0.0);
+        self.negative.retain(|&(_, count)| count != 0.0);
+        self.layout = None;
+    }
+
+    /// Go `CopyToSchema`; `target` must not exceed the schema.
+    pub(crate) fn copy_to_schema(&self, target: i32) -> Result<Self> {
+        if target == self.schema {
+            return Ok(self.clone());
+        }
+        if self.uses_custom_buckets() || target == CUSTOM_BUCKETS_SCHEMA || target > self.schema {
+            return Err(incompatible_schema());
+        }
+        Ok(Self {
+            reset_hint: CounterResetHint::Unknown,
+            schema: target,
+            zero_threshold: self.zero_threshold,
+            zero_count: self.zero_count,
+            count: self.count,
+            sum: self.sum,
+            positive: reduce_resolution(&self.positive, self.schema, target),
+            negative: reduce_resolution(&self.negative, self.schema, target),
+            custom_values: Vec::new(),
+            layout: None,
+        })
+    }
+
+    /// Go `Add`.
+    pub(crate) fn add(&mut self, other: &Self) -> Result<AddOutcome> {
+        self.add_or_sub(other, false)
+    }
+
+    /// Go `Sub`. The `-` operator also sets the hint to gauge, which is left to the caller.
+    pub(crate) fn sub(&mut self, other: &Self) -> Result<AddOutcome> {
+        self.add_or_sub(other, true)
+    }
+
+    fn add_or_sub(&mut self, other: &Self, subtract: bool) -> Result<AddOutcome> {
+        check_schemas(self, other)?;
+        self.layout = None;
+        let mut outcome = AddOutcome {
+            counter_reset_collision: self.adjust_counter_reset(other),
+            custom_bounds_reconciled: false,
+        };
+        let sign = if subtract { -1.0 } else { 1.0 };
+        if !self.uses_custom_buckets() {
+            let (other_zero_count, _) = self.reconcile_zero_buckets(other, None)?;
+            if subtract {
+                self.zero_count -= other_zero_count;
+            } else {
+                self.zero_count += other_zero_count;
+            }
+        }
+        if subtract {
+            self.count -= other.count;
+            self.sum -= other.sum;
+        } else {
+            self.count += other.count;
+            self.sum += other.sum;
+        }
+
+        if self.uses_custom_buckets() {
+            if self.custom_values == other.custom_values {
+                add_buckets(self, &other.positive, sign, None, None, true)?;
+            } else {
+                outcome.custom_bounds_reconciled = true;
+                let bounds = intersect_custom_bounds(&self.custom_values, &other.custom_values);
+                (self.positive, _) = add_custom_buckets_with_mismatches(
+                    subtract,
+                    &self.positive,
+                    &self.custom_values,
+                    &other.positive,
+                    &other.custom_values,
+                    None,
+                    &bounds,
+                );
+                self.custom_values = bounds;
+            }
+            return Ok(outcome);
+        }
+
+        let reduced;
+        let (other_positive, other_negative) = if other.schema < self.schema {
+            self.positive = reduce_resolution(&self.positive, self.schema, other.schema);
+            self.negative = reduce_resolution(&self.negative, self.schema, other.schema);
+            self.schema = other.schema;
+            (&other.positive, &other.negative)
+        } else if other.schema > self.schema {
+            reduced = [&other.positive, &other.negative]
+                .map(|side| reduce_resolution(side, other.schema, self.schema));
+            (&reduced[0], &reduced[1])
+        } else {
+            (&other.positive, &other.negative)
+        };
+        add_buckets(self, other_positive, sign, None, None, true)?;
+        add_buckets(self, other_negative, sign, None, None, false)?;
+        Ok(outcome)
+    }
+
+    /// Go `KahanAdd`: adds `other` with compensation `c`, created when `None`, and returns the
+    /// updated compensation.
+    pub(crate) fn kahan_add(
+        &mut self,
+        other: &Self,
+        c: Option<Self>,
+    ) -> Result<(Self, AddOutcome)> {
+        check_schemas(self, other)?;
+        self.layout = None;
+        let mut outcome = AddOutcome {
+            counter_reset_collision: self.adjust_counter_reset(other),
+            custom_bounds_reconciled: false,
+        };
+        let mut c = c.unwrap_or_else(|| self.new_compensation());
+        if !self.uses_custom_buckets() {
+            let (other_zero_count, other_c_zero_count) =
+                self.reconcile_zero_buckets(other, Some(&mut c))?;
+            (self.zero_count, c.zero_count) =
+                kahan_inc(other_zero_count, self.zero_count, c.zero_count);
+            (self.zero_count, c.zero_count) =
+                kahan_inc(other_c_zero_count, self.zero_count, c.zero_count);
+        }
+        (self.count, c.count) = kahan_inc(other.count, self.count, c.count);
+        (self.sum, c.sum) = kahan_inc(other.sum, self.sum, c.sum);
+
+        if self.uses_custom_buckets() {
+            if self.custom_values == other.custom_values {
+                add_buckets(self, &other.positive, 1.0, Some(&mut c), None, true)?;
+            } else {
+                outcome.custom_bounds_reconciled = true;
+                let bounds = intersect_custom_bounds(&self.custom_values, &other.custom_values);
+                let compensation: Vec<f64> = c.positive.iter().map(|&(_, c)| c).collect();
+                let (positive, positive_c) = add_custom_buckets_with_mismatches(
+                    false,
+                    &self.positive,
+                    &self.custom_values,
+                    &other.positive,
+                    &other.custom_values,
+                    Some(&compensation),
+                    &bounds,
+                );
+                self.positive = positive;
+                c.positive = positive_c;
+                self.custom_values = bounds.clone();
+                c.custom_values = bounds;
+            }
+            return Ok((c, outcome));
+        }
+
+        let mut other_positive = None;
+        let mut other_negative = None;
+        if other.schema < self.schema {
+            (self.positive, c.positive) =
+                kahan_reduce_resolution(&self.positive, &c.positive, self.schema, other.schema);
+            (self.negative, c.negative) =
+                kahan_reduce_resolution(&self.negative, &c.negative, self.schema, other.schema);
+            self.schema = other.schema;
+        } else if other.schema > self.schema {
+            if !other.positive.is_empty() {
+                let zeros = zero_compensation(&other.positive);
+                other_positive = Some(kahan_reduce_resolution(
+                    &other.positive,
+                    &zeros,
+                    other.schema,
+                    self.schema,
+                ));
+            }
+            if !other.negative.is_empty() {
+                let zeros = zero_compensation(&other.negative);
+                other_negative = Some(kahan_reduce_resolution(
+                    &other.negative,
+                    &zeros,
+                    other.schema,
+                    self.schema,
+                ));
+            }
+        }
+        let (positive, positive_c) = match &other_positive {
+            Some((buckets, c)) => (buckets, Some(c)),
+            None => (&other.positive, None),
+        };
+        add_buckets(self, positive, 1.0, Some(&mut c), positive_c, true)?;
+        let (negative, negative_c) = match &other_negative {
+            Some((buckets, c)) => (buckets, Some(c)),
+            None => (&other.negative, None),
+        };
+        add_buckets(self, negative, 1.0, Some(&mut c), negative_c, false)?;
+        c.schema = self.schema;
+        c.zero_threshold = self.zero_threshold;
+        Ok((c, outcome))
+    }
+
+    /// Go `newCompensationHistogram`: the layout of `self` with zero counts.
+    fn new_compensation(&self) -> Self {
+        Self {
+            reset_hint: self.reset_hint,
+            schema: self.schema,
+            zero_threshold: self.zero_threshold,
+            zero_count: 0.0,
+            count: 0.0,
+            sum: 0.0,
+            positive: zero_compensation(&self.positive),
+            negative: if self.uses_custom_buckets() {
+                Vec::new()
+            } else {
+                zero_compensation(&self.negative)
+            },
+            custom_values: self.custom_values.clone(),
+            layout: None,
+        }
+    }
+
+    /// Go `adjustCounterReset`.
+    fn adjust_counter_reset(&mut self, other: &Self) -> bool {
+        use CounterResetHint::{Gauge, Unknown};
+        match (self.reset_hint, other.reset_hint) {
+            (mine, theirs) if mine == theirs => false,
+            (Gauge, _) => false,
+            (_, Gauge) => {
+                self.reset_hint = Gauge;
+                false
+            }
+            (Unknown, _) => false,
+            (_, Unknown) => {
+                self.reset_hint = Unknown;
+                false
+            }
+            _ => {
+                self.reset_hint = Unknown;
+                true
+            }
+        }
+    }
+
+    /// Go `zeroCountForLargerThreshold`: the zero count after widening the zero bucket to at
+    /// least `larger_threshold`, the threshold actually needed so no bucket straddles it, and
+    /// the Kahan compensation of the count.
+    fn zero_count_for_larger_threshold(
+        &self,
+        mut larger_threshold: f64,
+        c: Option<&Self>,
+    ) -> Result<(f64, f64, f64)> {
+        let mut c_zero_count = c.map_or(0.0, |c| c.zero_count);
+        if larger_threshold == self.zero_threshold {
+            return Ok((self.zero_count, larger_threshold, c_zero_count));
+        }
+        'outer: loop {
+            // Go keeps the compensation accumulated by an abandoned pass.
+            let mut zero_count = self.zero_count;
+            for (position, &(idx, count)) in self.positive.iter().enumerate() {
+                let (lower, upper) = (self.bound(idx - 1)?, self.bound(idx)?);
+                if lower >= larger_threshold {
+                    break;
+                }
+                (zero_count, c_zero_count) = kahan_inc(count, zero_count, c_zero_count);
+                if let Some(c) = c {
+                    (zero_count, c_zero_count) =
+                        kahan_inc(c.positive[position].1, zero_count, c_zero_count);
+                }
+                if upper > larger_threshold {
+                    if count != 0.0 {
+                        larger_threshold = upper;
+                    }
+                    break;
+                }
+            }
+            for (position, &(idx, count)) in self.negative.iter().enumerate() {
+                let (lower, upper) = (-self.bound(idx)?, -self.bound(idx - 1)?);
+                if upper <= -larger_threshold {
+                    break;
+                }
+                (zero_count, c_zero_count) = kahan_inc(count, zero_count, c_zero_count);
+                if let Some(c) = c {
+                    (zero_count, c_zero_count) =
+                        kahan_inc(c.negative[position].1, zero_count, c_zero_count);
+                }
+                if lower < -larger_threshold {
+                    if count != 0.0 {
+                        larger_threshold = -lower;
+                        continue 'outer;
+                    }
+                    break;
+                }
+            }
+            return Ok((zero_count, larger_threshold, c_zero_count));
+        }
+    }
+
+    /// Go `trimBucketsInZeroBucket`: empties the buckets inside the zero bucket, then compacts.
+    fn trim_buckets_in_zero_bucket(&mut self, c: Option<&mut Self>) -> Result<()> {
+        let mut trimmed_positive = 0;
+        for &(idx, _) in &self.positive {
+            if self.bound(idx - 1)? >= self.zero_threshold {
+                break;
+            }
+            trimmed_positive += 1;
+        }
+        let mut trimmed_negative = 0;
+        for &(idx, _) in &self.negative {
+            if -self.bound(idx - 1)? <= -self.zero_threshold {
+                break;
+            }
+            trimmed_negative += 1;
+        }
+        for bucket in &mut self.positive[..trimmed_positive] {
+            bucket.1 = 0.0;
+        }
+        for bucket in &mut self.negative[..trimmed_negative] {
+            bucket.1 = 0.0;
+        }
+        match c {
+            Some(c) => {
+                for bucket in &mut c.positive[..trimmed_positive] {
+                    bucket.1 = 0.0;
+                }
+                for bucket in &mut c.negative[..trimmed_negative] {
+                    bucket.1 = 0.0;
+                }
+                compact_with(&mut self.positive, &mut c.positive);
+                compact_with(&mut self.negative, &mut c.negative);
+            }
+            None => self.compact(),
+        }
+        Ok(())
+    }
+
+    /// Go `reconcileZeroBuckets`: widens whichever zero bucket is narrower until both match, and
+    /// returns the zero count of `other` for that threshold with its compensation.
+    fn reconcile_zero_buckets(
+        &mut self,
+        other: &Self,
+        mut c: Option<&mut Self>,
+    ) -> Result<(f64, f64)> {
+        let mut other_zero_count = other.zero_count;
+        let mut other_zero_threshold = other.zero_threshold;
+        let mut other_c_zero_count = 0.0;
+        while other_zero_threshold != self.zero_threshold {
+            if self.zero_threshold > other_zero_threshold {
+                (other_zero_count, other_zero_threshold, other_c_zero_count) =
+                    other.zero_count_for_larger_threshold(self.zero_threshold, None)?;
+            }
+            if other_zero_threshold > self.zero_threshold {
+                let (zero_count, threshold, c_zero_count) =
+                    self.zero_count_for_larger_threshold(other_zero_threshold, c.as_deref())?;
+                self.zero_count = zero_count;
+                self.zero_threshold = threshold;
+                if let Some(c) = c.as_deref_mut() {
+                    c.zero_count = c_zero_count;
+                }
+                self.trim_buckets_in_zero_bucket(c.as_deref_mut())?;
+            }
+        }
+        Ok((other_zero_count, other_c_zero_count))
+    }
+
+    fn bound(&self, idx: i32) -> Result<f64> {
+        bound(idx, self.schema, &self.custom_values)
+    }
+
+    /// Go `DetectReset`: whether `self` cannot follow `previous` without a counter reset.
+    pub(crate) fn detect_reset(&self, previous: &Self) -> Result<bool> {
+        match self.reset_hint {
+            CounterResetHint::CounterReset => return Ok(true),
+            CounterResetHint::NotCounterReset => return Ok(false),
+            _ => {}
+        }
+        if self.count < previous.count {
+            return Ok(true);
+        }
+        if self.uses_custom_buckets() {
+            if !previous.uses_custom_buckets() {
+                return Ok(true);
+            }
+            if self.custom_values != previous.custom_values {
+                return self.detect_reset_with_mismatched_custom_bounds(previous);
+            }
+        }
+        if self.schema > previous.schema || self.zero_threshold < previous.zero_threshold {
+            return Ok(true);
+        }
+        let (previous_zero_count, threshold, _) =
+            previous.zero_count_for_larger_threshold(self.zero_threshold, None)?;
+        if threshold != self.zero_threshold || self.zero_count < previous_zero_count {
+            return Ok(true);
+        }
+        for (current, earlier) in [
+            (&self.positive, &previous.positive),
+            (&self.negative, &previous.negative),
+        ] {
+            let current = iterate(current, self.schema, self.schema, self.zero_threshold)?;
+            let earlier = iterate(earlier, previous.schema, self.schema, self.zero_threshold)?;
+            if side_reset(&current, &earlier) {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    /// Go `detectResetWithMismatchedCustomBounds`: compares the counts rolled up to each bound
+    /// both histograms share.
+    fn detect_reset_with_mismatched_custom_bounds(&self, previous: &Self) -> Result<bool> {
+        let current_bounds = &self.custom_values;
+        let previous_bounds = &previous.custom_values;
+        let mut current = RollUp::new(self);
+        let mut earlier = RollUp::new(previous);
+        let (mut i, mut j) = (0, 0);
+        while i <= current_bounds.len() && j <= previous_bounds.len() {
+            let current_bound = current_bounds.get(i).copied().unwrap_or(f64::INFINITY);
+            let previous_bound = previous_bounds.get(j).copied().unwrap_or(f64::INFINITY);
+            if current_bound == previous_bound {
+                let current_sum = current.sum_up_to(current_bound)?;
+                let previous_sum = earlier.sum_up_to(current_bound)?;
+                if current_sum < previous_sum {
+                    return Ok(true);
+                }
+                i += 1;
+                j += 1;
+            } else if current_bound < previous_bound {
+                i += 1;
+            } else {
+                j += 1;
+            }
+        }
+        Ok(false)
+    }
+
+    /// Go `Equals`: bit equality of counts and of the bucket layout.
+    pub(crate) fn equals(&self, other: &Self) -> bool {
+        let same_side = |a: &Buckets, b: &Buckets| {
+            a.len() == b.len()
+                && a.iter()
+                    .zip(b)
+                    .all(|(a, b)| a.0 == b.0 && a.1.to_bits() == b.1.to_bits())
+        };
+        self.schema == other.schema
+            && self.count.to_bits() == other.count.to_bits()
+            && self.sum.to_bits() == other.sum.to_bits()
+            && (!self.uses_custom_buckets() || self.custom_values == other.custom_values)
+            && self.zero_threshold == other.zero_threshold
+            && self.zero_count.to_bits() == other.zero_count.to_bits()
+            && same_side(&self.negative, &other.negative)
+            && same_side(&self.positive, &other.positive)
+            && {
+                let ([positive, negative], [other_positive, other_negative]) =
+                    (self.spans(), other.spans());
+                spans_match(&negative, &other_negative) && spans_match(&positive, &other_positive)
+            }
+    }
+}
+
+/// The rolling sum of custom buckets up to a bound, as Go's `rollupSumForBound` closure keeps
+/// it across calls.
+struct RollUp<'a> {
+    histogram: &'a FloatHistogram,
+    next: usize,
+    started: bool,
+    has_more: bool,
+}
+
+impl<'a> RollUp<'a> {
+    fn new(histogram: &'a FloatHistogram) -> Self {
+        Self {
+            histogram,
+            next: 0,
+            started: false,
+            has_more: false,
+        }
+    }
+
+    fn sum_up_to(&mut self, bound: f64) -> Result<f64> {
+        if self.started && !self.has_more {
+            return Ok(0.0);
+        }
+        self.started = true;
+        let mut sum = 0.0;
+        while let Some(&(idx, count)) = self.histogram.positive.get(self.next) {
+            if self.histogram.bound(idx)? > bound {
+                self.has_more = true;
+                return Ok(sum);
+            }
+            sum += count;
+            self.next += 1;
+        }
+        self.has_more = false;
+        Ok(sum)
+    }
+}
+
+fn incompatible_schema() -> DataFusionError {
+    DataFusionError::Execution(
+        "cannot apply this operation to histograms with exponential and custom buckets".into(),
+    )
+}
+
+fn check_schemas(a: &FloatHistogram, b: &FloatHistogram) -> Result<()> {
+    if a.uses_custom_buckets() != b.uses_custom_buckets() {
+        return Err(incompatible_schema());
+    }
+    Ok(())
+}
+
+/// Go `floatBucketIterator`: the buckets of `side` merged down to `target`, without the leading
+/// ones whose upper bound is at most `threshold`.
+fn iterate(side: &Buckets, schema: i32, target: i32, threshold: f64) -> Result<Buckets> {
+    let mut out: Buckets = Vec::with_capacity(side.len());
+    for &(idx, count) in side {
+        let target_idx = target_index(idx, schema, target);
+        match out.last_mut() {
+            Some(last) if schema != target && last.0 == target_idx => last.1 += count,
+            _ => out.push((target_idx, count)),
+        }
+    }
+    // Go starts skipping only for a nonzero start value.
+    if target != CUSTOM_BUCKETS_SCHEMA && threshold != 0.0 {
+        let mut skipped = 0;
+        for &(idx, _) in &out {
+            if bound(idx, target, &[])? > threshold {
+                break;
+            }
+            skipped += 1;
+        }
+        out.drain(..skipped);
+    }
+    Ok(out)
+}
+
+/// Go `targetIdx`.
+fn target_index(idx: i32, schema: i32, target: i32) -> i32 {
+    if schema == target {
+        return idx;
+    }
+    ((idx - 1) >> (schema - target)) + 1
+}
+
+/// Go `reduceResolution` without delta encoding.
+fn reduce_resolution(side: &Buckets, schema: i32, target: i32) -> Buckets {
+    let mut out: Buckets = Vec::with_capacity(side.len());
+    for &(idx, count) in side {
+        let target_idx = target_index(idx, schema, target);
+        match out.last_mut() {
+            Some(last) if last.0 == target_idx => last.1 += count,
+            _ => out.push((target_idx, count)),
+        }
+    }
+    out
+}
+
+/// Go `kahanReduceResolution`.
+fn kahan_reduce_resolution(
+    side: &Buckets,
+    compensation: &Buckets,
+    schema: i32,
+    target: i32,
+) -> (Buckets, Buckets) {
+    let mut out: Buckets = Vec::with_capacity(side.len());
+    let mut out_c: Buckets = Vec::with_capacity(side.len());
+    for (&(idx, count), &(_, c)) in side.iter().zip(compensation) {
+        let target_idx = target_index(idx, schema, target);
+        match (out.last_mut(), out_c.last_mut()) {
+            (Some(last), Some(last_c)) if last.0 == target_idx => {
+                (last.1, last_c.1) = kahan_inc(count, last.1, last_c.1);
+                (last.1, last_c.1) = kahan_inc(c, last.1, last_c.1);
+            }
+            _ => {
+                out.push((target_idx, count));
+                out_c.push((target_idx, c));
+            }
+        }
+    }
+    (out, out_c)
+}
+
+fn zero_compensation(side: &Buckets) -> Buckets {
+    side.iter().map(|&(idx, _)| (idx, 0.0)).collect()
+}
+
+/// Go `kahanCompact(0)`: drops the buckets whose count and compensation are both zero.
+fn compact_with(side: &mut Buckets, compensation: &mut Buckets) {
+    let keep: Vec<bool> = side
+        .iter()
+        .zip(compensation.iter())
+        .map(|(&(_, count), &(_, c))| count != 0.0 || c != 0.0)
+        .collect();
+    let mut flags = keep.iter();
+    side.retain(|_| *flags.next().unwrap());
+    let mut flags = keep.iter();
+    compensation.retain(|_| *flags.next().unwrap());
+}
+
+/// Go `addBuckets` and `kahanAddBuckets`: adds `sign * other` to one side of `h`, inserting the
+/// buckets `h` lacks. Leading buckets of `other` inside the zero bucket are skipped.
+fn add_buckets(
+    h: &mut FloatHistogram,
+    other: &Buckets,
+    sign: f64,
+    c: Option<&mut FloatHistogram>,
+    other_c: Option<&Buckets>,
+    positive: bool,
+) -> Result<()> {
+    let exponential = !h.uses_custom_buckets();
+    let threshold = h.zero_threshold;
+    let schema = h.schema;
+    let side = if positive {
+        &mut h.positive
+    } else {
+        &mut h.negative
+    };
+    let mut side_c = c.map(|c| {
+        if positive {
+            &mut c.positive
+        } else {
+            &mut c.negative
+        }
+    });
+    let mut below_threshold = true;
+    let mut position = 0;
+    for (k, &(idx, count)) in other.iter().enumerate() {
+        if below_threshold && exponential && bound(idx, schema, &[])? <= threshold {
+            continue;
+        }
+        below_threshold = false;
+        let value = count * sign;
+        let value_c = other_c.map_or(0.0, |other_c| other_c[k].1) * sign;
+        while position < side.len() && side[position].0 < idx {
+            position += 1;
+        }
+        if position < side.len() && side[position].0 == idx {
+            match side_c.as_deref_mut() {
+                Some(side_c) => {
+                    let (sum, comp) = (&mut side[position].1, &mut side_c[position].1);
+                    (*sum, *comp) = kahan_inc(value, *sum, *comp);
+                    if value_c != 0.0 {
+                        (*sum, *comp) = kahan_inc(value_c, *sum, *comp);
+                    }
+                }
+                None => side[position].1 += value,
+            }
+        } else {
+            side.insert(position, (idx, value));
+            if let Some(side_c) = side_c.as_deref_mut() {
+                side_c.insert(position, (idx, value_c));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Go `intersectCustomBucketBounds`.
+fn intersect_custom_bounds(a: &[f64], b: &[f64]) -> Vec<f64> {
+    let mut out = Vec::new();
+    let (mut i, mut j) = (0, 0);
+    while i < a.len() && j < b.len() {
+        if a[i] == b[j] {
+            out.push(a[i]);
+            i += 1;
+            j += 1;
+        } else if a[i] < b[j] {
+            i += 1;
+        } else {
+            j += 1;
+        }
+    }
+    out
+}
+
+/// Go `addCustomBucketsWithMismatches`: maps both sides onto the intersected bounds, adding
+/// with Kahan summation, and drops buckets left empty. Returns the buckets and their
+/// compensation.
+fn add_custom_buckets_with_mismatches(
+    subtract: bool,
+    a: &Buckets,
+    a_bounds: &[f64],
+    b: &Buckets,
+    b_bounds: &[f64],
+    a_compensation: Option<&[f64]>,
+    bounds: &[f64],
+) -> (Buckets, Buckets) {
+    let mut target = vec![0.0; bounds.len() + 1];
+    let mut target_c = vec![0.0; bounds.len() + 1];
+    let mut map = |side: &Buckets, side_bounds: &[f64], negate: bool, c: Option<&[f64]>| {
+        let mut intersect_idx = 0;
+        for (k, &(idx, value)) in side.iter().enumerate() {
+            let mut target_idx = target.len() - 1;
+            if let Some(&source_bound) = usize::try_from(idx).ok().and_then(|i| side_bounds.get(i))
+            {
+                while intersect_idx < bounds.len() {
+                    if bounds[intersect_idx] >= source_bound {
+                        target_idx = intersect_idx;
+                        break;
+                    }
+                    intersect_idx += 1;
+                }
+            }
+            let (sum, comp) = (&mut target[target_idx], &mut target_c[target_idx]);
+            if negate {
+                (*sum, *comp) = kahan_inc(-value, *sum, *comp);
+            } else {
+                (*sum, *comp) = kahan_inc(value, *sum, *comp);
+                if let Some(c) = c {
+                    (*sum, *comp) = kahan_inc(c[k], *sum, *comp);
+                }
+            }
+        }
+    };
+    map(a, a_bounds, false, a_compensation);
+    map(b, b_bounds, subtract, None);
+    let mut out = Vec::new();
+    let mut out_c = Vec::new();
+    for (i, (&value, &c)) in target.iter().zip(&target_c).enumerate() {
+        if value == 0.0 && c == 0.0 {
+            continue;
+        }
+        out.push((i as i32, value));
+        out_c.push((i as i32, c));
+    }
+    (out, out_c)
+}
+
+/// Go `detectReset` over two sides with matching indices.
+fn side_reset(current: &Buckets, previous: &Buckets) -> bool {
+    let mut current = current.iter().peekable();
+    for &(idx, count) in previous {
+        while current.next_if(|bucket| bucket.0 < idx).is_some() {}
+        match current.peek() {
+            Some(&&(current_idx, current_count)) if current_idx == idx => {
+                if current_count < count {
+                    return true;
+                }
+            }
+            _ if count != 0.0 => return true,
+            _ => {}
+        }
+    }
+    false
+}
+
+fn side_from_view(side: BucketSideView<'_>) -> Result<Buckets> {
+    let invalid = || DataFusionError::Execution("native histogram has an invalid layout".into());
+    if side.span_offsets.len() != side.span_lengths.len() {
+        return Err(invalid());
+    }
+    let mut out = Vec::with_capacity(side.buckets.len());
+    let mut counts = side.buckets.iter();
+    let mut idx = 0i64;
+    for (&offset, &length) in side.span_offsets.iter().zip(side.span_lengths) {
+        if length < 0 {
+            return Err(invalid());
+        }
+        idx += i64::from(offset);
+        for _ in 0..length {
+            let count = *counts.next().ok_or_else(invalid)?;
+            out.push((i32::try_from(idx).map_err(|_| invalid())?, count));
+            idx += 1;
+        }
+    }
+    if counts.next().is_some() {
+        return Err(invalid());
+    }
+    Ok(out)
+}
+
+/// Spans with one span per run of consecutive indices.
+fn canonical_spans(side: &Buckets) -> Vec<(i32, i32)> {
+    let mut spans: Vec<(i32, i32)> = Vec::new();
+    let mut next = None;
+    for &(idx, _) in side {
+        match next {
+            Some(expected) if expected == idx => spans.last_mut().unwrap().1 += 1,
+            _ => spans.push((next.map_or(idx, |expected| idx - expected), 1)),
+        }
+        next = Some(idx + 1);
+    }
+    spans
+}
+
+/// Go `spansMatch`: equal layouts once zero-length spans are folded into the next span.
+fn spans_match(a: &[(i32, i32)], b: &[(i32, i32)]) -> bool {
+    fn fold(spans: &[(i32, i32)]) -> Vec<(i32, i32)> {
+        let mut out = Vec::new();
+        let mut offset = 0;
+        for &(span_offset, length) in spans {
+            offset += span_offset;
+            if length != 0 {
+                out.push((offset, length));
+                offset = 0;
+            }
+        }
+        out
+    }
+    fold(a) == fold(b)
+}

src/promql/src/histogram_eval/native.rs

@@ -0,0 +1,397 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Prometheus `HistogramQuantile`, `HistogramFraction` and the `histogramVariance` estimate over
+//! one native histogram, with the bucket iteration of `model/histogram`.
+
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::histogram::{BucketSideView, HistogramView};
+
+use crate::functions::kahan_inc;
+use crate::histogram_eval::bounds::EXPONENTIAL_BOUNDS;
+
+pub(super) const CUSTOM_BUCKETS_SCHEMA: i32 = -53;
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct NativeBucket {
+    lower: f64,
+    upper: f64,
+    count: f64,
+}
+
+/// The buckets of `h` from the lowest to the highest, or the reverse: negative buckets, the zero
+/// bucket when it has observations, then positive buckets (Go `AllBucketIterator` and
+/// `AllReverseBucketIterator`). Buckets overlapping the zero bucket are clipped to it.
+pub(super) fn all_buckets(
+    h: &HistogramView<'_>,
+    reverse: bool,
+    out: &mut Vec<NativeBucket>,
+) -> Result<()> {
+    out.clear();
+    let (low, high) = if reverse {
+        (h.positive, h.negative)
+    } else {
+        (h.negative, h.positive)
+    };
+    // The first side runs from its highest index down, the second from its lowest index up.
+    side(h, low, reverse, out)?;
+    out.reverse();
+    if h.zero_count > 0.0 {
+        if h.schema == CUSTOM_BUCKETS_SCHEMA {
+            return Err(DataFusionError::Execution(
+                "histograms with custom buckets have no zero bucket".into(),
+            ));
+        }
+        out.push(NativeBucket {
+            lower: -h.zero_threshold,
+            upper: h.zero_threshold,
+            count: h.zero_count,
+        });
+    }
+    side(h, high, !reverse, out)?;
+    for bucket in out.iter_mut() {
+        if bucket.upper < 0.0 && bucket.upper > -h.zero_threshold {
+            bucket.upper = -h.zero_threshold;
+        } else if bucket.lower > 0.0 && bucket.lower < h.zero_threshold {
+            bucket.lower = h.zero_threshold;
+        }
+    }
+    Ok(())
+}
+
+/// Appends the buckets of one side by increasing index.
+fn side(
+    h: &HistogramView<'_>,
+    side: BucketSideView<'_>,
+    positive: bool,
+    out: &mut Vec<NativeBucket>,
+) -> Result<()> {
+    if side.span_offsets.len() != side.span_lengths.len() {
+        return Err(invalid_layout());
+    }
+    let mut counts = side.buckets.iter();
+    let mut index = 0i64;
+    for (&offset, &length) in side.span_offsets.iter().zip(side.span_lengths) {
+        if length < 0 {
+            return Err(invalid_layout());
+        }
+        index += i64::from(offset);
+        for _ in 0..length {
+            let count = *counts.next().ok_or_else(invalid_layout)?;
+            let idx = i32::try_from(index).map_err(|_| invalid_layout())?;
+            out.push(bucket(h, idx, count, positive)?);
+            index += 1;
+        }
+    }
+    if counts.next().is_some() {
+        return Err(invalid_layout());
+    }
+    Ok(())
+}
+
+fn bucket(h: &HistogramView<'_>, idx: i32, count: f64, positive: bool) -> Result<NativeBucket> {
+    let bound = |idx: i32| bound(idx, h.schema, h.custom_values);
+    Ok(if positive {
+        NativeBucket {
+            lower: bound(idx - 1)?,
+            upper: bound(idx)?,
+            count,
+        }
+    } else {
+        NativeBucket {
+            lower: -bound(idx)?,
+            upper: -bound(idx - 1)?,
+            count,
+        }
+    })
+}
+
+/// Go `getBound`.
+pub(super) fn bound(idx: i32, schema: i32, custom_values: &[f64]) -> Result<f64> {
+    if schema == CUSTOM_BUCKETS_SCHEMA {
+        let len = custom_values.len() as i64;
+        return match i64::from(idx) {
+            -1 => Ok(f64::NEG_INFINITY),
+            i if i == len => Ok(f64::INFINITY),
+            i if (0..len).contains(&i) => Ok(custom_values[i as usize]),
+            _ => Err(invalid_layout()),
+        };
+    }
+    if schema < 0 {
+        if schema < -4 {
+            return Err(invalid_layout());
+        }
+        let exp = i64::from(idx) << -schema;
+        if exp == 1024 {
+            // The last bucket of finite values; its computed bound would overflow to +Inf,
+            // which Go reserves for the bucket of infinite observations.
+            return Ok(f64::MAX);
+        }
+        return Ok(ldexp(1.0, exp));
+    }
+    // Go's table entries are not all correctly rounded, and bounds become zero thresholds that
+    // are compared exactly, so the table is used rather than computing `2^(idx / 2^schema)`.
+    let bounds = EXPONENTIAL_BOUNDS
+        .get(schema as usize)
+        .ok_or_else(invalid_layout)?;
+    let frac = bounds[(idx & ((1 << schema) - 1)) as usize];
+    let exp = i64::from(idx >> schema) + 1;
+    if frac == 0.5 && exp == 1025 {
+        return Ok(f64::MAX);
+    }
+    Ok(ldexp(frac, exp))
+}
+
+/// Go `math.Ldexp` for a positive normal `frac`.
+fn ldexp(frac: f64, exp: i64) -> f64 {
+    let bits = frac.to_bits();
+    let exp = exp + ((bits >> 52) & 0x7FF) as i64 - 1023;
+    if exp < -1075 {
+        return 0.0;
+    }
+    if exp > 1023 {
+        return f64::INFINITY;
+    }
+    let (exp, scale) = if exp < -1022 {
+        (exp + 53, 1.0 / (1u64 << 53) as f64)
+    } else {
+        (exp, 1.0)
+    };
+    scale * f64::from_bits((bits & !(0x7FF << 52)) | (((exp + 1023) as u64) << 52))
+}
+
+fn invalid_layout() -> DataFusionError {
+    DataFusionError::Execution("native histogram has an invalid bucket layout".into())
+}
+
+/// Prometheus `HistogramQuantile`.
+pub(super) fn quantile(
+    q: f64,
+    h: &HistogramView<'_>,
+    buckets: &mut Vec<NativeBucket>,
+) -> Result<f64> {
+    if q < 0.0 {
+        return Ok(f64::NEG_INFINITY);
+    }
+    if q > 1.0 {
+        return Ok(f64::INFINITY);
+    }
+    if h.count == 0.0 || q.is_nan() {
+        return Ok(f64::NAN);
+    }
+    let custom = h.schema == CUSTOM_BUCKETS_SCHEMA;
+    let forward = h.sum.is_nan() || q < 0.5;
+    all_buckets(h, !forward, buckets)?;
+    let mut rank = if forward {
+        q * h.count
+    } else {
+        (1.0 - q) * h.count
+    };
+    // Go keeps the last bucket visited, empty or not, and a zero bucket when there is none.
+    let mut bucket = NativeBucket {
+        lower: 0.0,
+        upper: 0.0,
+        count: 0.0,
+    };
+    let mut count = 0.0;
+    let mut visited = 0;
+    for &next in buckets.iter() {
+        visited += 1;
+        bucket = next;
+        if bucket.count == 0.0 {
+            continue;
+        }
+        count += bucket.count;
+        if count >= rank {
+            break;
+        }
+    }
+    if !custom && bucket.lower < 0.0 && bucket.upper > 0.0 {
+        if h.negative.buckets.is_empty() && !h.positive.buckets.is_empty() {
+            bucket.lower = 0.0;
+        } else if h.positive.buckets.is_empty() && !h.negative.buckets.is_empty() {
+            bucket.upper = 0.0;
+        }
+    } else if custom {
+        if bucket.lower == f64::NEG_INFINITY {
+            if bucket.upper <= 0.0 {
+                return Ok(bucket.upper);
+            }
+            bucket.lower = 0.0;
+        } else if bucket.upper == f64::INFINITY {
+            return Ok(bucket.lower);
+        }
+    }
+    if count > h.count {
+        count = h.count;
+    }
+    if count < rank {
+        return Ok(if h.sum.is_nan() {
+            f64::NAN
+        } else {
+            bucket.upper
+        });
+    }
+    if forward {
+        rank -= count - bucket.count;
+    } else {
+        rank = count - rank;
+    }
+    if h.sum.is_nan() {
+        // Prometheus walks the remaining buckets to annotate NaN observations and leaves the last
+        // one in `bucket`, which the interpolation below then uses.
+        for &next in &buckets[visited..] {
+            bucket = next;
+        }
+    }
+    let fraction = rank / bucket.count;
+    if custom || (bucket.lower <= 0.0 && bucket.upper >= 0.0) {
+        return Ok(bucket.lower + (bucket.upper - bucket.lower) * fraction);
+    }
+    let log_lower = bucket.lower.abs().log2();
+    let log_upper = bucket.upper.abs().log2();
+    if bucket.lower > 0.0 {
+        return Ok((log_lower + (log_upper - log_lower) * fraction).exp2());
+    }
+    Ok(-(log_upper + (log_lower - log_upper) * (1.0 - fraction)).exp2())
+}
+
+/// Prometheus `HistogramFraction`.
+pub(super) fn fraction(
+    lower: f64,
+    upper: f64,
+    h: &HistogramView<'_>,
+    buckets: &mut Vec<NativeBucket>,
+) -> Result<f64> {
+    if h.count == 0.0 || lower.is_nan() || upper.is_nan() {
+        return Ok(f64::NAN);
+    }
+    if lower >= upper {
+        return Ok(0.0);
+    }
+    let custom = h.schema == CUSTOM_BUCKETS_SCHEMA;
+    all_buckets(h, false, buckets)?;
+    let (mut count, mut rank, mut lower_rank, mut upper_rank) = (0.0, 0.0, 0.0, 0.0);
+    let (mut lower_set, mut upper_set) = (false, false);
+    let mut visited = 0;
+    for b in buckets.iter() {
+        visited += 1;
+        let mut b = *b;
+        count += b.count;
+        let mut zero_bucket = false;
+        if b.lower <= 0.0 && b.upper >= 0.0 {
+            zero_bucket = true;
+            if h.negative.buckets.is_empty() && !h.positive.buckets.is_empty() {
+                b.lower = 0.0;
+            } else if h.positive.buckets.is_empty() && !h.negative.buckets.is_empty() {
+                b.upper = 0.0;
+            }
+        }
+        let interpolate = |v: f64| {
+            if custom || zero_bucket {
+                if b.lower == f64::NEG_INFINITY {
+                    b.count
+                } else {
+                    rank + b.count * ((v - b.lower) / (b.upper - b.lower))
+                }
+            } else {
+                rank + b.count * fraction_below_exponential(b, v)
+            }
+        };
+        if !lower_set && b.lower >= lower {
+            lower_rank = rank;
+            lower_set = true;
+        }
+        if !upper_set && b.lower >= upper {
+            upper_rank = rank;
+            upper_set = true;
+        }
+        if lower_set && upper_set {
+            break;
+        }
+        if !lower_set && b.lower < lower && b.upper > lower {
+            lower_rank = interpolate(lower);
+            lower_set = true;
+        }
+        if !upper_set && b.lower < upper && b.upper > upper {
+            upper_rank = interpolate(upper);
+            upper_set = true;
+        }
+        if lower_set && upper_set {
+            break;
+        }
+        rank += b.count;
+    }
+    if h.sum.is_nan() {
+        for b in &buckets[visited..] {
+            count += b.count;
+        }
+    } else {
+        count = h.count;
+    }
+    if !lower_set || lower_rank > count {
+        lower_rank = count;
+    }
+    if !upper_set || upper_rank > count {
+        upper_rank = count;
+    }
+    Ok((upper_rank - lower_rank) / h.count)
+}
+
+/// Go `Bucket.FractionBelow` with exponential interpolation.
+fn fraction_below_exponential(b: NativeBucket, v: f64) -> f64 {
+    let log_lower = b.lower.abs().log2();
+    let log_upper = b.upper.abs().log2();
+    let log_v = v.abs().log2();
+    if v > 0.0 {
+        (log_v - log_lower) / (log_upper - log_lower)
+    } else {
+        1.0 - ((log_v - log_upper) / (log_lower - log_upper))
+    }
+}
+
+/// Prometheus `histogramVariance`: bucket midpoints weighted by count around the mean.
+pub(super) fn variance(h: &HistogramView<'_>, buckets: &mut Vec<NativeBucket>) -> Result<f64> {
+    let mean = h.sum / h.count;
+    let custom = h.schema == CUSTOM_BUCKETS_SCHEMA;
+    all_buckets(h, false, buckets)?;
+    let (mut variance, mut compensation) = (0.0, 0.0);
+    for bucket in buckets.iter().filter(|bucket| bucket.count != 0.0) {
+        let value = if custom {
+            (bucket.upper + bucket.lower) / 2.0
+        } else if bucket.lower <= 0.0 && bucket.upper >= 0.0 {
+            0.0
+        } else {
+            let value = (bucket.upper * bucket.lower).sqrt();
+            if bucket.upper < 0.0 { -value } else { value }
+        };
+        let delta = value - mean;
+        (variance, compensation) = kahan_inc(bucket.count * delta * delta, variance, compensation);
+    }
+    Ok((variance + compensation) / h.count)
+}
+
+#[cfg(test)]
+mod tests {
+    /// The last bucket of finite values ends at `f64::MAX`; only the next one, which counts
+    /// infinite observations, ends at +Inf.
+    #[test]
+    fn last_finite_bucket_ends_at_max() {
+        for schema in [-4, 0, 3, 8] {
+            let last = 1024i32 << schema.max(0) >> (-schema).max(0);
+            assert_eq!(super::bound(last, schema, &[]).unwrap(), f64::MAX);
+            assert_eq!(super::bound(last + 1, schema, &[]).unwrap(), f64::INFINITY);
+        }
+    }
+}

src/promql/src/histogram_eval/tests.rs

@@ -0,0 +1,606 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use datafusion::error::DataFusionError;
+use datatypes::series::samples::{FieldSpec, SampleRef, Series, SeriesSchema};
+use datatypes::series::time::TimeAxis;
+
+use super::float_histogram::{AddOutcome, FloatHistogram};
+use super::{
+    HistogramAggregate, HistogramFunction, NativeHistogramFunction, aggregate_histograms,
+    evaluate_histograms, map_native_histogram,
+};
+use crate::grid_series::merge_same_labelset;
+use crate::grid_series::reference::{
+    GoldenCase, Labels, OwnedHistogram, Points, canonical_bits, close, golden_cases, labels_of,
+    metric_of, mixed_series, points_of,
+};
+
+fn schema(case: &GoldenCase) -> Arc<SeriesSchema> {
+    Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(case.grid.clone()),
+    })
+}
+
+fn bits_argument(case: &GoldenCase, index: usize) -> f64 {
+    f64::from_bits(u64::from_str_radix(&case.spec[index], 16).unwrap())
+}
+
+/// Compares a kernel outcome with a fixture outcome; returns whether it was an error.
+fn assert_outcome(
+    case: &GoldenCase,
+    actual: Result<Vec<Series>, DataFusionError>,
+    expected: &Result<BTreeMap<Labels, Points>, String>,
+) -> bool {
+    match (actual, expected) {
+        (Ok(actual), Ok(expected)) => {
+            let actual: BTreeMap<_, _> = actual
+                .iter()
+                .map(|series| (labels_of(&series.metric), points_of(series)))
+                .collect();
+            let expected: BTreeMap<_, _> = expected
+                .iter()
+                .map(|(labels, points)| {
+                    let points = points
+                        .iter()
+                        .map(|(&index, &bits)| (index, canonical_bits(f64::from_bits(bits))))
+                        .collect::<Points>();
+                    (labels.clone(), points)
+                })
+                .collect();
+            let keys = |series: &BTreeMap<Labels, Points>| {
+                series
+                    .iter()
+                    .map(|(labels, points)| (labels.clone(), points.keys().copied().collect()))
+                    .collect::<Vec<(Labels, Vec<usize>)>>()
+            };
+            assert_eq!(keys(&actual), keys(&expected), "case {:?}", case.spec);
+            // promql-compat's tolerance for ill-conditioned evaluation covers the variance.
+            let epsilon = if case.spec[0].contains("stddev") || case.spec[0].contains("stdvar") {
+                1e-6
+            } else {
+                1e-10
+            };
+            for (labels, points) in &actual {
+                for (point, &bits) in points {
+                    let got = f64::from_bits(bits);
+                    let want = f64::from_bits(expected[labels][point]);
+                    assert!(
+                        close(got, want, epsilon),
+                        "case {:?}: {labels:?} at {point}: {got} vs {want}",
+                        case.spec
+                    );
+                }
+            }
+            false
+        }
+        (Err(actual), Err(expected)) => {
+            assert!(actual.to_string().contains(expected), "{actual}");
+            true
+        }
+        (actual, expected) => panic!("case {:?}: {actual:?} is not {expected:?}", case.spec),
+    }
+}
+
+#[test]
+fn classic_histograms_match_prometheus() {
+    let cases = golden_cases(include_str!("classic_cases.txt"));
+    assert_eq!(cases.len(), 300);
+    let mut failed = 0;
+    for case in &cases {
+        let schema = schema(case);
+        // The fixture lists buckets by bound; the kernel must not rely on input order.
+        let input: Vec<_> = case
+            .inputs
+            .iter()
+            .rev()
+            .filter_map(|(labels, points)| mixed_series(&schema, labels, points, &BTreeMap::new()))
+            .collect();
+        let function = match case.spec[0].as_str() {
+            "quantile" => HistogramFunction::Quantile(bits_argument(case, 1)),
+            "fraction" => HistogramFunction::Fraction {
+                lower: bits_argument(case, 1),
+                upper: bits_argument(case, 2),
+            },
+            other => panic!("unknown case {other}"),
+        };
+        let actual = evaluate_histograms(function, &schema, &input);
+        failed += usize::from(assert_outcome(case, actual, &case.outcome));
+    }
+    assert!(failed > 20, "{failed} failed");
+}
+
+#[test]
+fn native_histograms_match_prometheus() {
+    let cases = golden_cases(include_str!("native_cases.txt"));
+    assert_eq!(cases.len(), 661);
+    for case in &cases {
+        let schema = schema(case);
+        let input: Vec<_> = case
+            .inputs
+            .iter()
+            .zip(&case.histograms)
+            .filter_map(|((labels, floats), histograms)| {
+                mixed_series(&schema, labels, floats, histograms)
+            })
+            .collect();
+        let map = |function| -> Result<Vec<Series>, DataFusionError> {
+            let mapped = input
+                .iter()
+                .filter_map(|series| map_native_histogram(function, &schema, series).transpose())
+                .collect::<Result<Vec<_>, _>>()?;
+            merge_same_labelset(&schema, mapped)
+        };
+        let actual = match case.spec[0].as_str() {
+            "histogram_count" => map(NativeHistogramFunction::Count),
+            "histogram_sum" => map(NativeHistogramFunction::Sum),
+            "histogram_avg" => map(NativeHistogramFunction::Avg),
+            "histogram_stddev" => map(NativeHistogramFunction::StdDev),
+            "histogram_stdvar" => map(NativeHistogramFunction::StdVar),
+            "histogram_quantile" => evaluate_histograms(
+                HistogramFunction::Quantile(bits_argument(case, 1)),
+                &schema,
+                &input,
+            ),
+            "histogram_fraction" => evaluate_histograms(
+                HistogramFunction::Fraction {
+                    lower: bits_argument(case, 1),
+                    upper: bits_argument(case, 2),
+                },
+                &schema,
+                &input,
+            ),
+            aggregate => {
+                let (op, by_job) = match aggregate {
+                    "sum" => (HistogramAggregate::Sum, false),
+                    "avg" => (HistogramAggregate::Avg, false),
+                    "sum_by_job" => (HistogramAggregate::Sum, true),
+                    "avg_by_job" => (HistogramAggregate::Avg, true),
+                    other => panic!("unknown case {other}"),
+                };
+                assert_aggregates(case, &schema, &input, op, by_job);
+                continue;
+            }
+        };
+        assert_outcome(case, actual, &case.outcome);
+    }
+}
+
+fn canonical(value: f64) -> u64 {
+    canonical_bits(value)
+}
+
+/// The fields of `h` as bits, NaN as one NaN, with its bucket indices.
+fn fingerprint(h: &FloatHistogram) -> String {
+    let side = |side: &[(i32, f64)]| -> String {
+        side.iter()
+            .map(|&(idx, count)| format!("{idx}:{:x}", canonical(count)))
+            .collect::<Vec<_>>()
+            .join(",")
+    };
+    format!(
+        "{} {:?} zt={:x} zc={:x} count={:x} sum={:x} +[{}] -[{}] custom={:?}",
+        h.schema,
+        h.reset_hint,
+        canonical(h.zero_threshold),
+        canonical(h.zero_count),
+        canonical(h.count),
+        canonical(h.sum),
+        side(&h.positive),
+        side(&h.negative),
+        h.custom_values
+            .iter()
+            .map(|v| canonical(*v))
+            .collect::<Vec<_>>(),
+    )
+}
+
+fn histogram(text: &str) -> FloatHistogram {
+    FloatHistogram::try_from_view(&OwnedHistogram::parse(text).view()).unwrap()
+}
+
+#[test]
+fn histogram_arithmetic_matches_prometheus() {
+    let mut checked = 0;
+    for line in include_str!("arithmetic_cases.txt").lines() {
+        if line.starts_with('#') {
+            continue;
+        }
+        let (inputs, outputs) = line.split_once(" => ").unwrap();
+        let mut inputs = inputs.split(' ');
+        let (op, argument) = (inputs.next().unwrap(), inputs.next().unwrap());
+        let inputs: Vec<FloatHistogram> = inputs.map(histogram).collect();
+        let outputs: Vec<&str> = outputs.split(' ').collect();
+        let flags = |outcome: AddOutcome| {
+            vec![
+                outcome.counter_reset_collision.to_string(),
+                outcome.custom_bounds_reconciled.to_string(),
+            ]
+        };
+        let actual: Result<Vec<String>, _> = match op {
+            "add" | "sub" => {
+                let mut result = inputs[0].clone();
+                let outcome = if op == "add" {
+                    result.add(&inputs[1])
+                } else {
+                    result.sub(&inputs[1])
+                };
+                outcome.map(|outcome| [vec![fingerprint(&result)], flags(outcome)].concat())
+            }
+            "kahan" => {
+                let mut sum = inputs[0].clone();
+                let mut compensation = None;
+                let mut any = AddOutcome::default();
+                let mut result = Ok(());
+                for h in &inputs[1..] {
+                    match sum.kahan_add(h, compensation.take()) {
+                        Ok((c, outcome)) => {
+                            compensation = Some(c);
+                            any.counter_reset_collision |= outcome.counter_reset_collision;
+                            any.custom_bounds_reconciled |= outcome.custom_bounds_reconciled;
+                        }
+                        Err(error) => {
+                            result = Err(error);
+                            break;
+                        }
+                    }
+                }
+                result.map(|_| {
+                    let c = compensation.unwrap();
+                    [vec![fingerprint(&sum), fingerprint(&c)], flags(any)].concat()
+                })
+            }
+            "mul" | "div" => {
+                let factor = f64::from_bits(u64::from_str_radix(argument, 16).unwrap());
+                let mut result = inputs[0].clone();
+                if op == "mul" {
+                    result.mul(factor);
+                } else {
+                    result.div(factor);
+                }
+                Ok(vec![fingerprint(&result)])
+            }
+            "compact" => {
+                let mut result = inputs[0].clone();
+                result.compact();
+                Ok(vec![fingerprint(&result)])
+            }
+            "schema" => inputs[0]
+                .copy_to_schema(argument.parse().unwrap())
+                .map(|result| vec![fingerprint(&result)]),
+            "reset" => inputs[0]
+                .detect_reset(&inputs[1])
+                .map(|reset| vec![reset.to_string()]),
+            "equals" => Ok(vec![inputs[0].equals(&inputs[1]).to_string()]),
+            other => panic!("unknown operation {other}"),
+        };
+        let expected: Vec<String> = match op {
+            "add" | "sub" if outputs[0] != "error" => vec![
+                fingerprint(&histogram(outputs[0])),
+                outputs[1].to_string(),
+                outputs[2].to_string(),
+            ],
+            "kahan" if outputs[0] != "error" => vec![
+                fingerprint(&histogram(outputs[0])),
+                fingerprint(&histogram(outputs[1])),
+                outputs[2].to_string(),
+                outputs[3].to_string(),
+            ],
+            "mul" | "div" | "compact" | "schema" => vec![fingerprint(&histogram(outputs[0]))],
+            _ => outputs.iter().map(|output| output.to_string()).collect(),
+        };
+        match actual {
+            Ok(actual) => assert_eq!(actual, expected, "{line}"),
+            Err(error) => assert_eq!(expected, vec!["error".to_string()], "{line}: {error}"),
+        }
+        checked += 1;
+    }
+    assert_eq!(checked, 723);
+}
+
+/// Groups the input in its order as `sum`/`avg` with or without `by (job)` do, and compares the
+/// aggregated histograms; float-only points belong to the float aggregation.
+fn assert_aggregates(
+    case: &GoldenCase,
+    schema: &Arc<SeriesSchema>,
+    input: &[Series],
+    op: HistogramAggregate,
+    by_job: bool,
+) {
+    assert!(
+        case.outcome.is_ok(),
+        "case {:?}: {:?}",
+        case.spec,
+        case.outcome
+    );
+    let mut groups: BTreeMap<Labels, Vec<Series>> = BTreeMap::new();
+    for series in input {
+        let mut labels = Labels::new();
+        if by_job {
+            labels.insert(
+                "job".to_string(),
+                series.metric.get("job").unwrap().to_string(),
+            );
+        }
+        groups.entry(labels).or_default().push(series.clone());
+    }
+    let mut actual = BTreeMap::new();
+    for (labels, group) in groups {
+        if let Some(series) = aggregate_histograms(op, schema, &group, metric_of(&labels)).unwrap()
+        {
+            actual.insert(labels, histogram_points(&series));
+        }
+    }
+    let expected: BTreeMap<_, _> = case
+        .result_histograms
+        .iter()
+        .map(|(labels, points)| {
+            let points: BTreeMap<_, _> = points
+                .iter()
+                .map(|(&index, text)| (index, fingerprint(&histogram(text))))
+                .collect();
+            (labels.clone(), points)
+        })
+        .collect();
+    assert_eq!(actual, expected, "case {:?}", case.spec);
+}
+
+fn histogram_points(series: &Series) -> BTreeMap<usize, String> {
+    let TimeAxis::Grid(range) = &series.time else {
+        panic!("expected a grid series");
+    };
+    series.fields.as_slice()[0]
+        .iter()
+        .enumerate()
+        .filter_map(|(row, sample)| match sample {
+            SampleRef::Histogram(view) => Some((
+                range.start() + row,
+                fingerprint(&FloatHistogram::try_from_view(&view).unwrap()),
+            )),
+            _ => None,
+        })
+        .collect()
+}
+
+/// `histogram_quantile` drops all metadata labels; the single-histogram functions drop only
+/// `__name__`, as Prometheus does.
+#[test]
+fn histogram_functions_drop_metadata_labels() {
+    let grid = Arc::new(
+        datatypes::series::time::EvalGrid::try_new(
+            datatypes::series::time::GridSpec::try_new(0, 1_000, 1).unwrap(),
+        )
+        .unwrap(),
+    );
+    let schema = Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(grid),
+    });
+    let labels = |extra: &[(&str, &str)]| -> Labels {
+        [
+            ("__name__", "m"),
+            ("__type__", "histogram"),
+            ("__unit__", "seconds"),
+            ("job", "x"),
+        ]
+        .iter()
+        .chain(extra)
+        .map(|(name, value)| (name.to_string(), value.to_string()))
+        .collect()
+    };
+    let one = BTreeMap::from([(0, 1f64.to_bits())]);
+    let buckets = vec![
+        mixed_series(&schema, &labels(&[("le", "1")]), &one, &BTreeMap::new()).unwrap(),
+        mixed_series(&schema, &labels(&[("le", "+Inf")]), &one, &BTreeMap::new()).unwrap(),
+    ];
+    let quantile =
+        evaluate_histograms(HistogramFunction::Quantile(0.5), &schema, &buckets).unwrap();
+    assert_eq!(
+        labels_of(&quantile[0].metric),
+        Labels::from([("job".to_string(), "x".to_string())])
+    );
+
+    let native = mixed_series(
+        &schema,
+        &labels(&[]),
+        &BTreeMap::new(),
+        &BTreeMap::from([(
+            0,
+            "0/0/0/3ff0000000000000/3ff0000000000000/0/0_1/3ff0000000000000///".to_string(),
+        )]),
+    )
+    .unwrap();
+    let count = map_native_histogram(NativeHistogramFunction::Count, &schema, &native)
+        .unwrap()
+        .unwrap();
+    let mut expected = labels(&[]);
+    expected.remove("__name__");
+    assert_eq!(labels_of(&count.metric), expected);
+}
+
+/// Bounds +0 and -0 compare equal and keep input order, so coalescing keeps the first one:
+/// `1 / histogram_quantile(0, sort_desc(h))` over `le` "+Inf", "0", "-0" is +Inf.
+#[test]
+fn classic_bounds_keep_the_first_signed_zero() {
+    let grid = Arc::new(
+        datatypes::series::time::EvalGrid::try_new(
+            datatypes::series::time::GridSpec::try_new(0, 1_000, 1).unwrap(),
+        )
+        .unwrap(),
+    );
+    let schema = Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(grid),
+    });
+    let buckets: Vec<_> = [("+Inf", 3.0), ("0", 2.0), ("-0", 1.0)]
+        .iter()
+        .map(|(le, count)| {
+            let labels = Labels::from([
+                ("__name__".to_string(), "h".to_string()),
+                ("le".to_string(), le.to_string()),
+            ]);
+            let points = BTreeMap::from([(0, f64::to_bits(*count))]);
+            mixed_series(&schema, &labels, &points, &BTreeMap::new()).unwrap()
+        })
+        .collect();
+    let result = evaluate_histograms(HistogramFunction::Quantile(0.0), &schema, &buckets).unwrap();
+    let points = points_of(&result[0]);
+    assert_eq!(1.0 / f64::from_bits(points[&0]), f64::INFINITY);
+}
+
+/// Classic histograms over `le` values in input order, at one point.
+fn classic_result(function: HistogramFunction, buckets: &[(&str, f64)]) -> f64 {
+    let grid = Arc::new(
+        datatypes::series::time::EvalGrid::try_new(
+            datatypes::series::time::GridSpec::try_new(0, 1_000, 1).unwrap(),
+        )
+        .unwrap(),
+    );
+    let schema = Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(grid),
+    });
+    let series: Vec<_> = buckets
+        .iter()
+        .map(|(le, count)| {
+            let labels = Labels::from([
+                ("__name__".to_string(), "h".to_string()),
+                ("le".to_string(), le.to_string()),
+            ]);
+            let points = BTreeMap::from([(0, f64::to_bits(*count))]);
+            mixed_series(&schema, &labels, &points, &BTreeMap::new()).unwrap()
+        })
+        .collect();
+    let result = evaluate_histograms(function, &schema, &series).unwrap();
+    f64::from_bits(points_of(&result[0])[&0])
+}
+
+/// Go's insertion sort cannot move a bucket across a NaN bound, so a NaN bucket stays where it
+/// is and `+Inf` can still end the list. Values are from Prometheus v3.15.0.
+#[test]
+fn nan_bounds_stay_in_place() {
+    let buckets = [("1", 10.0), ("NaN", 20.0), ("inf", 30.0)];
+    let quantile = classic_result(HistogramFunction::Quantile(0.1), &buckets);
+    assert!((quantile - 0.3).abs() < 1e-12, "{quantile}");
+    let fraction = classic_result(
+        HistogramFunction::Fraction {
+            lower: 0.0,
+            upper: 0.5,
+        },
+        &buckets,
+    );
+    assert!((fraction - 1.0 / 6.0).abs() < 1e-12, "{fraction}");
+}
+
+/// `le` parses like Go's `strconv.ParseFloat`: a signed NaN is not a bound, and `_` may separate
+/// digits. Values are from Prometheus v3.15.0.
+#[test]
+fn bounds_parse_like_go() {
+    let signed_nan = [("1", 10.0), ("+nan", 20.0), ("+Inf", 30.0)];
+    for (q, expected) in [(0.1, 0.3), (0.5, 1.0)] {
+        let quantile = classic_result(HistogramFunction::Quantile(q), &signed_nan);
+        assert!((quantile - expected).abs() < 1e-12, "{q}: {quantile}");
+    }
+    let underscore = [("1", 10.0), ("1_000", 20.0), ("+Inf", 30.0)];
+    let quantile = classic_result(HistogramFunction::Quantile(0.5), &underscore);
+    assert!((quantile - 500.5).abs() < 1e-9, "{quantile}");
+    for rejected in ["-nan", "_1", "1__0", "1_", "1_.5", "1e_5"] {
+        assert_eq!(super::classic::parse_bound(rejected), None, "{rejected}");
+    }
+}
+
+/// Widened zero thresholds take Go's table bound, one ulp below `2^0.5` for schema 1 bucket 1,
+/// and later comparisons see that exact value.
+#[test]
+fn widened_zero_threshold_uses_go_bounds() {
+    let go_bound = f64::from_bits(0x3ff6a09e667f3bcc);
+    let mut a = histogram("1/0/0/3ff0000000000000/3ff0000000000000/0/1_1/3ff0000000000000///");
+    let previous = a.clone();
+    a.add(&histogram("1/3ff3333333333333/0/0/0/0/////"))
+        .unwrap();
+    assert_eq!(a.zero_threshold.to_bits(), go_bound.to_bits());
+
+    let current = histogram(&format!(
+        "1/{:x}/3ff0000000000000/3ff0000000000000/0/0/////",
+        go_bound.to_bits()
+    ));
+    assert!(!current.detect_reset(&previous).unwrap());
+}
+
+/// Only mixing exponential and custom buckets ends a group without a result; any other
+/// addition error, such as an invalid layout, fails the aggregation.
+#[test]
+fn aggregation_propagates_errors_other_than_mixed_schemas() {
+    let grid = Arc::new(
+        datatypes::series::time::EvalGrid::try_new(
+            datatypes::series::time::GridSpec::try_new(0, 1_000, 1).unwrap(),
+        )
+        .unwrap(),
+    );
+    let schema = Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(grid),
+    });
+    let group = |texts: [&str; 2]| -> Vec<Series> {
+        texts
+            .iter()
+            .enumerate()
+            .map(|(host, text)| {
+                let labels = Labels::from([("host".to_string(), host.to_string())]);
+                let histograms = BTreeMap::from([(0, text.to_string())]);
+                mixed_series(&schema, &labels, &BTreeMap::new(), &histograms).unwrap()
+            })
+            .collect()
+    };
+    let exponential = "0/0/0/3ff0000000000000/3ff0000000000000/0/1_1/3ff0000000000000///";
+    let custom =
+        "-53/0/0/3ff0000000000000/3ff0000000000000/0/0_1/3ff0000000000000///3ff0000000000000";
+    let invalid =
+        "9/3ff0000000000000/0/3ff0000000000000/3ff0000000000000/0/1_1/3ff0000000000000///";
+    for op in [HistogramAggregate::Sum, HistogramAggregate::Avg] {
+        let mixed = aggregate_histograms(
+            op,
+            &schema,
+            &group([exponential, custom]),
+            metric_of(&Labels::new()),
+        );
+        assert!(mixed.unwrap().is_none());
+        let invalid = aggregate_histograms(
+            op,
+            &schema,
+            &group([invalid, invalid]),
+            metric_of(&Labels::new()),
+        );
+        assert!(invalid.is_err());
+    }
+}

src/promql/src/lib.rs

@@ -15,6 +15,14 @@
 pub mod error;
 pub mod extension_plan;
 pub mod functions;
+mod go_sort;
+pub mod grid_series;
+pub mod histogram_eval;
 pub mod instant_eval;
+pub mod map_label;
+pub mod map_time;
 mod metrics;
 pub mod range_array;
+pub mod range_eval;
+pub mod select;
+pub mod vector_match;

src/promql/src/map_label.rs

@@ -0,0 +1,157 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! `label_replace` and `label_join` over evaluated series, following Prometheus
+//! `evalLabelReplace`, `evalLabelJoin` and `mergeSeriesWithSameLabelset`.
+
+use std::sync::{Arc, LazyLock};
+
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::samples::{Series, SeriesSchema};
+use regex::Regex;
+
+use crate::grid_series::merge_same_labelset;
+
+#[cfg(test)]
+mod tests;
+
+/// `label_replace(v, dst, replacement, src, regex)`: where `regex` matches the whole value of
+/// `src`, `dst` is set to `replacement` with `$1`, `${name}` and `$$` expanded.
+///
+/// `regex` compiles with the `regex` crate, whose dialect differs from Go's RE2 used by
+/// Prometheus: Perl classes (`\d`, `\w`, `\s`, `\b`) are Unicode-aware, `\Q...\E` is rejected,
+/// `(?x)` and repeat counts above 1000 are accepted, and `\<`, `\>` are word boundaries instead
+/// of literal characters.
+pub fn label_replace(
+    schema: &Arc<SeriesSchema>,
+    mut series: Vec<Series>,
+    dst: &str,
+    replacement: &str,
+    src: &str,
+    regex: &str,
+) -> Result<Vec<Series>> {
+    let compiled = Regex::new(&format!("^(?s:{regex})$")).map_err(|_| {
+        DataFusionError::Plan(format!(
+            "invalid regular expression in label_replace(): {regex}"
+        ))
+    })?;
+    if dst.is_empty() {
+        return Err(DataFusionError::Plan(
+            "invalid destination label name in label_replace(): ".into(),
+        ));
+    }
+    let mut value = String::new();
+    for series in &mut series {
+        let Some(captures) = compiled.captures(series.metric.get(src).unwrap_or_default()) else {
+            continue;
+        };
+        value.clear();
+        expand(&compiled, &captures, replacement, &mut value);
+        set_label(&mut series.metric, dst, &value)?;
+    }
+    merge_same_labelset(schema, series)
+}
+
+/// Go `regexp.Expand` reads a group name as Unicode letters (L), decimal digits (Nd) and `_`,
+/// narrower than `char::is_alphanumeric`.
+static GROUP_NAME: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[\p{L}\p{Nd}_]*").unwrap());
+
+/// Go `regexp.Expand`, whose template syntax differs from `regex::Captures::expand`: a numeric
+/// reference with a leading zero, like `$01`, or of more than nine digits is a group name.
+fn expand(regex: &Regex, captures: &regex::Captures<'_>, template: &str, out: &mut String) {
+    let mut rest = template;
+    while let Some(dollar) = rest.find('$') {
+        out.push_str(&rest[..dollar]);
+        rest = &rest[dollar + 1..];
+        if let Some(after) = rest.strip_prefix('$') {
+            out.push('$');
+            rest = after;
+            continue;
+        }
+        let (braced, body) = match rest.strip_prefix('{') {
+            Some(body) => (true, body),
+            None => (false, rest),
+        };
+        let len = GROUP_NAME.find(body).map_or(0, |name| name.end());
+        let name = &body[..len];
+        let closed = !braced || body[len..].starts_with('}');
+        if name.is_empty() || !closed {
+            // Malformed; Go keeps the `$` as text.
+            out.push('$');
+            continue;
+        }
+        rest = &body[len + usize::from(braced)..];
+        let number = (name.bytes().all(|b| b.is_ascii_digit())
+            && !(name.len() > 1 && name.starts_with('0')))
+        .then(|| name.parse::<usize>().ok())
+        .flatten()
+        .filter(|_| name.len() <= 9);
+        let group = match number {
+            Some(number) => captures.get(number),
+            None => regex
+                .capture_names()
+                .position(|group| group == Some(name))
+                .and_then(|index| captures.get(index)),
+        };
+        if let Some(group) = group {
+            out.push_str(group.as_str());
+        }
+    }
+    out.push_str(rest);
+}
+
+/// `label_join(v, dst, separator, src...)`: `dst` is set to the values of `src` joined by
+/// `separator`, an absent label joining as the empty string.
+pub fn label_join(
+    schema: &Arc<SeriesSchema>,
+    mut series: Vec<Series>,
+    dst: &str,
+    separator: &str,
+    src: &[&str],
+) -> Result<Vec<Series>> {
+    if let Some(src) = src.iter().find(|src| src.is_empty()) {
+        return Err(DataFusionError::Plan(format!(
+            "invalid source label name in label_join(): {src}"
+        )));
+    }
+    if dst.is_empty() {
+        return Err(DataFusionError::Plan(
+            "invalid destination label name in label_join(): ".into(),
+        ));
+    }
+    let mut value = String::new();
+    for series in &mut series {
+        value.clear();
+        for (index, src) in src.iter().enumerate() {
+            if index > 0 {
+                value.push_str(separator);
+            }
+            value.push_str(series.metric.get(src).unwrap_or_default());
+        }
+        set_label(&mut series.metric, dst, &value)?;
+    }
+    merge_same_labelset(schema, series)
+}
+
+/// An empty value removes the label, as Prometheus label sets have no empty values.
+fn set_label(metric: &mut MetricName, name: &str, value: &str) -> Result<()> {
+    if value.is_empty() {
+        metric.remove(name);
+        return Ok(());
+    }
+    metric
+        .set(name, Arc::from(value))
+        .map_err(|error| DataFusionError::External(Box::new(error)))
+}

src/promql/src/map_label/tests.rs

@@ -0,0 +1,115 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use datatypes::series::samples::{FieldSpec, SeriesSchema};
+
+use super::{label_join, label_replace};
+use crate::grid_series::reference::{
+    canonical_bits, golden_cases, labels_of, points_of, series_of,
+};
+
+#[test]
+fn label_functions_match_prometheus() {
+    let cases = golden_cases(include_str!("prometheus_cases.txt"));
+    assert_eq!(cases.len(), 200);
+    let (mut matched, mut merged, mut failed) = (0, 0, 0);
+    for case in cases {
+        let schema = Arc::new(SeriesSchema {
+            fields: vec![FieldSpec {
+                name: Arc::from("value"),
+            }]
+            .into(),
+            eval_grid: Some(case.grid.clone()),
+        });
+        let input = case
+            .inputs
+            .iter()
+            .filter_map(|(labels, points)| series_of(&schema, labels, points))
+            .collect::<Vec<_>>();
+        let inputs = input.len();
+        let spec: Vec<&str> = case.spec.iter().map(String::as_str).collect();
+        let actual = match spec[0] {
+            "label_replace" => label_replace(&schema, input, spec[1], spec[2], spec[3], spec[4]),
+            "label_join" => label_join(&schema, input, spec[1], spec[2], &spec[3..]),
+            other => panic!("unknown case {other}"),
+        };
+        match (actual, case.outcome) {
+            (Ok(actual), Ok(expected)) => {
+                if expected.len() < inputs {
+                    merged += 1;
+                }
+                let actual: BTreeMap<_, _> = actual
+                    .iter()
+                    .map(|series| (labels_of(&series.metric), points_of(series)))
+                    .collect();
+                let expected: BTreeMap<_, _> = expected
+                    .into_iter()
+                    .map(|(labels, points)| {
+                        let points = points
+                            .into_iter()
+                            .map(|(index, bits)| (index, canonical_bits(f64::from_bits(bits))))
+                            .collect();
+                        (labels, points)
+                    })
+                    .collect();
+                assert_eq!(actual, expected, "case {spec:?}");
+                matched += 1;
+            }
+            (Err(actual), Err(expected)) => {
+                assert!(
+                    actual.to_string().contains(&expected),
+                    "case {spec:?}: {actual} is not {expected}"
+                );
+                failed += 1;
+            }
+            (actual, expected) => panic!("case {spec:?}: {actual:?} is not {expected:?}"),
+        }
+    }
+    assert!(
+        matched > 150 && merged > 2 && failed > 20,
+        "{matched} matched, {merged} merged, {failed} failed"
+    );
+}
+
+/// Replacement templates expand as Go's `regexp.Expand` does; expectations come from Go.
+#[test]
+fn replacements_expand_like_go() {
+    let regex = regex::Regex::new("^(?s:(?P<word>[a-z]+)-([0-9]+))$").unwrap();
+    let captures = regex.captures("abc-42").unwrap();
+    for (template, expected) in [
+        ("$01", ""),
+        ("${01}", ""),
+        ("$1", "abc"),
+        ("${1}x", "abcx"),
+        ("$1x", ""),
+        ("$$", "$"),
+        ("$", "$"),
+        ("${1", "${1"),
+        ("$word", "abc"),
+        ("${word}!", "abc!"),
+        ("$2$1", "42abc"),
+        ("$-", "$-"),
+        ("$0", "abc-42"),
+        ("$9", ""),
+        ("$1234567890", ""),
+        ("$1²", "abc²"),
+    ] {
+        let mut out = String::new();
+        super::expand(&regex, &captures, template, &mut out);
+        assert_eq!(out, expected, "{template}");
+    }
+}

src/promql/src/map_time.rs

@@ -0,0 +1,212 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! `time()` and the date functions over evaluated series, following Prometheus `funcTime` and
+//! `dateWrapper`.
+
+use std::sync::Arc;
+
+use datafusion::arrow::array::Float64Array;
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::samples::{
+    DenseSamplesRef, SampleRef, Samples, Series, SeriesFields, SeriesSchema,
+};
+use datatypes::series::time::{GridRange, TimeAxis};
+
+use crate::grid_series::{GridSeriesBuilder, METADATA_LABELS, external};
+
+#[cfg(test)]
+mod tests;
+
+/// A PromQL date function: `minute(v)`, `year()` and so on.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DateFunction {
+    DayOfMonth,
+    DayOfWeek,
+    DayOfYear,
+    DaysInMonth,
+    Hour,
+    Minute,
+    Month,
+    Year,
+}
+
+/// `time()`: the evaluation time in seconds at every point of the schema's grid, unlabelled.
+pub fn time(schema: &SeriesSchema) -> Result<Series> {
+    eval_time_series(schema, |ms| ms as f64 / 1000.0)
+}
+
+/// A date function without argument, which reads the evaluation time: one unlabelled series
+/// over the whole grid.
+pub fn date_of_eval_time(function: DateFunction, schema: &SeriesSchema) -> Result<Series> {
+    // Prometheus truncates the timestamp to whole seconds towards zero.
+    eval_time_series(schema, |ms| function.apply(ms / 1000))
+}
+
+/// A date function over `series`: each float value is read as Unix seconds and replaced by the
+/// date component, and the metric name is dropped. Missing values stay missing; histogram
+/// samples are dropped, so the result is `None` when no float remains.
+///
+/// Series that share a label set once their names are dropped must then go through
+/// [`merge_same_labelset`](crate::grid_series::merge_same_labelset).
+pub fn map_date(
+    function: DateFunction,
+    schema: &Arc<SeriesSchema>,
+    series: &Series,
+) -> Result<Option<Series>> {
+    let TimeAxis::Grid(range) = &series.time else {
+        return Err(DataFusionError::Execution(
+            "date functions require an evaluated series".into(),
+        ));
+    };
+    let mut metric = series.metric.clone();
+    metric.remove_all(&METADATA_LABELS);
+    let map = |seconds: f64| function.apply(go_int64(seconds));
+
+    let all_floats = series.fields.iter().all(|samples| {
+        samples
+            .segments()
+            .iter()
+            .all(|segment| matches!(segment.dense(), Some(DenseSamplesRef::Float(_))))
+    });
+    if all_floats {
+        let fields = series
+            .fields
+            .iter()
+            .map(|samples| {
+                let segments = samples
+                    .segments()
+                    .iter()
+                    .map(|segment| {
+                        let Some(DenseSamplesRef::Float(floats)) = segment.dense() else {
+                            unreachable!("checked above");
+                        };
+                        Samples::from_float(floats.unary(map))
+                    })
+                    .collect();
+                Samples::try_from_chunks(segments).map_err(external)
+            })
+            .collect::<Result<Vec<_>>>()?;
+        let fields = SeriesFields::try_from_vec(fields).map_err(external)?;
+        return Series::try_new(schema, metric, series.time.clone(), fields)
+            .map(Some)
+            .map_err(external);
+    }
+
+    // Histogram samples leave holes, which may move the ends of the series.
+    let mut builder = GridSeriesBuilder::try_new(schema.clone())?;
+    let mut values = vec![None; series.fields.len()];
+    for row in 0..range.len() {
+        for (value, samples) in values.iter_mut().zip(series.fields.iter()) {
+            *value = match samples.sample(row) {
+                SampleRef::Float(seconds) => Some(map(seconds)),
+                SampleRef::Missing | SampleRef::Histogram(_) => None,
+            };
+        }
+        builder.push(range.start() + row, &values)?;
+    }
+    builder.finish(metric)
+}
+
+fn eval_time_series(schema: &SeriesSchema, value: impl Fn(i64) -> f64) -> Result<Series> {
+    let grid = schema.eval_grid.clone().ok_or_else(|| {
+        DataFusionError::Execution("time functions require an evaluation grid".into())
+    })?;
+    let values: Float64Array = grid.timestamps().iter().map(|&ms| value(ms)).collect();
+    let range = GridRange::try_new(grid.clone(), 0, values.len()).map_err(external)?;
+    let fields = vec![Samples::from_float(values); schema.fields.len()];
+    Series::try_new(
+        schema,
+        MetricName::try_new(None, Vec::new()).map_err(external)?,
+        TimeAxis::Grid(range),
+        SeriesFields::try_from_vec(fields).map_err(external)?,
+    )
+    .map_err(external)
+}
+
+/// Go's `int64(f)` on amd64: NaN and values out of range become `i64::MIN`.
+fn go_int64(value: f64) -> i64 {
+    if (-9_223_372_036_854_775_808.0..9_223_372_036_854_775_808.0).contains(&value) {
+        value as i64
+    } else {
+        i64::MIN
+    }
+}
+
+const SECONDS_PER_DAY: u64 = 86_400;
+const MARCH_THRU_DECEMBER: u32 = 306;
+const ABSOLUTE_YEARS: u64 = 292_277_022_400;
+/// Go's `unixToInternal + internalToAbsolute`.
+const UNIX_TO_ABSOLUTE: i64 = (1969 * 365 + 1969 / 4 - 1969 / 100 + 1969 / 400) * 86_400
+    + (ABSOLUTE_YEARS as i64 / 400 * 146_097 + MARCH_THRU_DECEMBER as i64) * 86_400;
+
+impl DateFunction {
+    /// The component of Unix second `seconds` in UTC, computed the way Go's `time` package does,
+    /// including its wrapping arithmetic for instants out of its range.
+    fn apply(self, seconds: i64) -> f64 {
+        let abs = seconds.wrapping_add(UNIX_TO_ABSOLUTE) as u64;
+        let days = abs / SECONDS_PER_DAY;
+        let value = match self {
+            Self::Hour => (abs % SECONDS_PER_DAY / 3600) as i64,
+            Self::Minute => (abs % 3600 / 60) as i64,
+            Self::DayOfWeek => ((days + 3) % 7) as i64,
+            Self::Year => civil(days).year,
+            Self::Month => civil(days).month as i64,
+            Self::DayOfMonth => civil(days).day as i64,
+            Self::DayOfYear => civil(days).year_day,
+            Self::DaysInMonth => {
+                let Civil { year, month, .. } = civil(days);
+                let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+                match month {
+                    2 if leap => 29,
+                    2 => 28,
+                    4 | 6 | 9 | 11 => 30,
+                    _ => 31,
+                }
+            }
+        };
+        value as f64
+    }
+}
+
+struct Civil {
+    year: i64,
+    month: u32,
+    day: u32,
+    year_day: i64,
+}
+
+/// Go's `absDays.split`, `date` and `yearYday`: days since March 1 of year `-ABSOLUTE_YEARS`.
+fn civil(days: u64) -> Civil {
+    let d = days.wrapping_mul(4).wrapping_add(3);
+    let century = d / 146_097;
+    let cd = (d % 146_097) as u32 | 3;
+    let product = 2_939_745u64 * cd as u64;
+    let cyear = (product >> 32) as u32;
+    let ayday = product as u32 / 2_939_745 / 4;
+
+    let m = 2141 * ayday + 197_913;
+    let jan_feb = u32::from(ayday >= MARCH_THRU_DECEMBER);
+    let leap = cyear.is_multiple_of(4) && (cyear != 0 || century.is_multiple_of(4));
+    Civil {
+        year: century.wrapping_mul(100).wrapping_sub(ABSOLUTE_YEARS) as i64
+            + cyear as i64
+            + jan_feb as i64,
+        month: (m >> 16) - jan_feb * 12,
+        day: 1 + (m & 0xFFFF) / 2141,
+        year_day: ayday as i64 + (1 + 31 + 28) + i64::from(leap && jan_feb == 0)
+            - 365 * jan_feb as i64,
+    }
+}

src/promql/src/map_time/tests.rs

@@ -0,0 +1,175 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use datafusion::arrow::array::{Float64Array, UInt32Array};
+use datatypes::series::histogram::{
+    BucketSideView, CounterResetHint, HistogramBatchBuilder, HistogramView,
+};
+use datatypes::series::samples::{FieldSpec, Samples, Series, SeriesFields, SeriesSchema};
+use datatypes::series::time::{EvalGrid, GridRange, GridSpec, TimeAxis};
+
+use super::{DateFunction, date_of_eval_time, map_date, time};
+use crate::grid_series::merge_same_labelset;
+use crate::grid_series::reference::{
+    Labels, canonical_bits, golden_cases, labels_of, metric_of, points_of, series_of,
+};
+
+fn schema(grid: Arc<EvalGrid>) -> Arc<SeriesSchema> {
+    Arc::new(SeriesSchema {
+        fields: vec![FieldSpec {
+            name: Arc::from("value"),
+        }]
+        .into(),
+        eval_grid: Some(grid),
+    })
+}
+
+fn function(name: &str) -> DateFunction {
+    match name {
+        "day_of_month" => DateFunction::DayOfMonth,
+        "day_of_week" => DateFunction::DayOfWeek,
+        "day_of_year" => DateFunction::DayOfYear,
+        "days_in_month" => DateFunction::DaysInMonth,
+        "hour" => DateFunction::Hour,
+        "minute" => DateFunction::Minute,
+        "month" => DateFunction::Month,
+        "year" => DateFunction::Year,
+        other => panic!("unknown date function {other}"),
+    }
+}
+
+#[test]
+fn time_functions_match_prometheus() {
+    let cases = golden_cases(include_str!("prometheus_cases.txt"));
+    assert_eq!(cases.len(), 200);
+    for case in cases {
+        let schema = schema(case.grid.clone());
+        let actual: Vec<Series> = match (case.spec[0].as_str(), case.spec[1].as_str()) {
+            ("eval_time", "time") => vec![time(&schema).unwrap()],
+            ("eval_time", name) => vec![date_of_eval_time(function(name), &schema).unwrap()],
+            ("date", name) => case
+                .inputs
+                .iter()
+                .filter_map(|(labels, points)| series_of(&schema, labels, points))
+                .filter_map(|series| map_date(function(name), &schema, &series).unwrap())
+                .collect::<Vec<_>>(),
+            (kind, _) => panic!("unknown case {kind}"),
+        };
+        // Dropping `__name__` can give two series one label set.
+        let actual = match (merge_same_labelset(&schema, actual), case.outcome) {
+            (Ok(actual), Ok(expected)) => (actual, expected),
+            (Err(actual), Err(expected)) => {
+                assert!(actual.to_string().contains(&expected), "{actual}");
+                continue;
+            }
+            (actual, expected) => panic!("case {:?}: {actual:?} is not {expected:?}", case.spec),
+        };
+        let (actual, expected) = actual;
+        let actual: BTreeMap<_, _> = actual
+            .iter()
+            .map(|series| (labels_of(&series.metric), points_of(series)))
+            .collect();
+        let expected: BTreeMap<_, _> = expected
+            .into_iter()
+            .map(|(labels, points)| {
+                let points = points
+                    .into_iter()
+                    .map(|(index, bits)| (index, canonical_bits(f64::from_bits(bits))))
+                    .collect();
+                (labels, points)
+            })
+            .collect();
+        assert_eq!(actual, expected, "case {:?}", case.spec);
+    }
+}
+
+/// Histogram samples are dropped and the series trimmed to the remaining floats; chunked floats
+/// are mapped chunk by chunk.
+#[test]
+fn map_date_drops_histograms_and_maps_chunks() {
+    let grid = Arc::new(EvalGrid::try_new(GridSpec::try_new(0, 1000, 4).unwrap()).unwrap());
+    let schema = schema(grid.clone());
+    let range = GridRange::try_new(grid, 1, 3).unwrap();
+    let series = |fields: Samples| {
+        Series::try_new(
+            &schema,
+            metric_of(
+                &[
+                    ("__name__", "m"),
+                    ("__type__", "gauge"),
+                    ("__unit__", "seconds"),
+                    ("host", "a"),
+                ]
+                .map(|(n, v)| (n.into(), v.into()))
+                .into(),
+            ),
+            TimeAxis::Grid(range.clone()),
+            SeriesFields::one(fields),
+        )
+        .unwrap()
+    };
+    let floats = |values: &[f64]| Samples::from_float(Float64Array::from(values.to_vec()));
+
+    let empty = BucketSideView {
+        span_offsets: &[],
+        span_lengths: &[],
+        buckets: &[],
+    };
+    let mut histograms = HistogramBatchBuilder::new();
+    histograms
+        .push(HistogramView {
+            schema: 0,
+            zero_threshold: 0.0,
+            sum: 1.0,
+            count: 1.0,
+            zero_count: 1.0,
+            reset_hint: CounterResetHint::Unknown,
+            start_timestamp: None,
+            custom_values: &[],
+            positive: empty,
+            negative: empty,
+        })
+        .unwrap();
+    let histogram =
+        Samples::try_from_histogram(UInt32Array::from(vec![0]), histograms.finish().unwrap())
+            .unwrap();
+    let mixed = Samples::try_from_chunks(vec![histogram, floats(&[3600.0, 7200.0])]).unwrap();
+    let hours = map_date(DateFunction::Hour, &schema, &series(mixed))
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        points_of(&hours),
+        BTreeMap::from([(2, 1f64.to_bits()), (3, 2f64.to_bits())])
+    );
+    assert_eq!(
+        labels_of(&hours.metric),
+        Labels::from([("host".into(), "a".into())])
+    );
+
+    let chunked = Samples::try_from_chunks(vec![floats(&[60.0]), floats(&[120.0, 180.0])]).unwrap();
+    let minutes = map_date(DateFunction::Minute, &schema, &series(chunked))
+        .unwrap()
+        .unwrap();
+    assert_eq!(
+        points_of(&minutes),
+        BTreeMap::from([
+            (1, 1f64.to_bits()),
+            (2, 2f64.to_bits()),
+            (3, 3f64.to_bits())
+        ])
+    );
+}

src/promql/src/range_eval.rs

@@ -0,0 +1,601 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Range-vector window evaluation of raw series onto an evaluation grid.
+
+use std::sync::Arc;
+
+use common_query::prometheus::is_prometheus_stale_nan;
+use datafusion::arrow::buffer::Buffer;
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::raw::RawSeriesChunk;
+use datatypes::series::samples::{SampleRef, Series, SeriesFields, SeriesSchema};
+use datatypes::series::time::{EvalGrid, GridSpec, TimeAxis};
+
+use crate::grid_series::{GridSample, GridSeriesBuilder, METADATA_LABELS};
+use crate::histogram_eval::float_histogram::FloatHistogram;
+
+mod function;
+mod histogram;
+#[cfg(test)]
+mod tests;
+
+pub use function::RangeFunction;
+
+/// The samples a range selector reads at evaluation time `T`: source timestamps in
+/// `(E - range_ms, E]`, where `E` is `T - offset_ms`, or `anchor_ms - offset_ms` with `@`.
+#[derive(Clone, Copy, Debug)]
+pub struct RangeWindow {
+    /// Positive window length in milliseconds.
+    pub range_ms: i64,
+    /// Selector offset in milliseconds; positive reads earlier samples.
+    pub offset_ms: i64,
+    /// The resolved `@` timestamp in milliseconds, with `start()` and `end()` already replaced
+    /// by the statement's start and end.
+    pub anchor_ms: Option<i64>,
+}
+
+/// The valid samples of one field inside one window, in source order.
+pub(crate) struct FloatWindow<'a> {
+    /// Sample timestamps shifted by the offset onto the evaluation timeline; non-empty.
+    pub timestamps: &'a [i64],
+    pub values: &'a [f64],
+    /// Evaluation timestamp `T`. `timestamps` lie in `(T - range_ms, T]`, except for an
+    /// `@`-anchored `predict_linear`, which evaluates the first point's window at every `T`.
+    pub eval_ts: i64,
+    pub range_ms: i64,
+}
+
+/// Computes one window result; `None` means the window has no result.
+pub(crate) type WindowKernel = Box<dyn FnMut(FloatWindow<'_>) -> Option<f64> + Send>;
+
+/// Evaluates range windows over raw series, one series at a time.
+///
+/// Each series is pushed as its chunks in order and completes on the chunk marked `is_last`.
+/// Fields are evaluated independently over their own valid samples; a row holding a stale
+/// marker in any field is dropped, as the ordinary range selector does. Only the samples later
+/// windows can still use are retained. Native histogram samples need a [`RangeFunction`]; an
+/// evaluator built from a bare kernel rejects them.
+pub struct RangeEvaluator {
+    grid: Arc<EvalGrid>,
+    /// The window with `offset_ms` replaced by the offset samples are shifted by.
+    window: RangeWindow,
+    replay: Replay,
+    kernel: WindowKernel,
+    function: Option<RangeFunction>,
+    output_schema: Arc<SeriesSchema>,
+    output: GridSeriesBuilder,
+    /// The grid of evaluated input series, such as the inner result of a subquery; `None` for
+    /// raw input.
+    input_grid: Option<GridSpec>,
+    series: Option<SeriesState>,
+    fields: Vec<FieldSamples>,
+    row: Vec<Option<GridSample>>,
+    drops_metric_name: bool,
+    /// Raised by the first non-empty window, where Prometheus validates function arguments.
+    window_error: Option<String>,
+}
+
+struct SeriesState {
+    /// `None` for evaluated input, which arrives as one complete series.
+    primary_key: Option<Buffer>,
+    metric: MetricName,
+    last_ts: i64,
+    /// Next grid index to evaluate.
+    cursor: usize,
+}
+
+/// How the windows of an `@`-anchored selector map to the grid.
+///
+/// Like Prometheus, an anchored selector is read once, as the window of the first grid point
+/// with the offset rewritten to `start - (anchor - offset)`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Replay {
+    /// Not anchored: every grid point reads its own window.
+    PerPoint,
+    /// The first point's result is reported at every point (step-invariant functions).
+    Once,
+    /// The first point's window is evaluated at every point (`predict_linear`).
+    EveryPoint,
+}
+
+#[derive(Default)]
+struct FieldSamples {
+    timestamps: Vec<i64>,
+    values: Vec<f64>,
+    /// Samples before `head` are behind every remaining window.
+    head: usize,
+    /// Native histogram samples, kept apart from the floats as Prometheus does.
+    histograms: Vec<(i64, FloatHistogram)>,
+    histogram_head: usize,
+}
+
+impl RangeEvaluator {
+    /// Creates an evaluator of `function` for the series of `input` onto `grid`.
+    pub fn try_new(
+        input: &SeriesSchema,
+        grid: Arc<EvalGrid>,
+        window: RangeWindow,
+        function: RangeFunction,
+    ) -> Result<Self> {
+        let mut window_error = None;
+        if let RangeFunction::DoubleExponentialSmoothing { smoothing, trend } = function {
+            // Prometheus rejects factors outside (0, 1); NaN passes its check.
+            window_error = [("smoothing", smoothing), ("trend", trend)]
+                .into_iter()
+                .find(|(_, factor)| *factor <= 0.0 || *factor >= 1.0)
+                .map(|(name, factor)| {
+                    format!("invalid {name} factor. Expected: 0 < factor < 1, got: {factor}")
+                });
+        }
+        let fold_offset = fold_offset(grid.spec(), window)?;
+        let step_invariant = !matches!(function, RangeFunction::PredictLinear(_));
+        if !step_invariant {
+            let spec = grid.spec();
+            let last =
+                i128::from(spec.start_ms) + i128::from(spec.step_ms) * (i128::from(spec.len) - 1);
+            for eval_ts in [i128::from(spec.start_ms), last] {
+                if i64::try_from(eval_ts + i128::from(fold_offset)).is_err() {
+                    return Err(DataFusionError::Plan(format!(
+                        "predict_linear evaluation time {eval_ts} overflows with offset {fold_offset} ms"
+                    )));
+                }
+            }
+        }
+        let mut evaluator = Self::with_kernel(
+            input,
+            grid,
+            window,
+            function.kernel(fold_offset),
+            step_invariant,
+        )?;
+        evaluator.drops_metric_name = function.drops_metric_name();
+        evaluator.window_error = window_error;
+        evaluator.function = Some(function);
+        Ok(evaluator)
+    }
+
+    /// `step_invariant` tells whether an `@`-anchored result holds at every grid point.
+    pub(crate) fn with_kernel(
+        input: &SeriesSchema,
+        grid: Arc<EvalGrid>,
+        mut window: RangeWindow,
+        kernel: WindowKernel,
+        step_invariant: bool,
+    ) -> Result<Self> {
+        if window.range_ms <= 0 {
+            return Err(DataFusionError::Plan(format!(
+                "range must be positive, got {} ms",
+                window.range_ms
+            )));
+        }
+        let replay = match (window.anchor_ms, step_invariant) {
+            (None, _) => Replay::PerPoint,
+            (Some(_), true) => Replay::Once,
+            (Some(_), false) => Replay::EveryPoint,
+        };
+        window.offset_ms = fold_offset(grid.spec(), window)?;
+        let output_schema = Arc::new(SeriesSchema {
+            fields: input.fields.clone(),
+            eval_grid: Some(grid.clone()),
+        });
+        Ok(Self {
+            grid,
+            window,
+            replay,
+            kernel,
+            function: None,
+            output: GridSeriesBuilder::try_new(output_schema.clone())?,
+            input_grid: input.eval_grid.as_ref().map(|grid| grid.spec()),
+            output_schema,
+            series: None,
+            fields: input
+                .fields
+                .iter()
+                .map(|_| FieldSamples::default())
+                .collect(),
+            row: Vec::with_capacity(input.fields.len()),
+            drops_metric_name: false,
+            window_error: None,
+        })
+    }
+
+    /// Schema of the evaluated series: the input fields on the evaluation grid.
+    pub fn output_schema(&self) -> &Arc<SeriesSchema> {
+        &self.output_schema
+    }
+
+    /// Consumes the next chunk of the current series, or starts a new series.
+    ///
+    /// Returns the evaluated series on its `is_last` chunk, or `None` there when no grid point
+    /// has a result.
+    ///
+    /// The evaluator must not be reused after an error.
+    pub fn push(&mut self, chunk: &RawSeriesChunk) -> Result<Option<Series>> {
+        if self.input_grid.is_some() {
+            return Err(DataFusionError::Execution(
+                "raw series chunk pushed to an evaluator of evaluated series".into(),
+            ));
+        }
+        self.check_chunk(chunk)?;
+        self.ingest(chunk.time.as_buffer(), &chunk.fields, true)?;
+        let last_ts = chunk.time.as_buffer()[chunk.time.len() - 1];
+        if !chunk.is_last {
+            // Later chunks only hold samples after `last_ts`.
+            self.evaluate(Some(
+                i128::from(last_ts) + i128::from(self.window.offset_ms),
+            ))?;
+            return Ok(None);
+        }
+        self.finish_series()
+    }
+
+    /// Evaluates one complete evaluated series, such as the inner result of a subquery: the
+    /// value at each grid point is a sample at that time. Stale markers are kept as values,
+    /// since the input is computed.
+    pub fn push_series(&mut self, series: &Series) -> Result<Option<Series>> {
+        let TimeAxis::Grid(range) = &series.time else {
+            return Err(DataFusionError::Execution(
+                "evaluated range input must be a grid series".into(),
+            ));
+        };
+        if self.input_grid != Some(range.grid().spec())
+            || series.fields.len() != self.fields.len()
+            || series.fields.iter().any(|field| field.len() != range.len())
+        {
+            return Err(DataFusionError::Execution(
+                "evaluated series does not match the input schema".into(),
+            ));
+        }
+        if self.series.is_some() {
+            return Err(DataFusionError::Execution(
+                "evaluated series pushed inside a raw series".into(),
+            ));
+        }
+        self.series = Some(SeriesState {
+            primary_key: None,
+            metric: series.metric.clone(),
+            last_ts: 0,
+            cursor: 0,
+        });
+        self.ingest(&range.timestamps(), &series.fields, false)?;
+        self.finish_series()
+    }
+
+    fn finish_series(&mut self) -> Result<Option<Series>> {
+        self.evaluate(None)?;
+        let mut state = self.series.take().expect("set by the caller");
+        if self.drops_metric_name {
+            state.metric.remove_all(&METADATA_LABELS);
+        }
+        self.output.finish(state.metric)
+    }
+
+    /// Checks that the input did not end inside a series.
+    pub fn finish(self) -> Result<()> {
+        if self.series.is_some() {
+            return Err(DataFusionError::Execution(
+                "raw series input ended before the last chunk of a series".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    fn check_chunk(&mut self, chunk: &RawSeriesChunk) -> Result<()> {
+        let primary_key = Some(chunk.primary_key.as_slice());
+        let time = chunk.time.as_buffer();
+        if time.is_empty()
+            || chunk.fields.len() != self.fields.len()
+            || chunk.fields.iter().any(|field| field.len() != time.len())
+        {
+            return Err(DataFusionError::Execution(format!(
+                "raw series chunk with {} timestamps and {} fields does not match {} schema fields",
+                time.len(),
+                chunk.fields.len(),
+                self.fields.len()
+            )));
+        }
+        match &mut self.series {
+            None => {
+                let metric = chunk.metric.clone().ok_or_else(|| {
+                    DataFusionError::Execution(
+                        "range evaluation requires materialized series labels".into(),
+                    )
+                })?;
+                self.series = Some(SeriesState {
+                    primary_key: Some(chunk.primary_key.clone()),
+                    metric,
+                    last_ts: time[time.len() - 1],
+                    cursor: 0,
+                });
+            }
+            Some(state) => {
+                if state.primary_key.as_ref().map(|key| key.as_slice()) != primary_key
+                    || chunk.metric.as_ref() != Some(&state.metric)
+                {
+                    return Err(DataFusionError::Execution(
+                        "raw series identity changed before its last chunk".into(),
+                    ));
+                }
+                if time[0] <= state.last_ts {
+                    return Err(DataFusionError::Execution(format!(
+                        "raw series timestamps are not increasing across chunks: {} after {}",
+                        time[0], state.last_ts
+                    )));
+                }
+                state.last_ts = time[time.len() - 1];
+            }
+        }
+        Ok(())
+    }
+
+    /// Retains the samples of `fields` at `timestamps`; with `drop_stale`, a row holding a stale
+    /// marker in any field is dropped.
+    fn ingest(
+        &mut self,
+        timestamps: &[i64],
+        fields: &SeriesFields,
+        drop_stale: bool,
+    ) -> Result<()> {
+        let mut samples: Vec<_> = fields.iter().map(|field| field.iter()).collect();
+        let mut row = Vec::with_capacity(samples.len());
+        for &timestamp in timestamps {
+            row.clear();
+            let mut stale = false;
+            for field in &mut samples {
+                let sample = field.next().expect("field length checked by the caller");
+                match &sample {
+                    SampleRef::Missing => {}
+                    SampleRef::Float(value) => stale |= is_prometheus_stale_nan(*value),
+                    SampleRef::Histogram(view) => {
+                        if self.function.is_none() {
+                            return Err(DataFusionError::NotImplemented(
+                                "range evaluation of histogram samples".into(),
+                            ));
+                        }
+                        stale |= is_prometheus_stale_nan(view.sum);
+                    }
+                }
+                row.push(sample);
+            }
+            if stale && drop_stale {
+                continue;
+            }
+            // Like RangeManipulate, any kept sample whose shifted time leaves i64 fails the series.
+            let shifted = timestamp
+                .checked_add(self.window.offset_ms)
+                .ok_or_else(|| {
+                    DataFusionError::Execution(format!(
+                        "sample timestamp {timestamp} overflows with offset {} ms",
+                        self.window.offset_ms
+                    ))
+                })?;
+            for (field, sample) in self.fields.iter_mut().zip(&row) {
+                match sample {
+                    SampleRef::Missing => {}
+                    SampleRef::Float(value) => {
+                        field.timestamps.push(shifted);
+                        field.values.push(*value);
+                    }
+                    SampleRef::Histogram(view) => field
+                        .histograms
+                        .push((shifted, FloatHistogram::try_from_view(view)?)),
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Evaluates grid points up to `ready` on the evaluation timeline, or all remaining points
+    /// when `ready` is `None`.
+    fn evaluate(&mut self, ready: Option<i128>) -> Result<()> {
+        let points_read = self.points_read();
+        let state = self.series.as_mut().expect("checked by check_chunk");
+        let spec = self.grid.spec();
+        let grid = self.grid.timestamps();
+        let range = i128::from(self.window.range_ms);
+        while state.cursor < points_read {
+            let eval_ts = grid[state.cursor];
+            let lower = i128::from(eval_ts) - range;
+            let mut earliest = None;
+            // Later windows start no earlier, so samples behind this one go even when the point
+            // itself is not ready yet.
+            for field in &mut self.fields {
+                field.head += field.timestamps[field.head..]
+                    .partition_point(|&timestamp| i128::from(timestamp) <= lower);
+                field.histogram_head += field.histograms[field.histogram_head..]
+                    .partition_point(|(timestamp, _)| i128::from(*timestamp) <= lower);
+                let first_histogram = field.histograms.get(field.histogram_head);
+                for &timestamp in field
+                    .timestamps
+                    .get(field.head)
+                    .into_iter()
+                    .chain(first_histogram.map(|(timestamp, _)| timestamp))
+                {
+                    earliest = Some(earliest.map_or(timestamp, |min: i64| min.min(timestamp)));
+                }
+            }
+            if ready.is_some_and(|ready| i128::from(eval_ts) > ready) {
+                break;
+            }
+            // No retained sample: either the series is done or the next one is not here yet.
+            let Some(earliest) = earliest else {
+                break;
+            };
+            if earliest > eval_ts {
+                // Skip the points whose windows end before the earliest sample.
+                let step = i128::from(spec.step_ms);
+                let steps = (i128::from(earliest) - i128::from(spec.start_ms) + step - 1) / step;
+                state.cursor = usize::try_from(steps).map_or(grid.len(), |i| i.min(grid.len()));
+                continue;
+            }
+            if let Some(error) = &self.window_error {
+                return Err(DataFusionError::Execution(error.clone()));
+            }
+
+            let mut evaluator = RowEvaluator {
+                fields: &self.fields,
+                kernel: &mut self.kernel,
+                function: self.function,
+                range_ms: self.window.range_ms,
+                offset_ms: self.window.offset_ms,
+            };
+            match self.replay {
+                Replay::PerPoint => {
+                    evaluator.evaluate(eval_ts, eval_ts, &mut self.row)?;
+                    self.output.push_samples(state.cursor, &self.row)?;
+                }
+                Replay::Once => {
+                    evaluator.evaluate(eval_ts, eval_ts, &mut self.row)?;
+                    for index in 0..grid.len() {
+                        self.output.push_samples(index, &self.row)?;
+                    }
+                }
+                Replay::EveryPoint => {
+                    for (index, &point) in grid.iter().enumerate() {
+                        evaluator.evaluate(eval_ts, point, &mut self.row)?;
+                        self.output.push_samples(index, &self.row)?;
+                    }
+                }
+            }
+            state.cursor += 1;
+        }
+        for field in &mut self.fields {
+            // After the last window, samples are still ingested so that the overflow and
+            // histogram checks do not depend on how the series is chunked, but none are kept.
+            // An anchored selector can skip past the one point it reads.
+            if state.cursor >= points_read {
+                field.head = field.timestamps.len();
+                field.histogram_head = field.histograms.len();
+            }
+            field.timestamps.drain(..field.head);
+            field.values.drain(..field.head);
+            field.head = 0;
+            field.histograms.drain(..field.histogram_head);
+            field.histogram_head = 0;
+        }
+        Ok(())
+    }
+
+    /// The number of leading grid points whose windows are read; an anchored selector reads
+    /// only the first.
+    fn points_read(&self) -> usize {
+        match self.replay {
+            Replay::PerPoint => self.grid.timestamps().len(),
+            Replay::Once | Replay::EveryPoint => 1,
+        }
+    }
+}
+
+/// Computes the result of every field's window at one grid point.
+struct RowEvaluator<'a> {
+    fields: &'a [FieldSamples],
+    kernel: &'a mut WindowKernel,
+    function: Option<RangeFunction>,
+    range_ms: i64,
+    offset_ms: i64,
+}
+
+impl RowEvaluator<'_> {
+    /// Fills `row` with the result over each field's window ending at `window_end`, evaluated
+    /// at `eval_ts`.
+    fn evaluate(
+        &mut self,
+        window_end: i64,
+        eval_ts: i64,
+        row: &mut Vec<Option<GridSample>>,
+    ) -> Result<()> {
+        row.clear();
+        for field in self.fields {
+            let timestamps = &field.timestamps[field.head..];
+            let len = timestamps.partition_point(|&timestamp| timestamp <= window_end);
+            let floats = (len > 0).then(|| FloatWindow {
+                timestamps: &timestamps[..len],
+                values: &field.values[field.head..field.head + len],
+                eval_ts,
+                range_ms: self.range_ms,
+            });
+            let histograms = &field.histograms[field.histogram_head..];
+            let histograms = &histograms
+                [..histograms.partition_point(|(timestamp, _)| *timestamp <= window_end)];
+            row.push(match self.function {
+                Some(function) if !histograms.is_empty() => histogram::evaluate(
+                    function,
+                    floats,
+                    histograms,
+                    eval_ts,
+                    self.range_ms,
+                    self.offset_ms,
+                    &mut *self.kernel,
+                )?,
+                _ => floats.and_then(|window| (self.kernel)(window).map(GridSample::Float)),
+            });
+        }
+        Ok(())
+    }
+}
+
+/// The offset samples are shifted by: the selector offset, or for `@` the offset that places
+/// the anchored window at the first grid point.
+fn fold_offset(grid: GridSpec, window: RangeWindow) -> Result<i64> {
+    let Some(anchor) = window.anchor_ms else {
+        return Ok(window.offset_ms);
+    };
+    anchor
+        .checked_sub(window.offset_ms)
+        .and_then(|end| grid.start_ms.checked_sub(end))
+        .ok_or_else(|| {
+            DataFusionError::Plan(format!(
+                "@ {anchor} ms with offset {} ms is out of range",
+                window.offset_ms
+            ))
+        })
+}
+
+/// The inner grid of a subquery read by `window` from the outer grid `outer`: the multiples of
+/// `step_ms` after `start - F - range` up to the last window end, where `F` is the fold offset
+/// of `window`; with `@`, the only window end is `start - F`. `None` when no multiple falls in
+/// the windows.
+pub fn subquery_grid(
+    outer: GridSpec,
+    window: RangeWindow,
+    step_ms: i64,
+) -> Result<Option<GridSpec>> {
+    if step_ms <= 0 {
+        return Err(DataFusionError::Plan(format!(
+            "subquery step must be positive, got {step_ms} ms"
+        )));
+    }
+    let fold_offset = i128::from(fold_offset(outer, window)?);
+    let step = i128::from(step_ms);
+    let start = i128::from(outer.start_ms);
+    let last_eval = match window.anchor_ms {
+        Some(_) => start,
+        None => start + i128::from(outer.step_ms) * (i128::from(outer.len) - 1),
+    };
+    let first = ((start - fold_offset - i128::from(window.range_ms)).div_euclid(step) + 1) * step;
+    let last = last_eval - fold_offset;
+    if first > last {
+        return Ok(None);
+    }
+    let len = u64::try_from((last - first) / step + 1)
+        .map_err(|_| DataFusionError::Plan("subquery grid has too many points".into()))?;
+    let first = i64::try_from(first).map_err(|_| {
+        DataFusionError::Plan(format!("subquery grid start {first} ms is out of range"))
+    })?;
+    GridSpec::try_new(first, step_ms, len)
+        .map(Some)
+        .map_err(|error| DataFusionError::External(Box::new(error)))
+}

src/promql/src/range_eval/absent_over_time_cases.txt

@@ -0,0 +1,804 @@
+# Generated by promql-compat cmd/narthex-golden-vector built for amd64 (Prometheus v3.15.0
+# engine, seed 1, 120 cases per kind). Each case lists its operation, the grid, the
+# input series and either the result series or the error. Points are `grid index:hex bits`.
+case absent_over_time 45000 host!="h2"
+grid 100000 10000 6
+series __name__=a,host=h2,job=y ; 1:7ff8000000000001
+series __name__=a,host=h1,job=y,zone=z1 ; 5:c079dc0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 1:4078980000000000 2:406ad00000000000 3:c08b8e0000000000
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 10000 host!="h1",job="x",zone!=""
+grid 100000 10000 7
+series __name__=a,host=h1,job=x ; 0:c089930000000000 1:c073020000000000
+series __name__=a,host=h2,job=y ; 5:408e5f0000000000 6:4072120000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 4:c0666c0000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 7
+series __name__=a,host=h1,job=y,zone=z1 ; 1:c08a7d0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 4:4048800000000000 5:c08e730000000000
+series __name__=a,host=h1,job=x ; 0:c075140000000000 1:0
+series __name__=a,host=h2,job=x ;
+end
+case absent_over_time 25000 job="x",zone!="z1"
+grid 100000 10000 3
+series __name__=a,host=h2,job=x,zone=z1 ; 0:408bfc0000000000
+series __name__=a,host=h2,job=y ; 0:407a580000000000 1:408bc60000000000
+series __name__=a,host=h2,job=x ; 0:c054900000000000 1:408c2a0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 0:c065100000000000 2:c0886b0000000000
+end
+case absent_over_time 10000 zone=""
+grid 100000 10000 7
+series __name__=a,host=h1,job=x ; 0:408eea0000000000
+series __name__=a,host=h2,job=y ; 3:4081650000000000 4:c06a840000000000 5:fff0000000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 3:4082530000000000 5:c08dde0000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 3:c05b700000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 6:406b7c0000000000
+series __name__=a,host=h1,job=y ; 0:c080630000000000 1:7ff8000000000001 2:4081c00000000000
+result - ; 6:3ff0000000000000
+end
+case absent_over_time 45000 host!="h2",job!="x",zone!=""
+grid 100000 10000 3
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h1,job=y,zone=z1 ; 1:c04bb00000000000 2:406b000000000000
+series __name__=a,host=h2,job=x ;
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 5000 job="x"
+grid 100000 10000 5
+series __name__=a,host=h2,job=y,zone=z1 ; 2:4081b90000000000
+series __name__=a,host=h2,job=x ;
+series __name__=a,host=h1,job=x ; 3:c0872d0000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 25000 host="h1"
+grid 100000 10000 8
+series __name__=a,host=h1,job=x ; 1:c084510000000000 2:40804d0000000000 3:c0890d0000000000 4:c085580000000000
+series __name__=a,host=h1,job=y ; 3:4088fe0000000000 4:4056f00000000000 5:4082b60000000000 6:7e37e43c8800759c
+series __name__=a,host=h2,job=y ; 7:407c440000000000
+result host=h1 ; 0:3ff0000000000000
+end
+case absent_over_time 45000 job="y"
+grid 100000 10000 4
+series __name__=a,host=h2,job=y ; 1:c087120000000000 2:7e37e43c8800759c 3:40775e0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 0:405e900000000000 1:0 2:c043a00000000000 3:c08e610000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 0:c066140000000000 1:c0867d0000000000 2:4055a80000000000 3:408c220000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 0:c042b00000000000 1:c073ee0000000000
+series __name__=a,host=h2,job=x ; 3:4071920000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 10
+series __name__=a,host=h1,job=x ; 3:c0797e0000000000 4:0
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 10
+series __name__=a,host=h1,job=x ;
+series __name__=a,host=h2,job=x,zone=z1 ;
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h2,job=x ; 8:405b980000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 1:4089390000000000 2:c065600000000000 3:c085950000000000 4:40710e0000000000
+result - ; 0:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 10000 job!="y",zone!="z1"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 2:7e37e43c8800759c
+result - ; 0:3ff0000000000000 1:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 45000 job!="y",zone="z1"
+grid 100000 10000 11
+series __name__=a,host=h1,job=x ; 7:7ff8000000000001
+result zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 25000 host="h2",job!="x",zone!="z1"
+grid 100000 10000 6
+series __name__=a,host=h1,job=y ; 2:4068940000000000 3:405a580000000000
+series __name__=a,host=h2,job=x ;
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 10000 zone=""
+grid 100000 10000 9
+series __name__=a,host=h2,job=y ; 5:4080eb0000000000 6:4032c00000000000
+series __name__=a,host=h2,job=x ;
+series __name__=a,host=h1,job=x ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 25000 job="y"
+grid 100000 10000 3
+series __name__=a,host=h1,job=x,zone=z1 ; 2:7ff0000000000000
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 25000 job!="y"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 5:fff0000000000000
+series __name__=a,host=h1,job=y ; 1:408af90000000000 2:c079da0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 5:c030a00000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 2:c071fc0000000000 3:c071d20000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 10000 host="h2",job!="x"
+grid 100000 10000 4
+series __name__=a,host=h1,job=x,zone=z1 ; 1:c088900000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 5000 zone!=""
+grid 100000 10000 9
+series __name__=a,host=h2,job=x,zone=z1 ; 5:7ff8000000000001 7:c072680000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 6:c074000000000000 7:c08d6b0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 8:c08efb0000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 1:4082330000000000
+result - ; 0:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 45000 job!="y",zone!="z1"
+grid 100000 10000 9
+series __name__=a,host=h1,job=x ; 5:408eaf0000000000 6:7ff0000000000000 7:4052180000000000
+series __name__=a,host=h2,job=x ; 0:c08b0a0000000000
+series __name__=a,host=h2,job=y ; 2:408cdf0000000000 3:407bd40000000000 5:408aac0000000000 6:c04ce00000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 1:c083620000000000 3:408ba80000000000 4:7ff8000000000001 5:c07fbe0000000000 6:c072d40000000000 8:c046c00000000000
+end
+case absent_over_time 5000 job!="x"
+grid 100000 10000 7
+series __name__=a,host=h1,job=x ; 5:405a780000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000
+end
+case absent_over_time 5000 host="h2",job!="x"
+grid 100000 10000 12
+series __name__=a,host=h1,job=y,zone=z1 ;
+series __name__=a,host=h1,job=x ; 8:c065d40000000000 9:c0823e0000000000
+series __name__=a,host=h2,job=x ; 1:c000000000000000 2:405ab00000000000 3:7ff0000000000000 4:407aaa0000000000 5:c083e60000000000 6:c084d00000000000 7:c053f80000000000 8:c048200000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 8:c08c180000000000 9:7e37e43c8800759c
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000 11:3ff0000000000000
+end
+case absent_over_time 45000 zone="z1"
+grid 100000 10000 3
+series __name__=a,host=h1,job=x,zone=z1 ;
+series __name__=a,host=h2,job=y,zone=z1 ; 1:c089c80000000000
+result zone=z1 ; 0:3ff0000000000000
+end
+case absent_over_time 10000 zone=""
+grid 100000 10000 6
+series __name__=a,host=h1,job=x,zone=z1 ; 0:40826d0000000000 1:c083ff0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 5000 host="h1"
+grid 100000 10000 3
+series __name__=a,host=h1,job=y,zone=z1 ; 1:c077060000000000
+series __name__=a,host=h2,job=y ; 1:405be80000000000
+series __name__=a,host=h1,job=x,zone=z1 ;
+result host=h1 ; 0:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 45000 job="y"
+grid 100000 10000 5
+series __name__=a,host=h1,job=x ; 4:407f1a0000000000
+series __name__=a,host=h2,job=x ; 4:40754a0000000000
+series __name__=a,host=h1,job=x,zone=z1 ;
+series __name__=a,host=h1,job=y,zone=z1 ; 1:4074580000000000 2:4084e50000000000
+result job=y ; 0:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 2
+series __name__=a,host=h1,job=y ; 1:fff0000000000000
+series __name__=a,host=h1,job=x ;
+series __name__=a,host=h2,job=x ; 0:4078200000000000 1:c029000000000000
+series __name__=a,host=h2,job=y ; 0:4083220000000000
+end
+case absent_over_time 45000 job!="x",zone=""
+grid 100000 10000 8
+series __name__=a,host=h2,job=y,zone=z1 ; 2:408e660000000000 3:c05eb80000000000
+series __name__=a,host=h2,job=y ; 5:4077020000000000 6:c0740a0000000000
+series __name__=a,host=h2,job=x ; 2:fff0000000000000 4:c0774a0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 6:0
+series __name__=a,host=h1,job=x ; 1:c040900000000000 2:4087350000000000 3:40735e0000000000 5:408e050000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 25000 job!="y"
+grid 100000 10000 7
+series __name__=a,host=h1,job=y,zone=z1 ; 4:7e37e43c8800759c
+series __name__=a,host=h2,job=x ; 6:c0779c0000000000
+series __name__=a,host=h2,job=y ; 2:4084890000000000 3:40683c0000000000
+series __name__=a,host=h1,job=y ; 4:7ff8000000000001 5:404f400000000000 6:c078e40000000000
+series __name__=a,host=h1,job=x ; 3:40759a0000000000 4:40802c0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 25000 host="h2",zone=""
+grid 100000 10000 11
+series __name__=a,host=h2,job=x ; 4:0 5:c07bda0000000000 6:4076540000000000
+series __name__=a,host=h2,job=y ; 7:c082630000000000
+series __name__=a,host=h1,job=y ; 9:408a340000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 5000 zone="z1"
+grid 100000 10000 11
+series __name__=a,host=h2,job=y ; 4:4076ac0000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 5:c07bd60000000000 6:c065000000000000 8:7ff0000000000000 9:408c110000000000 10:c0746e0000000000
+series __name__=a,host=h1,job=y ; 6:4088000000000000 7:fff0000000000000 8:4077ba0000000000
+result zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 7:3ff0000000000000
+end
+case absent_over_time 25000 job="y",zone!=""
+grid 100000 10000 12
+series __name__=a,host=h2,job=x ; 2:c06c200000000000 3:4084c10000000000
+series __name__=a,host=h1,job=y ;
+series __name__=a,host=h2,job=y ;
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000 11:3ff0000000000000
+end
+case absent_over_time 10000 zone!="z1"
+grid 100000 10000 3
+series __name__=a,host=h1,job=x ; 1:c069100000000000 2:0
+series __name__=a,host=h1,job=x,zone=z1 ; 1:c086ea0000000000
+series __name__=a,host=h1,job=y ; 2:c077a20000000000
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 3
+series __name__=a,host=h1,job=y ; 0:40811f0000000000 1:4087810000000000 2:c058b80000000000
+end
+case absent_over_time 45000 job="y",zone!="z1"
+grid 100000 10000 2
+series __name__=a,host=h2,job=x ; 0:c07fa60000000000 1:40821c0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 0:407a7a0000000000
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 host="h1",job="y"
+grid 100000 10000 5
+series __name__=a,host=h1,job=x ; 4:408d840000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 1:c071b40000000000 3:408b460000000000 4:c0840f0000000000
+series __name__=a,host=h2,job=x ;
+series __name__=a,host=h1,job=y ; 1:4054b80000000000
+result host=h1,job=y ; 0:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 45000 host="h2",job!="y"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 1:c08a650000000000 3:c047200000000000 4:4060980000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 3:bfe4000000000000 4:c07d540000000000 5:4077dc0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 5:4083d10000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 2
+series __name__=a,host=h2,job=y ; 1:4087460000000000
+series __name__=a,host=h2,job=x ; 0:c068800000000000
+series __name__=a,host=h1,job=x ; 1:c089420000000000
+end
+case absent_over_time 25000 host="h1"
+grid 100000 10000 10
+series __name__=a,host=h1,job=y ; 8:4080520000000000 9:c08ef50000000000
+series __name__=a,host=h1,job=x ; 5:c089710000000000 6:4074740000000000 7:40823d0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 5:4089e80000000000
+result host=h1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 5
+series __name__=a,host=h2,job=x,zone=z1 ; 3:c086dc0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 0:c07f2a0000000000 1:0 2:408bf70000000000
+end
+case absent_over_time 25000 -
+grid 100000 10000 3
+series __name__=a,host=h2,job=y,zone=z1 ; 2:c051a80000000000
+series __name__=a,host=h2,job=x ; 0:4087d80000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:fff0000000000000
+series __name__=a,host=h1,job=y ; 0:40874b0000000000
+end
+case absent_over_time 10000 job="x"
+grid 100000 10000 9
+series __name__=a,host=h2,job=y,zone=z1 ; 4:c08b380000000000 5:4085140000000000 7:7ff8000000000001
+series __name__=a,host=h2,job=y ; 4:0 6:c081e60000000000 7:4068f80000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 45000 zone!="z1"
+grid 100000 10000 12
+series __name__=a,host=h1,job=x ; 4:406e3c0000000000 5:c08b7b0000000000 7:c058f00000000000 8:c08dde0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 11:405a500000000000
+series __name__=a,host=h1,job=y ; 11:40873f0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 45000 host!="h2",job!="x",zone="z1"
+grid 100000 10000 3
+series __name__=a,host=h2,job=x ; 0:7ff0000000000000 1:7ff8000000000001 2:c083120000000000
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h1,job=x,zone=z1 ; 1:4088c70000000000
+result zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 25000 zone=""
+grid 100000 10000 4
+series __name__=a,host=h1,job=x,zone=z1 ; 1:c082c70000000000 2:c085d40000000000
+series __name__=a,host=h2,job=x,zone=z1 ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 10000 host!="h1",zone!="z1"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 0:0 1:407e220000000000 2:c07aa60000000000 3:c083e50000000000
+series __name__=a,host=h2,job=x ; 5:7ff8000000000001
+series __name__=a,host=h1,job=y,zone=z1 ; 2:c07be60000000000 3:c089540000000000 4:c066740000000000 5:c07c6a0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 10000 host="h1",zone!=""
+grid 100000 10000 3
+series __name__=a,host=h1,job=y,zone=z1 ; 2:4087fc0000000000
+series __name__=a,host=h1,job=y ; 2:4086a20000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 2:7ff8000000000001
+series __name__=a,host=h1,job=x ; 1:4074c80000000000
+result host=h1 ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 host="h2",job="y",zone="z1"
+grid 100000 10000 9
+series __name__=a,host=h2,job=y ; 8:c087ce0000000000
+series __name__=a,host=h2,job=x ; 3:c089820000000000 4:c07f2a0000000000 5:c04b700000000000 6:0
+result host=h2,job=y,zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 5
+series __name__=a,host=h2,job=y,zone=z1 ; 1:407dfe0000000000 2:407c820000000000 3:c07d3c0000000000 4:7ff0000000000000
+series __name__=a,host=h1,job=x ; 0:408dbd0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 4:c081e60000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 0:408bdb0000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 11
+series __name__=a,host=h1,job=x ; 9:c085bd0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 6:7ff8000000000001
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 5000 host="h2",zone=""
+grid 100000 10000 10
+series __name__=a,host=h1,job=y,zone=z1 ; 4:4054900000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 5000 job!="y"
+grid 100000 10000 7
+series __name__=a,host=h1,job=x ; 2:4060600000000000 3:408f080000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000
+end
+case absent_over_time 45000 host="h2"
+grid 100000 10000 8
+series __name__=a,host=h1,job=x ; 2:c071e40000000000 3:c089450000000000 4:4084b40000000000
+series __name__=a,host=h1,job=y ; 5:c060ac0000000000 6:408e290000000000 7:4060f00000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 6:c087fc0000000000
+series __name__=a,host=h2,job=y ; 7:c046f00000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 25000 host="h1",job!="y"
+grid 100000 10000 3
+series __name__=a,host=h2,job=y,zone=z1 ; 1:4084f20000000000
+series __name__=a,host=h1,job=x ; 0:c08dab0000000000 1:c0852b0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:4035400000000000
+series __name__=a,host=h2,job=y ; 1:fff0000000000000
+end
+case absent_over_time 5000 host!="h1"
+grid 100000 10000 2
+series __name__=a,host=h1,job=x,zone=z1 ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 job="x"
+grid 100000 10000 11
+series __name__=a,host=h2,job=y,zone=z1 ; 8:c059800000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 5:4071460000000000 7:4081220000000000
+series __name__=a,host=h2,job=x ; 3:407cf80000000000 4:4088fb0000000000 5:40820a0000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 25000 -
+grid 100000 10000 10
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h2,job=x,zone=z1 ; 2:4087750000000000 3:7e37e43c8800759c
+series __name__=a,host=h1,job=y,zone=z1 ; 5:0 7:c07a8c0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 host="h2"
+grid 100000 10000 10
+series __name__=a,host=h1,job=y ; 0:4082130000000000 2:c084730000000000 3:408ac60000000000 4:4042d00000000000 5:c08daf0000000000 6:40736c0000000000
+series __name__=a,host=h2,job=x ; 1:7ff8000000000001 2:4085af0000000000 3:c074820000000000 5:c0833a0000000000 6:407d660000000000 7:40837d0000000000 9:c06efc0000000000
+result host=h2 ; 0:3ff0000000000000
+end
+case absent_over_time 45000 host="h2",zone!=""
+grid 100000 10000 11
+series __name__=a,host=h2,job=y,zone=z1 ; 10:4077ba0000000000
+series __name__=a,host=h1,job=y ; 0:408cce0000000000 1:408bd00000000000 3:4084330000000000 5:407ff00000000000 6:c0770a0000000000 7:fff0000000000000 8:7ff0000000000000 9:406ec40000000000
+series __name__=a,host=h2,job=x ; 4:7ff8000000000001 5:c06e840000000000 6:c088c20000000000 7:40813f0000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 8
+series __name__=a,host=h1,job=x,zone=z1 ; 3:4065f80000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 5:c08bd20000000000 6:408c3d0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 4:c08bb40000000000 7:408ccd0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 45000 host!="h2",job="x"
+grid 100000 10000 4
+series __name__=a,host=h1,job=x,zone=z1 ; 2:c082f20000000000 3:c0864b0000000000
+series __name__=a,host=h1,job=y ; 2:40635c0000000000 3:4081d80000000000
+series __name__=a,host=h2,job=y,zone=z1 ;
+series __name__=a,host=h2,job=y ; 2:c087ac0000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 job!="y"
+grid 100000 10000 5
+series __name__=a,host=h2,job=x ; 2:4057200000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 2:c076bc0000000000 3:c07fc40000000000 4:40883c0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 0:c08b640000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 3:c080f00000000000 4:40754e0000000000
+end
+case absent_over_time 25000 zone=""
+grid 100000 10000 2
+series __name__=a,host=h2,job=x,zone=z1 ; 1:c084120000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 10000 job="y",zone="z1"
+grid 100000 10000 11
+series __name__=a,host=h2,job=y ; 6:c0743c0000000000
+series __name__=a,host=h2,job=x ; 7:7ff0000000000000 8:c066c00000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 0:c06f580000000000 2:c077d60000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 5:4074c40000000000 6:c08ea90000000000 7:c06ca80000000000 8:c05ed80000000000 10:4063200000000000
+result job=y,zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 3
+series __name__=a,host=h2,job=y ; 1:4062cc0000000000 2:c089f60000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 1:c0711c0000000000
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 25000 zone!=""
+grid 100000 10000 11
+series __name__=a,host=h2,job=x ; 8:40678c0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 25000 job!="x"
+grid 100000 10000 1
+series __name__=a,host=h2,job=x,zone=z1 ;
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 5000 host="h1",job!="x"
+grid 100000 10000 10
+series __name__=a,host=h2,job=y ; 4:c086d20000000000 5:7ff0000000000000 6:0 7:40602c0000000000 8:7ff8000000000001
+series __name__=a,host=h2,job=x,zone=z1 ; 7:4084ff0000000000 8:4086af0000000000
+series __name__=a,host=h2,job=x ; 5:c08a490000000000 6:7ff8000000000001 7:c0896e0000000000 9:c082710000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 8:408e860000000000
+series __name__=a,host=h1,job=y ; 1:c07ef40000000000 2:c0862d0000000000 3:c07d940000000000 4:c0848b0000000000 6:c05f580000000000 7:408b0a0000000000 8:4084cd0000000000
+result host=h1 ; 0:3ff0000000000000 5:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 5000 zone!="z1"
+grid 100000 10000 4
+series __name__=a,host=h1,job=x,zone=z1 ;
+series __name__=a,host=h2,job=x,zone=z1 ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 10000 host="h1",zone!=""
+grid 100000 10000 12
+series __name__=a,host=h1,job=x,zone=z1 ; 6:4081980000000000
+series __name__=a,host=h2,job=x ; 8:c088ee0000000000
+series __name__=a,host=h1,job=x ; 4:c06b780000000000 5:c080be0000000000
+series __name__=a,host=h1,job=y ; 1:4043800000000000 2:c068ec0000000000 3:4044200000000000
+series __name__=a,host=h2,job=y ; 10:407e900000000000
+result host=h1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000 11:3ff0000000000000
+end
+case absent_over_time 10000 job="x",zone!="z1"
+grid 100000 10000 8
+series __name__=a,host=h2,job=x,zone=z1 ; 0:4047700000000000 1:7ff8000000000001
+series __name__=a,host=h2,job=y ; 6:c06a580000000000
+result job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000
+end
+case absent_over_time 45000 job!="x"
+grid 100000 10000 5
+series __name__=a,host=h1,job=y ; 4:4062340000000000
+series __name__=a,host=h2,job=y ; 4:7ff8000000000001
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 25000 host!="h2",zone=""
+grid 100000 10000 4
+series __name__=a,host=h2,job=y ; 3:c063f00000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 1:c077860000000000
+series __name__=a,host=h1,job=y ; 0:c088540000000000 1:406c140000000000 2:4052600000000000
+end
+case absent_over_time 10000 host="h1",job="x"
+grid 100000 10000 5
+series __name__=a,host=h2,job=y,zone=z1 ; 1:c0889f0000000000 2:405fb00000000000 3:c088810000000000
+series __name__=a,host=h2,job=y ; 1:c084a70000000000
+result host=h1,job=x ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 10000 host="h2"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x,zone=z1 ; 5:40831c0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:c082e40000000000
+series __name__=a,host=h2,job=y ; 0:c083b30000000000 1:c087ad0000000000
+result host=h2 ; 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 6
+series __name__=a,host=h2,job=y ; 1:7ff8000000000001 2:c081860000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 1:4087300000000000 2:c068780000000000
+series __name__=a,host=h2,job=x ;
+series __name__=a,host=h1,job=x ;
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 10000 zone=""
+grid 100000 10000 11
+series __name__=a,host=h2,job=y,zone=z1 ; 2:407d260000000000 3:7ff8000000000001 4:7ff8000000000001
+series __name__=a,host=h2,job=y ; 5:407d8e0000000000
+series __name__=a,host=h2,job=x ; 8:4087c30000000000 9:4079940000000000 10:7e37e43c8800759c
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000
+end
+case absent_over_time 25000 host="h2",job!="y"
+grid 100000 10000 1
+series __name__=a,host=h1,job=y ; 0:c08c650000000000
+result host=h2 ; 0:3ff0000000000000
+end
+case absent_over_time 45000 host="h1"
+grid 100000 10000 9
+series __name__=a,host=h1,job=y ; 1:c06acc0000000000 2:c07ee60000000000 4:7e37e43c8800759c 5:4089760000000000 6:c08d7c0000000000 7:402b000000000000 8:4063140000000000
+series __name__=a,host=h2,job=y ; 3:0 4:7ff0000000000000 5:c070a20000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 1:c0751e0000000000 2:408b840000000000 5:407f8c0000000000 7:7ff8000000000001 8:c089570000000000
+series __name__=a,host=h2,job=x ;
+result host=h1 ; 0:3ff0000000000000
+end
+case absent_over_time 5000 zone=""
+grid 100000 10000 6
+series __name__=a,host=h2,job=x,zone=z1 ; 3:7ff8000000000001 4:4074960000000000 5:4076400000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 5000 job="y"
+grid 100000 10000 9
+series __name__=a,host=h2,job=y,zone=z1 ; 1:c06aec0000000000 2:7e37e43c8800759c 3:408e0a0000000000
+series __name__=a,host=h1,job=y ; 2:c088280000000000 4:c07af60000000000
+series __name__=a,host=h1,job=x,zone=z1 ;
+result job=y ; 0:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 25000 host="h2",job!="x"
+grid 100000 10000 5
+series __name__=a,host=h2,job=x ; 3:7ff8000000000001
+series __name__=a,host=h2,job=y ; 2:4042b00000000000 3:7e37e43c8800759c
+series __name__=a,host=h2,job=y,zone=z1 ; 3:403ba00000000000 4:4088470000000000
+result host=h2 ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 45000 job!="y",zone=""
+grid 100000 10000 6
+series __name__=a,host=h1,job=x,zone=z1 ; 2:c084530000000000
+series __name__=a,host=h2,job=x ; 0:40661c0000000000 1:c050700000000000 2:c074100000000000
+series __name__=a,host=h1,job=x ; 1:7ff8000000000001
+series __name__=a,host=h2,job=y ; 5:c050580000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 8
+series __name__=a,host=h2,job=y,zone=z1 ; 3:408cb00000000000 4:408c2a0000000000 5:40661c0000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 4:c08bbb0000000000 5:c086730000000000 6:4089800000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 7:3ff0000000000000
+end
+case absent_over_time 25000 job="y"
+grid 100000 10000 6
+series __name__=a,host=h2,job=y ; 1:0 3:408ef10000000000 4:c087950000000000 5:c075120000000000
+series __name__=a,host=h1,job=x ; 5:40813d0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:408b070000000000 3:c045400000000000
+result job=y ; 0:3ff0000000000000
+end
+case absent_over_time 45000 zone!=""
+grid 100000 10000 10
+series __name__=a,host=h2,job=y ; 5:7e37e43c8800759c 6:c084330000000000 7:c073760000000000
+series __name__=a,host=h1,job=x ; 2:c067a80000000000 3:406d240000000000 4:407df60000000000 5:407a100000000000 7:c073960000000000 8:4084090000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 25000 host!="h1",zone=""
+grid 100000 10000 2
+series __name__=a,host=h2,job=y ; 1:4074da0000000000
+series __name__=a,host=h1,job=y ; 1:7ff8000000000001
+series __name__=a,host=h1,job=x ; 1:7ff8000000000001
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 10000 host!="h2"
+grid 100000 10000 9
+series __name__=a,host=h2,job=y ; 5:c08ca90000000000
+series __name__=a,host=h2,job=x ; 2:4061c00000000000
+series __name__=a,host=h1,job=x ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 5
+series __name__=a,host=h2,job=x,zone=z1 ; 2:c084e70000000000
+series __name__=a,host=h1,job=y ; 2:4070760000000000
+series __name__=a,host=h1,job=x,zone=z1 ; 1:40862d0000000000 2:408edc0000000000 3:c049000000000000
+series __name__=a,host=h1,job=x ; 4:c06fbc0000000000
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 10000 host!="h1",zone!=""
+grid 100000 10000 4
+series __name__=a,host=h1,job=y ; 1:c087880000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 45000 job="x"
+grid 100000 10000 4
+series __name__=a,host=h2,job=x ; 1:c06f800000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:c06b2c0000000000
+series __name__=a,host=h1,job=x ; 3:c0782a0000000000
+result job=x ; 0:3ff0000000000000
+end
+case absent_over_time 5000 zone!=""
+grid 100000 10000 6
+series __name__=a,host=h1,job=y ; 5:c089420000000000
+series __name__=a,host=h1,job=x ;
+series __name__=a,host=h2,job=x,zone=z1 ; 0:40707a0000000000 1:4083090000000000 2:c083440000000000
+result - ; 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 5000 host!="h1",zone!="z1"
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 3:4063480000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 5000 job!="y",zone!=""
+grid 100000 10000 5
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h1,job=y ; 2:408e210000000000 3:c073e00000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 10000 host="h1",zone=""
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ; 3:7ff8000000000001 4:c065b40000000000
+series __name__=a,host=h2,job=y ; 5:4083ab0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 0:c08f2f0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 1:4072700000000000 2:c08e9e0000000000
+result host=h1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 25000 host!="h2",zone=""
+grid 100000 10000 12
+series __name__=a,host=h2,job=y,zone=z1 ; 5:c08f160000000000 6:408bc20000000000 7:c0897f0000000000
+series __name__=a,host=h1,job=y ; 2:c087330000000000 4:7ff0000000000000 5:c080850000000000 7:408b820000000000 8:7e37e43c8800759c 10:c074840000000000 11:4063c80000000000
+series __name__=a,host=h2,job=y ; 9:c0877b0000000000 10:fff0000000000000 11:4057c80000000000
+series __name__=a,host=h1,job=x ; 6:c03ca00000000000 7:c06e700000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 9:40874a0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 1:407c460000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 10000 -
+grid 100000 10000 10
+series __name__=a,host=h2,job=x,zone=z1 ; 0:c019000000000000 1:7ff8000000000001
+series __name__=a,host=h1,job=x,zone=z1 ;
+series __name__=a,host=h1,job=y ; 0:c082570000000000 1:c087380000000000 2:c069b80000000000
+result - ; 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 45000 job="x",zone="z1"
+grid 100000 10000 5
+series __name__=a,host=h1,job=x,zone=z1 ; 1:c0854c0000000000
+result job=x,zone=z1 ; 0:3ff0000000000000
+end
+case absent_over_time 45000 job="y",zone!=""
+grid 100000 10000 12
+series __name__=a,host=h1,job=x ; 6:4067f80000000000 7:0
+series __name__=a,host=h1,job=y ; 7:fff0000000000000 8:c086ba0000000000 10:4079380000000000 11:7ff8000000000001
+series __name__=a,host=h2,job=y,zone=z1 ; 11:4082f50000000000
+series __name__=a,host=h2,job=y ; 11:406f040000000000
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 10000 job!="x"
+grid 100000 10000 7
+series __name__=a,host=h2,job=x,zone=z1 ; 0:40817b0000000000 1:c078100000000000 3:c078320000000000 5:7ff8000000000001
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000
+end
+case absent_over_time 25000 job="x"
+grid 100000 10000 10
+series __name__=a,host=h1,job=x ; 0:4071560000000000 1:c064fc0000000000 2:4080b40000000000 7:c052e00000000000 8:408a5f0000000000
+series __name__=a,host=h2,job=y ; 2:408c5b0000000000
+result job=x ; 5:3ff0000000000000 6:3ff0000000000000
+end
+case absent_over_time 10000 -
+grid 100000 10000 5
+series __name__=a,host=h2,job=y ; 4:c060e80000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 3:c08aec0000000000
+series __name__=a,host=h1,job=x ; 2:4088e80000000000 3:40876c0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 25000 host!="h2",zone="z1"
+grid 100000 10000 8
+series __name__=a,host=h1,job=y ;
+series __name__=a,host=h1,job=x ; 6:7ff8000000000001
+series __name__=a,host=h2,job=x ; 3:7e37e43c8800759c 4:406f600000000000 5:c07d7e0000000000 6:c08cd50000000000
+result zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000
+end
+case absent_over_time 5000 host="h2",job="x",zone="z1"
+grid 100000 10000 6
+series __name__=a,host=h1,job=y ; 5:40725c0000000000
+series __name__=a,host=h2,job=y ; 2:c082840000000000
+series __name__=a,host=h2,job=x ; 2:c06eb40000000000
+result host=h2,job=x,zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 25000 -
+grid 100000 10000 7
+series __name__=a,host=h1,job=x,zone=z1 ; 4:c076a80000000000 5:4088a20000000000 6:40833b0000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 5:40753a0000000000 6:405d100000000000
+series __name__=a,host=h1,job=x ;
+series __name__=a,host=h1,job=y ; 2:4083850000000000 3:c0881b0000000000 4:4087110000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 2
+series __name__=a,host=h1,job=y ;
+series __name__=a,host=h1,job=x ; 1:40813e0000000000
+result - ; 0:3ff0000000000000
+end
+case absent_over_time 10000 -
+grid 100000 10000 6
+series __name__=a,host=h1,job=y ; 5:7ff8000000000001
+series __name__=a,host=h1,job=x ; 0:c0867a0000000000 1:40744e0000000000 2:0 3:7ff8000000000001 4:7ff8000000000001
+series __name__=a,host=h2,job=x ;
+end
+case absent_over_time 45000 job="y"
+grid 100000 10000 3
+series __name__=a,host=h2,job=x ; 1:4084e10000000000
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h1,job=x ;
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000
+end
+case absent_over_time 5000 job="y"
+grid 100000 10000 2
+series __name__=a,host=h2,job=y ; 0:7ff8000000000001 1:408e570000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 0:4085530000000000 1:7e37e43c8800759c
+end
+case absent_over_time 45000 zone=""
+grid 100000 10000 11
+series __name__=a,host=h1,job=x ; 9:408e050000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 5:40806c0000000000 6:c079500000000000 7:406ef80000000000 8:c082b20000000000 9:c088410000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 1:7ff8000000000001 2:c08b7a0000000000 3:c068080000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000
+end
+case absent_over_time 10000 zone=""
+grid 100000 10000 10
+series __name__=a,host=h1,job=x,zone=z1 ; 0:c083b60000000000 1:4077be0000000000 2:40854d0000000000 3:4080900000000000 4:408e200000000000
+series __name__=a,host=h1,job=x ; 4:4069740000000000 5:408a390000000000 6:405c080000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 8:4089040000000000
+series __name__=a,host=h2,job=x ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000
+end
+case absent_over_time 5000 job!="x",zone="z1"
+grid 100000 10000 11
+series __name__=a,host=h2,job=y ; 0:4081dd0000000000 1:c08bbf0000000000 2:4069d00000000000
+series __name__=a,host=h1,job=y,zone=z1 ; 5:7ff0000000000000
+result zone=z1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 6:3ff0000000000000 7:3ff0000000000000 8:3ff0000000000000 9:3ff0000000000000 10:3ff0000000000000
+end
+case absent_over_time 25000 zone=""
+grid 100000 10000 6
+series __name__=a,host=h2,job=x,zone=z1 ; 0:fff0000000000000
+series __name__=a,host=h2,job=x ;
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 45000 -
+grid 100000 10000 6
+series __name__=a,host=h1,job=y,zone=z1 ; 5:4065780000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 25000 host!="h2",job!="x"
+grid 100000 10000 8
+series __name__=a,host=h2,job=y ; 2:c058680000000000 4:c0689c0000000000
+series __name__=a,host=h2,job=x ; 7:c086690000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 7:c087330000000000
+series __name__=a,host=h1,job=y ; 0:408b130000000000 1:c07ff80000000000 2:408bd20000000000 3:c040100000000000 4:7e37e43c8800759c
+result - ; 7:3ff0000000000000
+end
+case absent_over_time 5000 -
+grid 100000 10000 3
+series __name__=a,host=h2,job=x ; 2:c072160000000000
+series __name__=a,host=h2,job=y,zone=z1 ; 0:c06b880000000000
+series __name__=a,host=h1,job=y ;
+series __name__=a,host=h1,job=x,zone=z1 ; 1:c071820000000000 2:0
+end
+case absent_over_time 10000 zone!="z1"
+grid 100000 10000 4
+series __name__=a,host=h2,job=x ; 2:408ece0000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 3:3ff0000000000000
+end
+case absent_over_time 10000 -
+grid 100000 10000 6
+series __name__=a,host=h1,job=x ;
+series __name__=a,host=h2,job=y ;
+series __name__=a,host=h1,job=y ; 5:fff0000000000000
+result - ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000
+end
+case absent_over_time 45000 job="y",zone!="z1"
+grid 100000 10000 7
+series __name__=a,host=h2,job=y ; 6:c087ff0000000000
+series __name__=a,host=h2,job=x ; 4:403fa00000000000 5:c08c740000000000
+series __name__=a,host=h1,job=x ; 1:c08b9a0000000000 2:4086000000000000 3:407d680000000000 4:c0881e0000000000
+series __name__=a,host=h2,job=x,zone=z1 ; 2:408b6e0000000000
+result job=y ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000
+end
+case absent_over_time 25000 host="h1",job!="x"
+grid 100000 10000 7
+series __name__=a,host=h1,job=x ; 4:c0607c0000000000
+result host=h1 ; 0:3ff0000000000000 1:3ff0000000000000 2:3ff0000000000000 3:3ff0000000000000 4:3ff0000000000000 5:3ff0000000000000 6:3ff0000000000000
+end

src/promql/src/range_eval/experimental_cases.txt

@@ -0,0 +1,243 @@
+# Generated by promql-compat cmd/narthex-golden built for amd64 (Prometheus v3.15.0 engine, seed 1,
+# `-only first_over_time,mad_over_time,ts_of_first_over_time,ts_of_last_over_time,ts_of_min_over_time,ts_of_max_over_time -at -cases 40`).
+# Each line: function params range_ms offset_ms start_ms step_ms points [anchor_ms] ; samples ; result
+first_over_time - 3203 4376 19888 3203 19 ; 12166:c257759f462f60fd 13861:c027de5a16a21d0e 15136:40d17d1ded071630 17632:418148f1bdf553bf 20580:41816ba7ea66b83e 21122:7ff0000000000002 23954:4236130864b31007 25440:4257ec5b0b91d690 27004:c06eceb438438b02 28164:c0d3d031882af4e9 30364:c006378342e8b71a 31068:406e3b2aae250fc0 31225:40af03d6d29d9143 ; 19888:c027de5a16a21d0e 23091:418148f1bdf553bf 26294:41816ba7ea66b83e 29497:4236130864b31007 32700:4257ec5b0b91d690 35903:c006378342e8b71a
+first_over_time - 3287 0 9150 3286 12 12050 ; 9087:405e18e4a7b1aff0 11147:405f2a8f0e098f65 12026:4062edbafd64e104 14530:4064afdbe0cf4df5 15956:406895a20db0c199 16967:7ff0000000000002 ; 9150:405e18e4a7b1aff0 12436:405e18e4a7b1aff0 15722:405e18e4a7b1aff0 19008:405e18e4a7b1aff0 22294:405e18e4a7b1aff0 25580:405e18e4a7b1aff0 28866:405e18e4a7b1aff0 32152:405e18e4a7b1aff0 35438:405e18e4a7b1aff0 38724:405e18e4a7b1aff0 42010:405e18e4a7b1aff0 45296:405e18e4a7b1aff0
+first_over_time - 5321 0 31447 3887 13 15935 ; 8864:fe37e43c8800759c 9135:406727eb92980ea0 11188:408dbacc0accd5ff 13938:c07207728fcfff40 15163:c089a29f60de2300 38002:4062058e27a3d2a6 38643:408c9f433ad76d52 39827:c0871960e2d59fd5 42595:0 44819:c0854595d35fc02f 46986:403990429960f4a4 48149:407b0bc9ba296b09 48580:0 49364:c081b8762eecd485 50930:c0751437362922dd 52687:c0661d6ab062060a 54317:7e37e43c8800759c ; 31447:408dbacc0accd5ff 35334:408dbacc0accd5ff 39221:408dbacc0accd5ff 43108:408dbacc0accd5ff 46995:408dbacc0accd5ff 50882:408dbacc0accd5ff 54769:408dbacc0accd5ff 58656:408dbacc0accd5ff 62543:408dbacc0accd5ff 66430:408dbacc0accd5ff 70317:408dbacc0accd5ff 74204:408dbacc0accd5ff 78091:408dbacc0accd5ff
+first_over_time - 624 5265 23252 623 20 32031 ; 21126:c245085909f470fb 22980:7ff0000000000002 23374:c0a4997354e139d3 23895:3ff4f0a47a75ac32 24956:414a831d4fb2e40a 25017:428861cb7144bc3b 27618:c291a685b11c6cf1 29423:40e7b451da042ff4 29438:c107218dca4aa413 29723:421c7c8d1cc70ecd 30114:40e65f345c3e79b7 38452:c159ac6fff7e762f 38690:c27623b13afbb75e 41043:7ff0000000000002 ; 
+first_over_time - 3049 0 6817 3049 1 ; 909:430c6bf5263401dd 1918:430c6bf5263401aa 3294:430c6bf526340038 4762:430c6bf5263401d6 5486:430c6bf5263402be 5526:430c6bf526340177 6043:430c6bf526340270 7095:430c6bf5263401f0 9983:430c6bf52634004d 10845:430c6bf526340094 13499:430c6bf5263400a1 15776:430c6bf526340213 16357:7ff0000000000002 18625:430c6bf526340260 21434:430c6bf526340209 23877:430c6bf5263401f3 24131:430c6bf5263400d8 ; 6817:430c6bf5263401d6
+first_over_time - 1047 0 2941 1046 2 39316 ; 6733:40471b3eafa72831 7155:40517598d5100f2d 10078:401f96b44c27949d 12103:403b7075994089de 12228:4043ec98f12ac987 13969:404a9570df50d662 14551:405917919aa7234e 16755:405d51bf8eac441b 18133:40614e6ea388c8ac 20941:4062dbe63c105211 23486:40671fef12688daa 25061:4067ea1de9d8c995 27585:406be3a460de91b1 30257:406f4c9b379bd5c0 30612:4071b1ce88f61182 31534:7ff0000000000002 32384:4073b4133648eda7 34525:400ad768ba6cc83d 36636:4045820937ca1ee9 37962:40460facdd67c9c3 39399:404f4025657b0c25 41426:405bbc0e3f1c0387 43603:7ff0000000000002 44038:405f555db2888836 ; 
+first_over_time - 12714 4870 29546 122 7 ; 12305:4048f1ab82fc1b38 13822:404bf9556c907b77 15786:40509f7450827834 18662:4059386d44dcf7f8 20215:405fc25edfb6c866 21928:4060deb6b75ac540 24243:40659814328ad498 26583:4067b341497797e6 29478:406a14d43350a40d 30807:406ce083951cf581 32529:401a0c05995205a8 32872:403ca4dd4d363108 33785:7ff0000000000002 35238:404945aec4b42a58 37933:40586835bd3022fa 39348:7ff0000000000002 40617:4061307f3192d5d8 43386:4067225f6c516755 ; 29546:4048f1ab82fc1b38 29668:4048f1ab82fc1b38 29790:4048f1ab82fc1b38 29912:404bf9556c907b77 30034:404bf9556c907b77 30156:404bf9556c907b77 30278:404bf9556c907b77
+first_over_time - 1163 4214 16037 1162 4 ; 11794:0 14476:0 17094:0 17668:0 ; 16037:0 19523:0
+first_over_time - 3152 0 16896 3151 9 31976 ; 13707:c077d0556d909810 27058:40811baaa574c70b 29893:c075dd65862c3de1 29987:c08022b7d8ea1ae4 29994:7ff8000000000001 32237:c00ab30f46719512 ; 16896:c075dd65862c3de1 20047:c075dd65862c3de1 23198:c075dd65862c3de1 26349:c075dd65862c3de1 29500:c075dd65862c3de1 32651:c075dd65862c3de1 35802:c075dd65862c3de1 38953:c075dd65862c3de1 42104:c075dd65862c3de1
+first_over_time - 16153 3237 31529 3097 13 34454 ; 19229:7ff8000000000001 21425:7ff8000000000001 23725:4084037caf5129e6 24669:406cdf06eec2b178 26221:c05137cbb9b8ed13 28401:406388f088c867c4 28716:c062f22ccf8c35ec 31553:4073c66f856aec38 33166:c088ed39e788a744 35699:7ff8000000000001 41889:c03a5c83c0a9e86d 42698:c075da093f572de8 ; 31529:7ff8000000000001 34626:7ff8000000000001 37723:7ff8000000000001 40820:7ff8000000000001 43917:7ff8000000000001 47014:7ff8000000000001 50111:7ff8000000000001 53208:7ff8000000000001 56305:7ff8000000000001 59402:7ff8000000000001 62499:7ff8000000000001 65596:7ff8000000000001 68693:7ff8000000000001
+first_over_time - 4779 -3547 40411 2386 1 31306 ; 13142:430c6bf5263401a5 15581:430c6bf5263402c1 18253:7ff0000000000002 18781:430c6bf526340131 19019:430c6bf5263400ba 20382:430c6bf526340279 41464:430c6bf5263401c4 41537:430c6bf52634007b 42458:430c6bf526340019 42519:430c6bf5263402b9 ; 
+first_over_time - 3817 0 27718 3817 17 ; 19253:c087688906d0f106 28225:407f4c6570265486 28469:c07cede62fadf795 30270:c08aab4bc806bf9d 31462:7ff8000000000001 32741:7ff8000000000001 33125:40701dffe731a610 35284:4041aeb4a41922eb ; 31535:407f4c6570265486 35352:7ff8000000000001
+first_over_time - 3465 0 5868 3465 6 ; 9988:405af491bdaea06a 11893:406140124545bacd 12404:4066ef0789c6a9b1 14808:406772c9c80db14f ; 12798:405af491bdaea06a 16263:406772c9c80db14f
+first_over_time - 2379 -449 57475 1186 5 36397 ; 25710:4072372cd5ec0f32 27041:40830ff34a3d73ae 27540:8000000000000000 29684:405e8dcc39d454a6 48802:7e37e43c8800759c 51781:7ff0000000000002 53995:c08e60baa7b430e1 55167:c07ffb80167a05e6 57556:408e21dae9cc167a 58540:4040bce996516872 58614:fe37e43c8800759c 59578:c07a30a0c08611b2 61676:0 62460:c084890dad5d4f7c 63063:c084cd4f0f03edb9 64946:4069ae3d3b7b4840 65295:40793d5682208c9a 67372:7e37e43c8800759c 69137:408eae21d18129bd 71959:fe37e43c8800759c 73971:8000000000000000 74598:c058a9e7e147176a ; 
+first_over_time - 3600 -6762 45686 3600 7 25569 ; 17432:408bb7c2008cd4d2 20033:7ff8000000000001 20732:405203b0ad145210 22875:7ff0000000000002 37129:7ff8000000000001 38525:c086bafba7d9a15c 40881:7ff8000000000001 42086:7ff8000000000001 44524:4081dd0ac5288cb5 46570:7ff8000000000001 49436:408829ebfa8eacac ; 
+first_over_time - 3403 8497 3932 1698 5 ; 2834:c0706117d78ff098 5290:408521d66aa83bde 8003:8000000000000000 10916:405ece824d076ae6 ; 
+first_over_time - 1441 -1474 29531 1441 7 34414 ; 8008:430c6bf52634029a 9590:430c6bf5263400ca 9783:430c6bf5263401e1 11455:430c6bf52634014a 13480:430c6bf5263400f3 14337:430c6bf52634013a 16525:430c6bf5263401f3 33379:430c6bf526340111 34881:430c6bf526340277 36530:430c6bf5263400a6 36890:430c6bf526340016 37203:430c6bf526340084 40160:430c6bf526340206 ; 29531:430c6bf526340277 30972:430c6bf526340277 32413:430c6bf526340277 33854:430c6bf526340277 35295:430c6bf526340277 36736:430c6bf526340277 38177:430c6bf526340277
+first_over_time - 12072 5309 40853 3003 18 61310 ; 14081:40661dc09dc0494f 15270:407739f4234be29c 16483:7ff8000000000001 18025:c0781473b60f2d79 20963:c083b92521352a06 21550:4076d887837be3f2 22847:40681077f1d49b06 22962:7ff8000000000001 24366:4085a720e46875ab 27141:405d8ed0800aa28e 27984:408742a5044f6311 52737:408d16addd5395e6 54079:c0795033bdcbcbbb 56114:c07392e499eebf17 57975:c08a1e619ce1fce0 ; 40853:408d16addd5395e6 43856:408d16addd5395e6 46859:408d16addd5395e6 49862:408d16addd5395e6 52865:408d16addd5395e6 55868:408d16addd5395e6 58871:408d16addd5395e6 61874:408d16addd5395e6 64877:408d16addd5395e6 67880:408d16addd5395e6 70883:408d16addd5395e6 73886:408d16addd5395e6 76889:408d16addd5395e6 79892:408d16addd5395e6 82895:408d16addd5395e6 85898:408d16addd5395e6 88901:408d16addd5395e6 91904:408d16addd5395e6
+first_over_time - 13498 -2284 64971 461 10 19982 ; 13077:c06c82f71db36dbc 14051:408b918c57d84992 15105:c08d8745ea61bc5b 17666:4087ab0118b51e55 18336:c06efeabf2cccfb4 21262:c043e2b46e484032 21532:408667aaf035b2ae 22954:4067725048e78556 23203:c053eb297910e474 25221:405a55d5ee29e787 27372:c08d96a76b2e04e0 28620:7ff8000000000001 51628:c068da8cd58128ba 52043:40820308d17ea761 54898:4077a2a6fc26393f 67652:c085810afe44374f 68977:c06ed26bfaa62364 70530:c0823b9863d2bc16 72060:c088b19c35ceacfc 72815:7ff8000000000001 74922:408bb11ba7be6c59 76633:408ace6a598f2384 78649:c073ee200ca5c302 81438:7ff8000000000001 ; 64971:c06c82f71db36dbc 65432:c06c82f71db36dbc 65893:c06c82f71db36dbc 66354:c06c82f71db36dbc 66815:c06c82f71db36dbc 67276:c06c82f71db36dbc 67737:c06c82f71db36dbc 68198:c06c82f71db36dbc 68659:c06c82f71db36dbc 69120:c06c82f71db36dbc
+first_over_time - 7525 9265 30700 3759 10 43320 ; 14941:41d563c9fbb8c603 16901:c107368bc8b38718 17496:41bba44350827e87 18278:4275e5154857153e 19113:41323dd3a1d22d7f 21044:c1b79fcaf52b06a7 22846:c0d5ff21a42600bf 25721:428469214f3d32d9 27685:4239cc5345b1dfc3 29744:4281a57190552487 31034:c0dffd3193fb192b 33375:42f8826dd2a13c5a 34528:c040021fcc03decc 37104:bfdcd28ce0c3b282 37253:c2b10726b7fd4ab4 40234:7ff0000000000002 41633:428a32b53fdaaa0b 43748:c10b6d2e6de916d4 45011:425c8528562b1a49 45362:c1835b54fbacb2a1 46617:bff543d2de402da6 ; 30700:4239cc5345b1dfc3 34459:4239cc5345b1dfc3 38218:4239cc5345b1dfc3 41977:4239cc5345b1dfc3 45736:4239cc5345b1dfc3 49495:4239cc5345b1dfc3 53254:4239cc5345b1dfc3 57013:4239cc5345b1dfc3 60772:4239cc5345b1dfc3 64531:4239cc5345b1dfc3
+first_over_time - 4787 9628 18189 2390 16 ; 10413:4132561070188daf 12900:c1906f0790d59e9c 14009:40363ad9b9a16730 14149:42889e296158fbdd 15341:42e8fc2f1c49e06c 18174:c0443651f72a0da0 20885:c2b90c392f6360f4 ; 20579:4132561070188daf 22969:4132561070188daf 25359:c1906f0790d59e9c 27749:40363ad9b9a16730 30139:c0443651f72a0da0 32529:c0443651f72a0da0 34919:c2b90c392f6360f4
+first_over_time - 2977 0 42917 1485 5 52564 ; 17308:408f0b52754ad4b5 18508:4078c3fc9518e80d 19736:c08cce789da3f890 22383:c076c3abe1867b96 24466:c0886a5043213d0d 26643:c08bef8f710b8c85 29238:c076b1b05caf78af 31372:40841267ca8ad42c 34057:4077437025b12da5 47043:c0641fe96da49c88 48420:c0864a9189204503 49921:c013da1381b1c5c9 ; 42917:c013da1381b1c5c9 44402:c013da1381b1c5c9 45887:c013da1381b1c5c9 47372:c013da1381b1c5c9 48857:c013da1381b1c5c9
+first_over_time - 337 3966 10320 337 3 10344 ; 8499:40507f904c18897e 9562:4005775801abd2c7 11946:4041acb97435301f 13409:404cbeab9d2424f6 33576:4053fd47c233ba28 34952:405f615fd504f541 36957:7ff0000000000002 39496:40615df3c122bf56 40290:4066c41e1458a4df 40556:406befaaae4a0a34 41675:4070265ab05f4b38 42513:4070d1f6bd29b4f1 44424:40733d201e9ae6c7 44837:40754c3771e7de2a 45081:4075ae714e1eed1b 46315:4077d1b9249f09b5 47244:407a6b6596f630b5 ; 
+first_over_time - 15814 -8363 15989 2411 2 ; 11692:4054ea7373a508eb 13809:4059cd5aa99d421e 15598:40629bb493d019d2 16818:40649d261f90397a ; 15989:4054ea7373a508eb 18400:4054ea7373a508eb
+first_over_time - 311 0 28588 311 20 44342 ; 17326:7e37e43c8800759c 17637:7e37e43c8800759c 18844:7e37e43c8800759c 19811:7e37e43c8800759c 22508:7e37e43c8800759c 23296:7e37e43c8800759c 25414:7e37e43c8800759c 26009:7e37e43c8800759c 26212:7e37e43c8800759c 28526:7e37e43c8800759c 29723:7e37e43c8800759c 31954:7e37e43c8800759c 33593:7e37e43c8800759c 34368:7e37e43c8800759c 36757:7e37e43c8800759c 37815:7e37e43c8800759c 39958:7e37e43c8800759c 41275:7e37e43c8800759c ; 
+first_over_time - 2470 -3697 30386 2470 8 34889 ; 18607:8000000000000000 19272:8000000000000000 40160:8000000000000000 40337:8000000000000000 ; 
+first_over_time - 1000 6726 1380 2346 9 5384 ; 5223:7ff8000000000001 5487:4073c16e8422d64f 8343:7ff8000000000001 9214:7ff8000000000001 ; 
+first_over_time - 1000 0 10970 1121 18 ; 7048:4058229faa9baca2 9831:405cce4ae506fdb0 12523:4062ec2abcb56448 12624:401ba8a9748a4be7 15501:403ff872cad84e09 17259:404ffcd3433853b6 17497:40540f9a63e20bfa ; 13212:4062ec2abcb56448 17696:404ffcd3433853b6
+first_over_time - 6101 -4144 25171 3047 17 22129 ; 2508:c08ebb6feca3e3b7 2731:405d9723451bccd7 3850:7ff8000000000001 4850:405a77d5f1709fb6 6871:408e32730529be05 9314:c08a9230061c0e88 25055:c0634d9d9009e6a8 25848:7ff8000000000001 ; 25171:c0634d9d9009e6a8 28218:c0634d9d9009e6a8 31265:c0634d9d9009e6a8 34312:c0634d9d9009e6a8 37359:c0634d9d9009e6a8 40406:c0634d9d9009e6a8 43453:c0634d9d9009e6a8 46500:c0634d9d9009e6a8 49547:c0634d9d9009e6a8 52594:c0634d9d9009e6a8 55641:c0634d9d9009e6a8 58688:c0634d9d9009e6a8 61735:c0634d9d9009e6a8 64782:c0634d9d9009e6a8 67829:c0634d9d9009e6a8 70876:c0634d9d9009e6a8 73923:c0634d9d9009e6a8
+first_over_time - 2457 0 14880 1225 10 5675 ; 9507:4081e4d5774ce1bf 10691:408a0f78ea3bb0c9 23438:7ff0000000000000 24557:40800b7443c45704 26201:7ff0000000000000 29086:c057c354e3a84536 29742:407882efbc12a486 30191:408bb02acd9c7e5f 32552:7ff8000000000001 33776:408e7bb7555ff030 34616:c08ec5bcf9fc783b ; 
+first_over_time - 3978 3324 18494 3977 2 ; 14395:404b61dfae6fca74 15477:404b85d911bc5581 17032:404e568eb6cfd24c 19043:40513024b42239b9 21948:40537552696b6d51 ; 18494:404b61dfae6fca74 22471:404b85d911bc5581
+first_over_time - 821 -5241 17346 407 18 23631 ; 16483:41e007d9fac0cea4 17416:4225f9d88500bf50 18620:41dbcff281ee7674 18816:3fd0cf4d1855018e 20843:c1ea8f2625349258 22869:c16aed8cc078f521 ; 
+first_over_time - 14498 -305 15689 3475 16 ; 9069:7e37e43c8800759c 10332:7e37e43c8800759c 11383:7e37e43c8800759c 13109:7e37e43c8800759c 13648:7e37e43c8800759c 15253:7e37e43c8800759c 17710:7e37e43c8800759c 18555:7e37e43c8800759c 20995:7e37e43c8800759c 22047:7e37e43c8800759c 22193:7e37e43c8800759c 22708:7e37e43c8800759c ; 15689:7e37e43c8800759c 19164:7e37e43c8800759c 22639:7e37e43c8800759c 26114:7e37e43c8800759c 29589:7e37e43c8800759c 33064:7e37e43c8800759c 36539:7e37e43c8800759c
+first_over_time - 5605 -9069 18690 2799 5 59663 ; 9020:7ff0000000000000 9661:40878d82ea0d5b7e 11653:c085acf8d51cc8b3 12422:c08e1c414bd749d4 14401:408b6cf4b9872e90 17017:405e24efda24f284 19946:c07c8c8b99faa3c9 22095:7e37e43c8800759c 23267:40802a9599208ea6 25842:7ff8000000000001 28121:408677998359969d 29740:4081f8ee7c3c778e 30560:408e5db3da2ad991 51439:408b0a1a4e633318 54417:4067039d634e091e 56834:fe37e43c8800759c 57350:4080da83123e0bb5 58566:40607d2bef6e9d6d 59393:c082ade63be96efc 61959:4023a1b2bc5991e6 ; 
+first_over_time - 1183 -3126 35728 1183 9 22181 ; 20262:7ff8000000000001 22857:408dc72db33ea83e 23612:7ff8000000000001 25945:c081a57acc315afe 27414:c06bb388a39d82c7 29197:7ff8000000000001 30656:c070c391f1512079 32646:7ff8000000000001 33695:c06b473243656374 35802:40886dc871510db3 36141:c07f6d189198b504 38163:406221a2611c7fde 39037:c08e591dcc0f481d 41471:c08ae97701b7b594 43177:407f1977e3587b2b ; 
+first_over_time - 6085 -5819 18544 3039 7 25026 ; 16224:7ff8000000000001 16570:c077d8ab5bba288b 32620:7ff8000000000001 35144:c077a41077116cd4 37603:c077a67f6fd64790 39135:407c16b43d6a727c 39965:7ff8000000000001 41887:c059a5a0f498e076 43002:40898877980af255 43744:7ff8000000000001 44869:7ff8000000000001 47644:c081f4794c1d0ed2 49215:408987ef123f42d4 50926:c07cec92b94ee661 ; 
+first_over_time - 1133 0 13674 563 20 ; 17827:40581f23ce7cecc8 19613:4060ca1b5238b44e 20006:406322d9de4d6757 20685:406763478833f504 22200:406be9ebe20728ba 23898:40179d54a668ceff 26461:4048cb5f94ffa459 27129:4051e730ffcfffbe 29316:40581b1ffa532274 ; 18178:40581f23ce7cecc8 18741:40581f23ce7cecc8 19867:4060ca1b5238b44e 20430:4060ca1b5238b44e 20993:406322d9de4d6757 21556:406763478833f504 22682:406be9ebe20728ba 23245:406be9ebe20728ba 24371:40179d54a668ceff
+first_over_time - 5901 7295 52619 2947 18 34598 ; 9555:40710a03ee4568db 15646:c04b1b7d598da5ea 15880:0 17371:7e37e43c8800759c 17646:c08af8ef7891f91b 18060:40865c496100f273 18119:7ff0000000000000 18568:c08e6a3269428049 20156:c0408ee15f06ef78 22808:c084ee9b39a5aabe 23159:408ae8ef07e6f554 23932:40682c11ab0b6ffe 26806:40887dbbb5d0cf83 28173:c079bee1db090d5e 30992:c051b8b5ff074a20 33603:406b452f49cd1b1e 34886:7e37e43c8800759c 52499:407f79fb814a26f3 53876:c079677f0cf4b512 54031:c05dd10bcb318c54 54352:c05402a314c9bff5 ; 52619:c084ee9b39a5aabe 55566:c084ee9b39a5aabe 58513:c084ee9b39a5aabe 61460:c084ee9b39a5aabe 64407:c084ee9b39a5aabe 67354:c084ee9b39a5aabe 70301:c084ee9b39a5aabe 73248:c084ee9b39a5aabe 76195:c084ee9b39a5aabe 79142:c084ee9b39a5aabe 82089:c084ee9b39a5aabe 85036:c084ee9b39a5aabe 87983:c084ee9b39a5aabe 90930:c084ee9b39a5aabe 93877:c084ee9b39a5aabe 96824:c084ee9b39a5aabe 99771:c084ee9b39a5aabe 102718:c084ee9b39a5aabe
+first_over_time - 1242 4766 38700 1241 8 88571 ; 19279:405245c53ba38472 21604:405299a7fb29faee 24018:4054728b434bf7e6 26320:405953233c6ac3ff 39797:40596d9cefd874ad 42609:40215b0f7d053939 42961:402ea3e552170e0e 43453:4042ae46d9ce30ce 46321:404e0f7920e83c48 47744:4053c029a5a6c6a2 50151:405db78271d48a1b 72521:405e755b8954fc62 72695:4062502adb7d776a 74327:406746bc482a297f 75624:406c8bcd5b211509 77138:4022d003caee2661 78495:40494097a2493e8b 93854:4056fb7b07a8bd12 96286:405deedc919d6544 98690:4020e395cb7846d1 98974:403663a1e66798b8 100648:403ded7fce8c7d97 103126:4052e73719fec899 105600:405e69c3b9806b92 ; 
+first_over_time - 4423 -9371 7369 2587 1 27165 ; 6834:c1869b0ccd7b670c 9061:c0878cce670ed8d9 9490:40507a905992d79d 11612:c16a67b0b76fb706 13168:407ebaa1e7f78b1e 15253:c214bff7c6363529 18060:40737e0c3d2d103a 18541:c27024b1f2d157e4 21534:c1e5eb86f9b0580d 21591:c14d2d164ca791c4 22130:407b0058d2948d88 22711:427413a07c76d77e 23024:c2a7966507320397 24714:4003571baf2f4fbf 27144:c01065a9149acbd2 28630:40e09764109812c2 31214:429b018f1786f323 32561:401117000d816a08 34997:c07042e4be2a976a ; 7369:401117000d816a08
+mad_over_time - 1761 0 29595 1760 6 27277 ; 9723:7ff0000000000000 10353:7ff0000000000000 11756:7ff0000000000000 14525:7ff0000000000000 15776:7ff0000000000000 16602:7ff0000000000002 17710:7ff0000000000000 18663:7ff0000000000000 37629:7ff0000000000000 39659:7ff0000000000000 41344:7ff0000000000000 ; 
+mad_over_time - 5411 7033 57656 2702 8 ; 20295:c08a3600545fdf30 20439:c0869bcacd008691 21094:4084cb4671c118c8 22014:c04abbba6c434cec 24020:4079ec3557ba98b1 24491:7ff8000000000001 24673:c08b093f932f3c05 25366:7ff8000000000001 44165:c08d5becbdcf3a38 47164:c06af9602146de13 49637:c07dd5fecb61f977 51313:408924f11c267f8a 52655:7ff8000000000001 73381:406c106e466e7630 76243:c086184cd015f9d5 77972:408be828114073dd 80927:c076ce4893897c26 81183:7ff8000000000001 81278:7ff8000000000001 84111:40863cce9fb31e07 86814:40755a057bb3c390 ; 57656:4060594ebabe8a6e 60358:7ff8000000000001 63060:7ff8000000000001
+mad_over_time - 2426 1310 10721 2425 15 ; 12952:411708db1b093d23 14229:c11b3f7dd74df3bf ; 15571:4119242c792b9871
+mad_over_time - 1000 580 9832 11 17 16521 ; 7404:c073d462aef61f5d 10113:408c1895fa071b25 11502:407fda56b2b6b9eb 12236:c066377f32566125 13044:406085229299f53e 14421:7ff8000000000001 14563:7ff8000000000001 16717:c08651dbfb4a3e2e 18641:408d0346adb31705 19575:408ccf4be4f2e332 ; 
+mad_over_time - 2154 0 5146 2154 10 ; 5802:40571606fc556719 7458:405c201ceead7a82 8993:405ce2f88650a362 9499:4061b346e9b29b0f ; 7300:0 9454:3ff85b72f4651c00 11608:0
+mad_over_time - 6107 -7208 16766 3050 20 ; 16003:c050f10d4d78809a 18343:0 18382:c089ab5e7ea6f48e 19003:404417297f8755fa 21349:c0690e0c90a1b7d9 23706:c086fd064d5e567b 25805:c08cee124f0c5380 27023:7ff8000000000001 28157:407c5e95932da035 29013:c08ad76048d8d549 31541:c0807f5776750615 ; 16766:406e13d6f0838d58 19816:7ff8000000000001 22866:7ff8000000000001 25916:7ff8000000000001 28966:0
+mad_over_time - 1000 -3942 24734 1354 3 ; 21359:c1502f42eeb764ec 23441:42ece2f42fe25180 24200:c186db55dd5701c6 26472:c1f27f5425f35501 28817:c013c3b658ded5fe 31214:c2411a6f4224f2bd 31635:40f12d84cce6642b 34583:c0139f29aa6adc62 35293:403d44fff55fd9b4 35974:407d724110fb665c 38393:c225fdbd8af250fd 38669:41a601be3cdb7a4b 47660:41ea98965e94bf6f 49384:40249394c566fa58 55720:4222358364b691ee 56806:c10e867a9861d877 58179:42f6f8e9751991b5 60733:41bcf36265fe4de2 60931:c14c9eafaa4f1929 61397:40b09146f6f4206b ; 27442:0
+mad_over_time - 1000 0 50164 3235 15 ; 15224:40601a79bdce1ba1 15370:4060fc4baca49812 17481:4062d4bc6dc24b85 19346:4065b382ec9acbc7 19470:40679287a417d714 37347:406ce0291d93646b 38859:407178ce9b4c117a 41011:4074364151441476 42783:407459a96da8ed56 45248:4077696228b87314 46658:407a32733afa4759 47816:7ff0000000000002 61532:3ff4069753b7d83c 61963:400783cb30a16e68 62175:4036ae1f82a0eac0 63147:4043cadb4996da3e 63812:404c1e0ac9053966 64867:405269e0ab1d2fe6 67109:405358ff1220d3b4 69529:4021b3d3a1fda7e4 69820:4021d5edba10dbd8 72176:403227f440f2e0c9 74904:404d28916c2bacda ; 63104:0 69574:0 72809:0
+mad_over_time - 743 5812 40651 743 19 46608 ; 19722:4057062231cff56f 21664:4059a0d99b079321 22614:405d0567d37bf14e 24810:40629d4d9a490104 26422:40689c7ef008d763 28047:7ff0000000000002 29019:406b39dd0aada43d 30323:40703f5ae5815652 33253:4072e87c024278ef 34976:4073fb80d98b8218 35850:4074fc18f44ab866 37435:4077c114153ba419 39719:407a27edf6e465f2 40766:407b7f54283c2dfa 42020:407bf4286fd066f7 43766:407c5ba565649281 45971:407e1de36059d976 ; 40651:0 41394:0 42137:0 42880:0 43623:0 44366:0 45109:0 45852:0 46595:0 47338:0 48081:0 48824:0 49567:0 50310:0 51053:0 51796:0 52539:0 53282:0 54025:0
+mad_over_time - 3644 5862 10276 3644 3 ; 11082:430c6bf5263402eb 12313:430c6bf526340289 15183:430c6bf5263402a6 16771:430c6bf5263401ae 17198:7ff0000000000002 17332:430c6bf526340189 19446:430c6bf5263402be 21179:430c6bf526340195 23637:430c6bf526340178 24014:430c6bf5263401b0 24091:430c6bf5263401c4 26574:430c6bf526340171 28354:430c6bf526340266 29744:430c6bf5263400ec 31703:430c6bf5263400f0 32384:430c6bf526340209 ; 17564:0
+mad_over_time - 2181 5185 18938 1087 11 58157 ; 9455:c088696382c8745e 9683:c085fbc81e3ee826 31326:4068b2e6bb238c19 33915:407cc9c69d78d25b 36050:404c4fe52ee69dc6 36457:7ff0000000000002 38264:c08e187c4feb012f 40712:4060a29e6bcfab6a 42279:c07fdc13c1e5e53d 42299:7ff8000000000001 44647:c0662526e90406f1 45513:c08513ce804ab862 48390:407da0ceaa8339da 51288:7ff8000000000001 52306:40629f76de95fc3c 55233:c07bb22db26b560a 55257:c06bfe383c308182 56388:404b23077e7d629e 57676:7ff8000000000001 59370:c0547362bd4e500c 60083:408a27440cb8cae5 61690:7ff8000000000001 ; 18938:7ff8000000000001 20025:7ff8000000000001 21112:7ff8000000000001 22199:7ff8000000000001 23286:7ff8000000000001 24373:7ff8000000000001 25460:7ff8000000000001 26547:7ff8000000000001 27634:7ff8000000000001 28721:7ff8000000000001 29808:7ff8000000000001
+mad_over_time - 3130 0 56780 3287 20 ; 18974:4080a49335847cf3 20759:c084fcae11f499c2 22653:4061b0f7122f1ed4 25427:c08ceb145990995d 26592:4087fb0695c74570 26892:407954c1fb89f31e 27829:408a0260f44da23f 30378:7ff8000000000001 32826:c07f593f241285a0 35179:c06aff5ea65b5668 36640:c084211ae7152472 37375:7ff8000000000001 38914:c087c948203e4cfe 41665:c0891942f0a72726 43129:c07ea2480ca18032 44493:c08a28b280ca8c0b 44937:7ff8000000000001 46954:c08626dceeaa6c91 48262:c05843da015fdc9b 50211:40815178b8acf185 50339:403cb9966ba5dc32 50811:c0876f06169c6276 52291:7ff0000000000002 54808:c067e32a8b69d8ec 57080:4082017828746b9f ; 56780:0 60067:0
+mad_over_time - 1190 -8714 15626 1190 11 ; 8512:40812192977ecae8 10885:c0787cbc30826880 13484:7ff8000000000001 15842:405f1457be8dbdec 17032:4066431e4a8be592 17112:40719284a172e117 19875:7ff8000000000001 22735:c07cc02397e4d61f 23703:7ff8000000000001 26426:7ff8000000000001 27499:7ff8000000000001 ; 15626:7ff8000000000001 18006:7ff8000000000001 19196:7ff8000000000001
+mad_over_time - 937 -769 7910 465 19 5378 ; 8985:fe37e43c8800759c 9089:fe37e43c8800759c 10864:fe37e43c8800759c ; 
+mad_over_time - 7109 -3272 -2304 3551 3 3183 ; 975:407dc3de623225c3 1416:408be325e112e66d 2975:404001ee7c45c688 5086:408b6a27572c8381 ; -2304:406a026d5ff3a718 1247:406a026d5ff3a718 4798:406a026d5ff3a718
+mad_over_time - 1227 -307 36696 610 3 ; 20619:7ff8000000000001 21427:40754d1bca4b3ed6 22145:40357c44ad23e6b0 22385:c07d190e84e47220 22501:c0822ff5422fcd8b 23809:4072ed111f7a5335 26237:c084e75dc2e89948 27839:407ff0f502e1ae90 30693:40854865e3acfdc6 33587:c08dddd05017d65c 36449:7ff8000000000001 37763:7ff8000000000001 ; 36696:7ff8000000000001 37306:7ff8000000000001 37916:7ff8000000000001
+mad_over_time - 1000 0 22380 1181 3 ; 5501:c07030731d90f7ed 5541:7ff8000000000001 8410:408ac5d50c1aec89 9041:c081e393adc11cb4 10912:c08ddfec8f944dea 10982:c08a4348ab342979 12962:408b452872910b11 13799:7ff8000000000001 13994:407f87a4520e0353 14838:40897cc6b631ca3e 16089:408db13f078b9127 18321:c07f79fa97fee5d8 20526:4080e7f02d55d38d 22399:c08b80d19e3a2a2a 31037:7ff8000000000001 31871:408279254371efe1 33865:c075a31633893496 35431:c08f12295cee1da1 36555:408c9e403c5c3f8b 37486:406185812ea69fa8 39027:7ff8000000000001 ; 
+mad_over_time - 1000 0 26238 2350 7 ; 19555:405a4fe2c6741f9b 19590:40627d0e1e29f83f 19892:4064b56799713916 19923:406679039ecf59de 20604:406b23ae2318c5b6 21509:406d6b26bd4b2cfe 23862:406e96f73d338801 25709:3fb91fda2cd8a620 27996:4039adc9c2cd02c0 29878:40495ffdcb50fa2f ; 26238:0 28588:0
+mad_over_time - 2427 0 47496 2427 6 35643 ; 20513:40470585063af357 21911:4050d209f92ca1f4 24824:40534a0c04c6063a 27813:405d676900cf98d8 48781:40647bda9a2746eb 50864:4068aab5d56f79b5 52298:406adbc83cf4d103 52466:406fa11a72135044 54934:40709c7347020793 57388:3ffd12048321a479 70824:7ff0000000000002 72460:403cd0afa1aaed47 73958:405388dc56aba7cd 74163:40595506bddd124b 76022:406037aff36889b7 77799:4011e01269569b56 78270:40490c9061f1175a 80786:40584de920e71962 83154:405f7fd4eabd4276 83876:4065148c9ca2f7c2 84341:4066f6a4fdcf2032 85666:4069e399aebfec6b 87813:4020ea7cae6fe157 ; 
+mad_over_time - 19193 -368 16755 3979 12 12414 ; 12668:7ff0000000000000 13676:7ff0000000000000 15904:7ff0000000000000 18306:7ff0000000000000 19670:7ff0000000000000 ; 16755:7ff8000000000000 20734:7ff8000000000000 24713:7ff8000000000000 28692:7ff8000000000000 32671:7ff8000000000000 36650:7ff8000000000000 40629:7ff8000000000000 44608:7ff8000000000000 48587:7ff8000000000000 52566:7ff8000000000000 56545:7ff8000000000000 60524:7ff8000000000000
+mad_over_time - 4143 6996 71145 3334 15 83019 ; 10797:407c62cd74ab7344 29896:c08180002c01183a 32869:c07f9928d54591ff 34463:7ff8000000000001 35650:c062b72e4857e773 36535:4051dbd8768516c9 37918:4087359ffeaf2c36 40079:c028e022aeaf04d2 41954:c07fc49062b26b98 44183:40616b8381d11eb7 47064:c07b1aae33fd271b 47351:c0697799ffa48180 49067:c06305e9b453952f 49131:7ff8000000000001 50321:c0889d2c7a104613 52120:c087cd92f096ac41 54932:408c7673e7afa0ff 75535:7ff8000000000001 76727:c07476a02606e76d 78485:7ff8000000000001 79797:40442fede1d19820 81384:c08295c67c34adcd 82044:c0702cecafa55180 84236:7ff8000000000001 ; 71145:7ff8000000000001 74479:7ff8000000000001 77813:7ff8000000000001 81147:7ff8000000000001 84481:7ff8000000000001 87815:7ff8000000000001 91149:7ff8000000000001 94483:7ff8000000000001 97817:7ff8000000000001 101151:7ff8000000000001 104485:7ff8000000000001 107819:7ff8000000000001 111153:7ff8000000000001 114487:7ff8000000000001 117821:7ff8000000000001
+mad_over_time - 419 1699 23384 418 18 35651 ; 17204:c07e110269d7c652 20176:c0845ea28b96eaf2 21320:c0864aaca2315beb 22561:c0661e9f3018444c 23277:c08eae54997b9ccc 25643:408d345a793e073a 26536:c0814544172bb9af 29439:c077b6e0a0c3cf61 30645:fff0000000000000 32411:c07fe3362328e392 34537:4077ee0e421745c3 34730:7ff0000000000002 36506:0 37207:c049a26a1a4490b2 39429:c08a9615df5bf409 40755:c089b0d0cef2c8d0 ; 
+mad_over_time - 8658 0 16996 2397 10 20075 ; 9925:40497c6cb21b4a8e 12436:4049b9028eae31b3 12701:40583a2017f007a8 15214:402160188242e6cc 17761:40304d1fa49ffd5e 17918:7ff0000000000002 18901:403b014025dcb20a 20802:4040a84ebb12edc9 23483:4047b71622cb0e43 26094:404b6f5a78ee4c12 27704:40090cdf05a1510c 28012:402678e63af739b3 29236:4048be1ddb13892a 30045:404f5f11988f9482 31408:405457db17ab4a53 33208:3fdd26b8d30bc050 ; 16996:40325133e4bb3ea4 19393:40325133e4bb3ea4 21790:40325133e4bb3ea4 24187:40325133e4bb3ea4 26584:40325133e4bb3ea4 28981:40325133e4bb3ea4 31378:40325133e4bb3ea4 33775:40325133e4bb3ea4 36172:40325133e4bb3ea4 38569:40325133e4bb3ea4
+mad_over_time - 3378 0 7886 3378 17 ; 11210:40781afaa105bf3c 13745:c0810a18697d2164 16532:c0801a9328ce87b6 16738:c08eaed6923e54eb 19576:7ff8000000000001 ; 11264:0 14642:0 18020:406d2886d2df9a6a 21398:7ff8000000000001
+mad_over_time - 209 0 42655 101 14 ; 19967:4088877fa2daa585 22636:c05ff0a77321bd60 23692:c074ab4ab419b387 25799:404c6dfa43eb93cb 28493:c08453fe09251862 29856:408999428cf572f4 30611:7ff8000000000001 33111:c082fcdfc3e95cae 36003:c01cf1c6b1d18e96 36599:402836fd989fc100 38096:c0585e2f0653df82 38762:fff0000000000000 38843:c08b6032e8a263d3 39787:c07cd0aac8bd9e4d 41414:c065bd83b5fa7e7b 42929:40686205e4bee566 57058:4063f5de8629aef8 59618:407219dea9f6d41a 59889:0 60589:c08a34f6d211d3dc ; 42958:0 43059:0
+mad_over_time - 1000 0 20244 1160 1 41798 ; 5550:c085876c37e3ddb3 5906:408a70f77809b819 25740:c0814d3e4a72b807 27125:0 28468:c087e66c8d1c2c11 28635:7ff8000000000001 29884:7ff0000000000002 30172:408e29460ed91c91 32977:4088ff8f032fb778 33514:0 35681:8000000000000000 36690:7ff8000000000001 39036:8000000000000000 40550:406b3f381d1731a5 40703:4089821534273e58 43165:4061ddedc0fc90e6 ; 
+mad_over_time - 1000 -696 27911 1080 1 ; 20645:4034c248a24fc2f3 20791:4023818cab84d0a8 20885:41d08c0171edae5d 21248:c299feb588069d79 23826:c242205db0b59883 25729:42e964a9ef888f7a 26841:4286ed113fa41179 29285:c0dddfbce29c3e12 30080:4243fdd376856503 32487:3fbb20fa6e927ad0 34009:c28d165078cb0806 36757:41310298fee6b2a4 38549:4152d49aea10750d 41167:429a1b38570679e7 44162:c28240e3283eadcc 45890:7ff0000000000002 47394:3feda55f244aa47a 48387:c039abb6ba8671eb 50807:c0a209d59fd9ed71 ; 
+mad_over_time - 13969 6597 11041 3672 17 18467 ; 5131:c0863f6af75579d7 6768:406a4127744fed34 9124:40727c5f010640b1 9295:c0822b75986fe033 10919:7ff8000000000001 13290:408777278dc78706 13401:c0635557f1c02be7 16036:c080f90c561c60aa 17067:c0515785a74e7db6 18862:40567c1344bf8349 18888:4084fcb7afb84429 30535:406178e26723505e 30830:406961384624d707 31797:c07403e9913dfc57 34445:407ce78d8325b33f 35869:7ff0000000000002 38539:c08bff5c9f29203f 39127:c077e2708dcca210 ; 11041:7ff8000000000001 14713:7ff8000000000001 18385:7ff8000000000001 22057:7ff8000000000001 25729:7ff8000000000001 29401:7ff8000000000001 33073:7ff8000000000001 36745:7ff8000000000001 40417:7ff8000000000001 44089:7ff8000000000001 47761:7ff8000000000001 51433:7ff8000000000001 55105:7ff8000000000001 58777:7ff8000000000001 62449:7ff8000000000001 66121:7ff8000000000001 69793:7ff8000000000001
+mad_over_time - 1391 0 18084 1390 17 6552 ; 9672:430c6bf5263402a9 12264:430c6bf526340223 13203:430c6bf5263402b2 13490:430c6bf5263402ae 13829:430c6bf526340093 14626:430c6bf5263402ae 14857:430c6bf52634010a 15262:430c6bf52634010e 15364:430c6bf526340110 17882:430c6bf526340234 18563:430c6bf526340118 19058:430c6bf52634009a 19840:430c6bf52634002c 20014:430c6bf526340024 22145:430c6bf526340317 ; 
+mad_over_time - 908 6237 25555 907 1 ; 5017:8000000000000000 15745:8000000000000000 18176:8000000000000000 19196:8000000000000000 21385:8000000000000000 24225:8000000000000000 25668:8000000000000000 26998:8000000000000000 29764:8000000000000000 ; 25555:0
+mad_over_time - 1000 0 17648 22 11 ; 10381:407b051b4a59f7c7 13336:4055e0967778ae39 18975:4004019faed0bd54 20137:7ff8000000000001 20804:7ff8000000000001 22821:40837636beb02645 23631:406e37e18c2e6e8c 24486:c0486a74fbbded22 27300:407f39d742b704a2 29186:7ff8000000000001 31215:4076e5a1d95306da 33982:7ff8000000000001 34046:7ff8000000000001 36761:c08e10acb69603c7 38154:7ff8000000000001 39556:c08e01e95f873259 40407:7ff8000000000001 41281:4082b0dd71d82983 42071:c06f5145088e47c0 43354:408e7f9c2170808d ; 
+mad_over_time - 1000 -1692 13078 713 11 13113 ; 7683:4060c2660da2cf3f 9467:406425886b854d96 12298:40657c8c29a7fa89 13708:4066ebda509c874e 15079:406b6d588582d905 17259:406d51e63eccd95c 19440:406d6713c561266c 19490:40702683f9f33320 21770:4072d7533d1851f5 22569:4073d3e0376634b1 25381:40740af2921f43be 27976:4076e60335559bb0 29941:407919fc1dbbccfa ; 
+mad_over_time - 862 0 22630 862 8 40307 ; 12305:fe37e43c8800759c 14059:fe37e43c8800759c 16257:fe37e43c8800759c 17106:fe37e43c8800759c 18534:fe37e43c8800759c 21518:fe37e43c8800759c 21941:fe37e43c8800759c 22052:fe37e43c8800759c 24928:fe37e43c8800759c 27273:fe37e43c8800759c 29716:fe37e43c8800759c 30145:fe37e43c8800759c 31909:fe37e43c8800759c 32321:fe37e43c8800759c 32355:fe37e43c8800759c 34645:fe37e43c8800759c 36933:fe37e43c8800759c 37430:fe37e43c8800759c 38976:fe37e43c8800759c 40970:fe37e43c8800759c 41336:fe37e43c8800759c 42033:fe37e43c8800759c 42968:fe37e43c8800759c 45038:fe37e43c8800759c 47555:fe37e43c8800759c ; 
+mad_over_time - 3021 0 10133 2225 9 ; 9142:430c6bf5263401fe 9434:430c6bf526340214 10008:430c6bf5263401d8 12471:7ff0000000000002 12727:430c6bf52634014a ; 10133:4006000000000000 12358:400e000000000000 14583:0
+mad_over_time - 1000 0 36347 3818 8 ; 29180:40b2004ffcbaa679 32005:c213be06954860e5 32879:c072cd396ec6a3f7 33844:42a3a239b9617413 35389:c097bffc544f88ef 44264:409077994c56ec5c 45743:c047f8a3a675f624 45974:40a18b809a4ef6a7 48691:40750e1abb3ba7f0 49574:c1e9d7f834680883 52063:c0e6bf23ab506c71 52576:42c4b720f36026bf 53115:c100590666a592ba 54807:c1fedf477bfa6d5e 55383:413a080ebf749d4d 58180:c0f9b03ff8ceaf69 60194:41cf70ed1b8f463c 62184:c258ce5f90229cee 64986:c0dd99957b6b7d20 66245:c223881a6ec0d979 68299:42be96fcf0a0372a 69466:41daf1a882ef22b7 70964:42187a12fb07b837 72228:4187d77a0953444e 74570:c1eb82f17adbbf30 ; 36347:0 55437:41eee0e7fce664a8 63073:0
+mad_over_time - 189 1526 4652 188 7 ; 6823:408cea991012abce 9112:40706f9e2554f57e 9253:c05f72607bd2d1b7 11726:c06a4cf1ec2af316 12508:c0833568354f15c6 ; 
+mad_over_time - 8883 0 8663 1200 14 18270 ; 9119:430c6bf52634015e 11842:430c6bf526340067 12329:430c6bf5263400e0 12732:430c6bf5263401f0 15529:430c6bf5263401a2 15987:430c6bf52634024a ; 8663:4035000000000000 9863:4035000000000000 11063:4035000000000000 12263:4035000000000000 13463:4035000000000000 14663:4035000000000000 15863:4035000000000000 17063:4035000000000000 18263:4035000000000000 19463:4035000000000000 20663:4035000000000000 21863:4035000000000000 23063:4035000000000000 24263:4035000000000000
+mad_over_time - 2403 2959 3008 2403 2 ; 7965:c14fc5af15388a05 10771:c0b228b8ada995c3 ; 
+mad_over_time - 1000 0 7506 2834 11 9092 ; 10572:41abd9a2ea27f393 12331:c1700b612c739ee5 14065:4173f80a2082a98b 14544:4151efe5e8c09240 16404:c0e5b3847b418f47 17721:42407efebd883e51 18025:41af1188f803fe45 18640:42dfb23bd240563c 20624:414e7f522a2114af 22882:42b7bae972da4a4f 25029:40f9472148a275b8 26481:c0e277953ba0099e 28609:c1435ccf39fe15f3 ; 
+mad_over_time - 318 0 10855 318 4 17049 ; 13985:41116cc731c9385a 14754:40987e51efddbe3c 17512:41644fca24457f4b 20289:c10bafec9a253caa 23250:c119ba28fc076255 24590:c02912599a380d12 24786:c2e5ae5b85cf9ff7 27387:4070607e96205cbc ; 
+ts_of_first_over_time - 473 -3405 1786 472 18 ; 2476:c081709db0b9a1b9 3551:40846e32666d42ab 3940:40797b62e1bfa9b9 6628:40652ed8a83171c6 9377:c088e8f9ddbf6d3f 9813:c079b48a4fb070d7 10702:40885202eda81e14 13320:0 14626:c071fd592ac569dc 17010:c08a57c94aa45234 17654:fff0000000000000 20451:c08001d90fb89e89 23415:c05377e96b2a72cd 24668:fe37e43c8800759c 25075:4078c295af09d6c8 25079:c0792f0aa4e2a8d9 ; 3674:401a83126e978d50 6034:4022c10624dd2f1b 6506:4023a04189374bc7 7450:4025676c8b439581
+ts_of_first_over_time - 4604 0 454 45 10 0 ; 2573:c0711c5e86318845 7608:c053d00f5cd6509b ; 
+ts_of_first_over_time - 7397 0 5043 3695 7 7468 ; 4252:42ba2e4a0af84b89 6087:bfaf336b7dc62a70 8038:424ff53886dbc0bd 8331:c25aa0bdfdc0918a 8415:c064e23ef9530bde 9292:4187a9ce0ce6cd99 11785:c2c12d2cf997b09f ; 5043:4011020c49ba5e35 8738:4011020c49ba5e35 12433:4011020c49ba5e35 16128:4011020c49ba5e35 19823:4011020c49ba5e35 23518:4011020c49ba5e35 27213:4011020c49ba5e35
+ts_of_first_over_time - 6955 -3744 7605 3474 5 ; 10227:3fd83c5e59dc6bb0 11848:4027bcb35255b3cc 13046:403eebd9df50f176 15518:404d1d897c3f76c4 18158:4023313143f3cdde 19133:4045f8d1b6ded5a4 19707:405617e412e6f02a 21514:405ae06f5ca352ee 23460:40613a0453e43a96 25999:4066408028c16b1d 26312:40666e6ea897a8b6 26496:406b4c1852976ee8 28840:406d9fb2a049345b 31831:406f9f7fad427cca 34750:7ff0000000000002 45527:4071d26cc9b7c0f5 46563:40723a31863525a4 47176:4072c229e3cbe8e3 49097:4074c82a3fc0b9be 49611:4076abb507260723 ; 7605:402474395810624e 11079:402474395810624e 14553:4027b22d0e560419 18027:402f09374bc6a7f0 21501:4033220c49ba5e35
+ts_of_first_over_time - 793 0 18824 792 18 ; 13920:7ff0000000000002 16504:430c6bf5263402eb 17772:430c6bf526340293 19259:430c6bf52634031c 20808:430c6bf5263402e2 21239:430c6bf526340004 24211:430c6bf526340283 25493:430c6bf52634026b 26586:430c6bf52634027b 29492:7ff0000000000002 30086:430c6bf52634028a 30564:430c6bf5263401f5 31065:430c6bf5263401c1 ; 19616:4033424dd2f1a9fc 21200:4034ced916872b02 21992:40353d2f1a9fbe77 24368:40383604189374bc 25952:40397e353f7ced91 26744:403a9604189374bc 30704:403e1604189374bc 31496:403f10a3d70a3d71
+ts_of_first_over_time - 4661 4343 17167 2327 16 ; 5860:c183bddd564840db 6402:c1eefdfafff455c0 6524:7ff0000000000002 8735:c28e3948386c8a5e 10200:c03d7354ad62862f 10314:c0a83839818cb3c9 12244:c2239529c5e51c1e 14673:c2a30375a5ceb78c 15082:42491d38204b4e95 15245:4111425691df7d2a 17033:40486b434a8c6c43 19509:400acb44b571085e 19539:c0d82ddb19a5729d 21854:c180ea593f7ea85b 22420:41504c556f33b739 24119:40a26f1d0df10bc9 24779:c1e3aaaed64efb07 25434:417fbcdbddf93914 27985:c124113340717ad1 28886:3fa18265d43c4840 30573:c1751cc76f5d3533 36271:c177ece96db8c5ec ; 17167:40217851eb851eb8 19494:40287ced916872b0 21821:402d589374bc6a7f 24148:402e7d70a3d70a3d 26475:4033824dd2f1a9fc 28802:4035da9fbe76c8b4 31129:40366b851eb851ec 33456:4038c76c8b439581 35783:403bfc28f5c28f5c 38110:403e92b020c49ba6 42764:404222b020c49ba6 45091:404222b020c49ba6
+ts_of_first_over_time - 7139 -729 6742 3566 19 22080 ; 8628:fe37e43c8800759c 8631:40565e8146d52a96 9676:c071f1094ff55d5d 10380:40875ea6e4922f49 12616:40738c589ff08260 14460:406eabc73cef4d35 17108:408995486e45b72b ; 6742:40311ba5e353f7cf 10308:40311ba5e353f7cf 13874:40311ba5e353f7cf 17440:40311ba5e353f7cf 21006:40311ba5e353f7cf 24572:40311ba5e353f7cf 28138:40311ba5e353f7cf 31704:40311ba5e353f7cf 35270:40311ba5e353f7cf 38836:40311ba5e353f7cf 42402:40311ba5e353f7cf 45968:40311ba5e353f7cf 49534:40311ba5e353f7cf 53100:40311ba5e353f7cf 56666:40311ba5e353f7cf 60232:40311ba5e353f7cf 63798:40311ba5e353f7cf 67364:40311ba5e353f7cf 70930:40311ba5e353f7cf
+ts_of_first_over_time - 1000 0 63582 148 3 52352 ; 7376:c064d5bc421eac21 9595:c06e17c7a136b61a 10587:407750ae00999f12 12106:4060e2b3cdff3a18 12390:c07b3344421f6c38 14203:406c7195027d61d1 15713:40576aac42ef1343 16374:4086bf0c0fbdda5d 17189:c063a63a4c79888c 20115:c08002cc3d0a5062 20916:c060c0f72cd308e8 40394:4078dec57adf7a25 41657:7ff0000000000002 42391:4059732b6a1c8b71 45088:c05b9c7103d3fbed 47664:c079876d3e4c8045 48293:407783433f3f667c 51126:4081980f711808e8 52842:c0435da38840806e 75502:c088ee7b377ca3ef 76423:c0899526e85f314d 79206:40756af4c92ad8fe 80044:c084266b4d0a2a8e 80479:7e37e43c8800759c ; 
+ts_of_first_over_time - 4991 4746 12625 2492 1 17645 ; 9493:4058ab6d58d0de32 10926:40592f5d79580a4b 11773:405f68510cf7e6fe 13176:7ff0000000000002 ; 12625:4022fc6a7ef9db23
+ts_of_first_over_time - 524 -3205 7670 523 6 ; 12251:4070bf8414bbae9b 12913:c15d1e7656ce6bd5 14754:4018c200e017e25e 17738:411c40314c4373a7 19865:4233b4ffe97486cb 21527:7ff0000000000002 21601:421e0e8131500c1b 41234:c284b6c283fd8d33 42444:c14aeeaba294426e ; 9239:40288083126e978d 9762:4029d374bc6a7efa
+ts_of_first_over_time - 1000 3895 28979 1537 1 ; 16460:c08a3d9d5381547f 19146:c08a82577a2fd413 19157:c089e33fa710f2ec 19218:7ff0000000000002 19618:7ff8000000000001 21844:c0407a1841f7bcb8 23697:40811bd1c09dcba5 25925:4070565fc3dbfafd 26721:7ff8000000000001 26837:40673a442795aa07 29507:4064cf75c7cec691 30075:7ff8000000000001 32673:c066c6b8830bf2a0 34288:4088f0259b1c79d7 35551:c0735e946ba8a2e6 38402:c06aa2795a1143d4 40709:c08c62db4cc568c5 ; 
+ts_of_first_over_time - 478 -2514 8335 477 9 ; 2959:c07e51a73ee9a8c9 3459:408bf677f1c455f1 5476:4050cb2ed8db9c09 8241:c07b1571d9fdf87f 10389:c0778cdcc7a175e1 11403:c05e0a76b911c4bd 13496:c07eb6cb33777feb 15462:407074b1de90c19a 17684:4088e78adc590874 18477:c085c5b5769748bc 19492:406c1364014fffbe 19575:4074539dc7a59f6e 21162:4080d8b8899c084c 21493:7ff8000000000001 21994:c0818bb6499ab193 24671:407aaa277de8fa90 25504:c07188880c0cd967 ; 8335:4024c72b020c49ba 9289:4026ce5604189375 11197:402afdf3b645a1cb
+ts_of_first_over_time - 1000 -2091 12977 633 12 21384 ; 8102:430c6bf5263402be 10144:430c6bf5263400e0 11423:430c6bf52634001d 11456:430c6bf526340208 11652:430c6bf5263402c6 12009:430c6bf52634016a 12115:430c6bf526340215 14599:430c6bf526340104 16982:430c6bf52634022d 17440:430c6bf5263400c8 ; 
+ts_of_first_over_time - 3130 2052 4577 3130 10 ; 4994:403fb121cbde0c22 5985:404d685783506e9a 7018:7ff0000000000002 8060:405a48b64b627b1e 8374:4061df250676bbeb ; 7707:4013f9db22d0e560 10837:4017f0a3d70a3d71
+ts_of_first_over_time - 19145 4832 20670 812 16 ; 14571:c0852a6912799f0a 15889:7ff0000000000002 18656:408da45a85428e6c 20310:40759923277abe6e 21400:fe37e43c8800759c 21418:4081e29a666c50c3 21426:40878a51b36cf8af 23525:c08e962fca534289 24524:c0864133e2ceaa65 26727:40831b99306c560e 27879:c085cc66eb23a609 28206:c05527546d1dfabc 30630:405ec4a1ba88c177 30993:4063bce021baa00d 33357:c07ab4ce355d7303 35954:404a6a81118d1256 ; 20670:402d245a1cac0831 21482:402d245a1cac0831 22294:402d245a1cac0831 23106:402d245a1cac0831 23918:402d245a1cac0831 24730:402d245a1cac0831 25542:402d245a1cac0831 26354:402d245a1cac0831 27166:402d245a1cac0831 27978:402d245a1cac0831 28790:402d245a1cac0831 29602:402d245a1cac0831 30414:402d245a1cac0831 31226:402d245a1cac0831 32038:402d245a1cac0831 32850:402d245a1cac0831
+ts_of_first_over_time - 3253 -5775 26939 1623 11 38505 ; 18838:7ff8000000000001 19300:407118c49280e63f 20818:c081958c99d50792 22682:7ff8000000000001 24251:c07a902e2a86218c 25797:405c265b3db195ac 26517:c08ac80b37d5aee9 29276:c07160775883fc69 29940:c06ee435955f87cc 31891:c089e0f253a1b32d 32495:7ff0000000000002 35033:7ff8000000000001 35131:c0872c0992b78866 37843:40725c9b3560d955 38301:c070dc9b7d6c057d 41138:4070191b42721f0b 42706:40890ba123c898c1 ; 26939:404491a9fbe76c8b 28562:404491a9fbe76c8b 30185:404491a9fbe76c8b 31808:404491a9fbe76c8b 33431:404491a9fbe76c8b 35054:404491a9fbe76c8b 36677:404491a9fbe76c8b 38300:404491a9fbe76c8b 39923:404491a9fbe76c8b 41546:404491a9fbe76c8b 43169:404491a9fbe76c8b
+ts_of_first_over_time - 1000 576 18601 2097 13 19614 ; 18513:405bf6be89aee3fc 19159:4061ce2fb3e02f07 ; 18601:40328353f7ced917 20698:40328353f7ced917 22795:40328353f7ced917 24892:40328353f7ced917 26989:40328353f7ced917 29086:40328353f7ced917 31183:40328353f7ced917 33280:40328353f7ced917 35377:40328353f7ced917 37474:40328353f7ced917 39571:40328353f7ced917 41668:40328353f7ced917 43765:40328353f7ced917
+ts_of_first_over_time - 6119 1528 17831 3056 20 ; 19240:c22158c8b6665818 19459:4180ff61103e0d7d 20150:40ac9f1204e9e340 20376:c2669a13b48b91e2 21510:c0640116a5983d37 21520:40e546fcbb26d956 22227:c1a484eb5445a085 24388:c17a51521c874b2a 25659:c23adbd09388929d ; 20887:40333d70a3d70a3d 23943:40333d70a3d70a3d 26999:403375810624dd2f 30055:40386353f7ced917 33111:4039a8b439581062
+ts_of_first_over_time - 15927 0 2927 408 4 8735 ; 2468:7ff0000000000000 3082:7ff0000000000000 4094:7ff0000000000000 6258:7ff0000000000000 ; 2927:4003be76c8b43958 3335:4003be76c8b43958 3743:4003be76c8b43958 4151:4003be76c8b43958
+ts_of_first_over_time - 15953 -5115 34250 2945 5 ; 11051:405814c34059a6c5 27412:405fd35bca6834ad 29186:40658c4f328b2dbb 31809:7ff0000000000002 32211:40660fbbfc087e1d 35066:4068d849f9f05dff 35528:406b4124615ed5ac 53934:406cb35727e7efd2 53947:40700481e05c96f0 56382:4019e4b100290d9b 57158:403f0e5caecb9059 57826:404fc8ec35db67c2 58303:40583f743e995368 60673:405c515f5b890527 ; 34250:403b6978d4fdf3b6 37195:403b6978d4fdf3b6 40140:40401b020c49ba5e 43085:40418872b020c49c 46030:4041c395810624dd
+ts_of_first_over_time - 1000 -2615 11692 2958 13 ; 16219:c08d7c47688713c6 18128:c08cd09a12ebc247 20055:40840f571ff3c403 20700:7ff8000000000001 21406:c08d7cd094a70f60 23746:4059f9beae8b6061 25278:4079ac0e80fc0cbc 28210:408d22bb3b78dad8 28381:405fead01e6c206c 29848:4073f4d86d45b8ca 32364:c063a49ee786b26b 34874:7ff8000000000001 36544:40879dc2de667aa1 37975:c07742f31d55fd95 38290:407364acb5e43cd4 ; 17608:40340e147ae147ae 23524:4039472b020c49ba 26482:403c35c28f5c28f6 32398:40416fdf3b645a1d
+ts_of_first_over_time - 7143 5280 29355 3568 13 ; 16334:406e9053b87cb0bd 19096:40868cd842ade8f5 20606:7ff8000000000001 21313:c088fdd40193ca06 24141:40822557485c9905 24683:c07dbae1123281b6 27476:c07d9f4687d03156 29046:4089c62f7a3caa6c 30247:4083ab1d4ede483e 31735:7ff8000000000001 33803:c076c2d3f703a829 ; 29355:4033189374bc6a7f 32923:40349b22d0e56042 36491:403824189374bc6a 40059:403d0bc6a7ef9db2 43627:403fbc28f5c28f5c
+ts_of_first_over_time - 6175 9166 25247 2124 9 ; 29357:fff0000000000000 30661:fff0000000000000 31611:fff0000000000000 34493:fff0000000000000 36007:fff0000000000000 37387:fff0000000000000 39198:fff0000000000000 40946:fff0000000000000 43431:fff0000000000000 46027:fff0000000000000 48689:fff0000000000000 51333:fff0000000000000 51394:fff0000000000000 53408:fff0000000000000 54841:fff0000000000000 55056:fff0000000000000 56172:fff0000000000000 56305:fff0000000000000 58109:fff0000000000000 ; 40115:403d5b645a1cac08 42239:403d5b645a1cac08
+ts_of_first_over_time - 1000 -8595 13798 580 17 ; 15140:c08218fc046a8225 15452:7ff8000000000001 17755:c0642c2e991b586b 18230:40816dd3897ff08f ; 
+ts_of_first_over_time - 437 0 6076 437 12 8280 ; 3305:c084d02d2923b529 5657:4070c076e4b31537 6359:c07871684163464c 9223:405d17a35c65d58d ; 
+ts_of_first_over_time - 85 -305 11036 85 3 ; 6246:fe37e43c8800759c 9110:fe37e43c8800759c 9200:fe37e43c8800759c 10446:fe37e43c8800759c 12562:fe37e43c8800759c 13720:fe37e43c8800759c 34563:fe37e43c8800759c 36916:fe37e43c8800759c 37782:fe37e43c8800759c 40549:7ff0000000000002 43040:fe37e43c8800759c 43142:fe37e43c8800759c 43697:fe37e43c8800759c 43745:fe37e43c8800759c 45382:fe37e43c8800759c 48289:fe37e43c8800759c 49324:fe37e43c8800759c 57849:fe37e43c8800759c 60127:fe37e43c8800759c 60419:fe37e43c8800759c 61038:fe37e43c8800759c 62043:fe37e43c8800759c 62909:fe37e43c8800759c 63122:7ff0000000000002 64335:fe37e43c8800759c ; 
+ts_of_first_over_time - 4035 -3132 7614 3386 1 ; 6292:430c6bf526340061 6723:430c6bf526340141 7801:430c6bf52634011e ; 7614:401ae45a1cac0831
+ts_of_first_over_time - 11024 0 10214 531 1 ; 13029:406044b35291d450 13388:406382999c441219 14057:4063d212627dfd34 34060:4065c4a0417b8d78 34098:406b8d8b46642678 35617:406fec60278dfaa9 37076:407242d9df1f3f64 37094:40744a6052453aa1 ; 
+ts_of_first_over_time - 158 0 71924 157 14 ; 10106:7ff0000000000000 10719:7ff0000000000000 12576:7ff0000000000000 12862:7ff0000000000000 15737:7ff0000000000000 16094:7ff0000000000000 17246:7ff0000000000000 19360:7ff0000000000000 20200:7ff0000000000000 22497:7ff0000000000000 22558:7ff0000000000000 22688:7ff0000000000000 24322:7ff0000000000000 46310:7ff0000000000000 49273:7ff0000000000000 50648:7ff0000000000000 53011:7ff0000000000000 53945:7ff0000000000000 55866:7ff0000000000000 77831:7ff0000000000000 ; 
+ts_of_first_over_time - 3314 2509 2057 1493 16 ; 2091:4073d832548627ac 2104:c08d057ede9ea011 3859:7ff0000000000002 5470:c072bb90d914eb8e 8011:4065ddbca7435af4 8345:c07767606073f3ea 8987:c0893f7283e9a250 11539:408b753c2a79b79d 13167:c04b31c423c4c412 14564:c08e08fd2a1e6221 16114:40804d209d62a97d 26134:40813fbbd35e4e8f ; 5043:4000ba5e353f7cee 6536:4000ba5e353f7cee 8029:4015e147ae147ae1 9522:4015e147ae147ae1 11015:4015e147ae147ae1 12508:402005a1cac08312 14001:4020b0a3d70a3d71 15494:402713f7ced91687 16987:402713f7ced91687 18480:402a55810624dd2f 19973:402d20c49ba5e354 21466:40301d2f1a9fbe77
+ts_of_first_over_time - 7701 -2866 10133 1695 8 7543 ; 5557:408cec9618a7647e 7025:fe37e43c8800759c 9442:c0865af1a7afa5e5 12034:40871bbb61e1af25 13220:c08b63e2e53a8e8b 15803:c08bbaac6d6103f4 17646:7e37e43c8800759c 19959:408c4bf88ab67324 21228:c0811331387e9a17 22730:7ff0000000000002 24032:bfec3b876418eff0 24957:408cd8243497e3f4 25567:c08e37ef75186e2c ; 10133:40163a5e353f7cee 11828:40163a5e353f7cee 13523:40163a5e353f7cee 15218:40163a5e353f7cee 16913:40163a5e353f7cee 18608:40163a5e353f7cee 20303:40163a5e353f7cee 21998:40163a5e353f7cee
+ts_of_first_over_time - 4981 0 49513 2487 1 ; 17409:4085fd881d5862b3 20258:7ff0000000000002 21923:404ce93a1449af02 22259:4083052297cb410c 23719:c083574dcb495ea6 24180:407e3c9f67790755 24724:406c5aea93b565d1 27564:408eeafed6e4d1dc 46434:c08f004bc1a09b84 49144:c081e09da7960f80 49587:407a9475037a8e8e 51507:c07b4c6a8ded9ecb 53692:406802b2bbdff6a7 54293:7ff8000000000001 55656:8000000000000000 ; 49513:4047378d4fdf3b64
+ts_of_first_over_time - 2290 0 18293 2290 5 12087 ; 16498:c0807f062948910c 17383:406279a8cd531418 17881:c04545096f632571 18501:408c2f88ed143497 19424:407d8a1b57d93329 20619:c0681dcf90547350 20941:405f560fde96f0a5 ; 
+ts_of_first_over_time - 1238 -1434 19836 1238 16 ; 11000:7ff0000000000000 11021:7ff0000000000000 11219:7ff0000000000000 12863:7ff0000000000000 14903:7ff0000000000000 16766:7ff0000000000000 18619:7ff0000000000000 21588:7ff0000000000000 21735:7ff0000000000000 ; 21074:403596872b020c4a
+ts_of_first_over_time - 1105 0 23807 549 6 ; 21519:c07bde3027dbc509 21544:7e37e43c8800759c 24508:4064185dbd970bbf ; 24905:4038820c49ba5e35 25454:4038820c49ba5e35
+ts_of_first_over_time - 1000 -2450 50146 766 19 ; 9330:c08c15ebff29ba66 9492:4065f03b6a855a7c 10721:4074d9a76fe22486 29089:4075f664e9d52dd8 30053:408afa08981791eb 31716:408699c074022400 33774:c08d3671bc638728 34265:7ff0000000000002 37035:c05778353e215116 39795:c08de4856f0617e4 40801:c075bc92728e6bc9 41605:c078f4daff32ee90 44206:c08036525242465b 45814:c0885e2fe0eeaca5 65007:c055f30ca14f3836 67448:c06a20dfe5ac021e 68516:c06371a75fc12b9b 70402:40847066ee91dbf6 89008:40626544aecf0962 89977:c0857ddb52f8597a ; 63168:40504072b020c49c
+ts_of_first_over_time - 5671 0 33988 2832 20 23629 ; 14015:c079a973bfb89cfa 14376:405dfa95cb8408e0 16761:c07f76e1bd4e7178 19017:4071df87e4938b6b 20118:fff0000000000000 22026:c08554c90f1cf14b 22049:c08adce0a59ac989 22307:c0771a5e10e58ded 24796:40619d8dc71707df 26104:c0740631d6716e6c 27209:407f3c65f43bbb37 28187:408aec35850ca6c4 30372:c07c4e639bebdb53 33156:40862d112d076317 33961:c08540e744060eef 35408:4086203726c16b4e ; 33988:4033045a1cac0831 36820:4033045a1cac0831 39652:4033045a1cac0831 42484:4033045a1cac0831 45316:4033045a1cac0831 48148:4033045a1cac0831 50980:4033045a1cac0831 53812:4033045a1cac0831 56644:4033045a1cac0831 59476:4033045a1cac0831 62308:4033045a1cac0831 65140:4033045a1cac0831 67972:4033045a1cac0831 70804:4033045a1cac0831 73636:4033045a1cac0831 76468:4033045a1cac0831 79300:4033045a1cac0831 82132:4033045a1cac0831 84964:4033045a1cac0831 87796:4033045a1cac0831
+ts_of_first_over_time - 1000 7398 49705 1895 6 70146 ; 1736:c06622448623d9d2 3144:c03992a0946ed14a 4561:407e3954adc376a7 7397:7ff8000000000001 8217:407f4d414a76240d 10199:40771f20171bdb8e 10910:402248aa727cb25e 31935:c072ba0c0c64f258 34166:c021c869a665684d 35477:407ee5a3b167bafd 37337:4079909862c10428 37632:408b2764a981255d 40072:405bce5c55c70c58 42020:c08794d47b688974 44053:c089ba8241701418 45075:c05824c9919f08ff 46613:c08e8c0bfd5057c2 47777:408e0d075727c1ea 68221:408c20838414e994 70655:7ff8000000000001 ; 
+ts_of_first_over_time - 651 -4827 5839 322 1 ; 9915:c07e313d819838a4 12649:408923c1c6b9fc65 15354:c065b06b5c152943 17847:40719e8ce49b883a 27417:408f2c9ea06d47fa 27904:40572385236944d6 30549:c0782a8f10da353a 31831:40699cea713468c4 32787:407ec54b16ab3f30 33911:7ff8000000000001 34338:c07e5ba30f413638 34801:c088ad13207710b0 36314:40831fbcd6635000 ; 
+ts_of_first_over_time - 76 0 43313 75 13 14984 ; 9443:404340f1d1713bc3 12256:404c233e383c9f59 14225:4053e654c82a3258 17009:4059c6aa81f59fa7 19746:405dc7708a9927f2 20793:400b510defe30488 22938:403e916c443cc131 25371:4053bee790b11596 26242:4058b347455cb38a 26917:40624633793fab08 29372:406379093c2bbbd6 31807:4065055621ce71ab 33185:4065b4286c5d5f16 36004:40698f3ab6381a1a 38313:406aee7886195d7a 40818:406fdedf6021a80f 42673:40720b1cac4a38b9 45043:4072fde709515ff0 48010:40752a5e95ba67dd 50516:407556f33bfb4587 51234:40776ffcf5200925 52839:407a852b14ec2932 ; 
+ts_of_last_over_time - 1000 0 3305 1247 16 17917 ; 2348:7ff8000000000001 4976:c080dae449bf7517 6841:406a3fcef97db3a7 7788:c08d622306ecd282 9870:0 11858:408d7a2965b57000 33022:c0643f35c7b96968 ; 
+ts_of_last_over_time - 2513 -1607 31285 2512 20 ; 10841:40627640f691f960 11633:c06c2019a8335478 12564:4087fa5604871df2 13580:40511b0ee6c1180b 13926:c082335856461557 16007:408e20d5c716e87e 17665:c0880ba5f5d036c1 20652:4087d1dfdfb5ef4d 21362:4083cd80d1015f5f 21703:407aadfe920feae7 23822:c06c466b1872b3d0 26154:7ff8000000000001 26971:c08ccb0d9e9ada92 27719:c080538741729450 29698:7ff8000000000001 31597:7ff0000000000002 32289:4045f12687f3619e 33582:4085d5f34e512616 35606:c08dc2ecfc5c0e36 35649:c08a2ccb47f4e2a1 35859:7ff0000000000002 37698:7ff8000000000001 38865:4088fa03dbe8f606 39051:4088f17fe2cfb0c9 39760:7ff8000000000001 ; 31285:404024fdf3b645a2 33797:4040ca7ef9db22d1 36309:4042d95810624dd3 38821:4043e147ae147ae1
+ts_of_last_over_time - 2916 674 15510 2916 3 ; 13117:7ff0000000000002 14908:430c6bf526340121 15992:430c6bf526340002 16228:430c6bf5263400eb 17826:430c6bf5263400d7 19820:430c6bf526340112 21208:430c6bf526340088 22927:7ff0000000000002 24079:430c6bf526340259 26523:430c6bf526340084 ; 18426:40303a5e353f7cee 21342:4033d1eb851eb852
+ts_of_last_over_time - 18242 -8487 62576 3720 16 15828 ; 18719:42de7ec376ac8443 42403:41852d8dd68fc1ac 42791:41a247fae4f76fed 44435:4170988d666cd156 54863:4258ba50f4a3a7bf 57638:c073aab0adef2c9d 58268:419e5ecca31645c3 59940:4248a7d0abff1c26 60807:c2b1eb5c9590d064 61237:4121039ea1fecb17 62742:428c4d6a42b54ba0 ; 62576:4032b810624dd2f2 66296:4032b810624dd2f2 70016:4032b810624dd2f2 73736:4032b810624dd2f2 77456:4032b810624dd2f2 81176:4032b810624dd2f2 84896:4032b810624dd2f2 88616:4032b810624dd2f2 92336:4032b810624dd2f2 96056:4032b810624dd2f2 99776:4032b810624dd2f2 103496:4032b810624dd2f2 107216:4032b810624dd2f2 110936:4032b810624dd2f2 114656:4032b810624dd2f2 118376:4032b810624dd2f2
+ts_of_last_over_time - 2161 0 19770 811 7 858 ; 4592:405fb87a7b69e6eb 7012:7ff0000000000002 7605:406215ae88d280d1 9000:406792998a43af57 11530:406cf2f762bde153 14276:4070124e7da85267 15450:4070ca9891bc6f69 16237:407304befafdc6e2 18306:4074c04a07ddcd48 19479:40770933180da988 21666:4077a8d807f3e7af 22033:40791f70e1d6d638 ; 
+ts_of_last_over_time - 183 6037 41429 183 20 ; 12243:4059c693c1eb4a17 12642:405d23f29bb2d1a6 15616:40613dad27ee3597 16087:406193a00528c3bf 18162:4067b3a688666de9 19880:4069129e5955b5eb 22433:406957ecb8a6e292 22575:406c72ec4dd06e0e 23762:401e92e389a6fa63 25279:403994015778f000 25489:404d0e8e0927e77c 27630:7ff0000000000002 27761:405aa7c50a3744a8 28353:405be96f9e1eb100 30335:406005aa75e8ef76 31429:4023d2c498402ea2 42317:40474a2d4a356490 42683:40476de05891e632 42700:40232675940e0ddc 43444:4046502bc9359b8f 44650:40482def3b7a9189 47237:4057e797342cf320 48633:3ff52c7a14fdffb0 50654:4043725b051b0ad0 ; 
+ts_of_last_over_time - 1547 6214 14948 1546 17 17145 ; 15288:fe37e43c8800759c 17488:fe37e43c8800759c 17737:fe37e43c8800759c 18717:fe37e43c8800759c 18914:fe37e43c8800759c ; 
+ts_of_last_over_time - 1000 3924 10772 3475 12 ; 13698:c11a4c413979567e 14129:4184d57daebb0c0c 15125:c1147b2483eecc2d 15920:7ff0000000000002 17745:40d9f2f7bde44f48 18290:3fb245bd807e70d8 21288:4213ae69d9135ac9 23243:7ff0000000000002 24410:bfd745d65a070b41 26296:413eca0ce8a31ce1 ; 17722:402b65604189374c
+ts_of_last_over_time - 1000 -1716 17833 3503 14 ; 10624:405ab2f708075e38 11032:40633a0aceda3ae7 11129:4067a94a19629566 13035:406905ceee480116 15859:406bd81073573559 16477:7ff0000000000002 18920:4070e4e954eb36e3 21439:4072c61b8510dd49 23173:4075b9da689e080e 25323:407660438b9763f8 27115:40786edaf37186d7 29340:407afaebe2022e9e 31550:407b4b2826c9093d 34547:407b66cac23ea04e ; 17833:4032eb851eb851ec 28342:403d570a3d70a3d7
+ts_of_last_over_time - 3330 0 -2508 3329 10 22079 ; 2146:40872e44c540ef1c 3694:c05cc1b6a1bbb56d 4418:c084ca49f6594f7f 7047:7ff0000000000002 7947:c066aa09043d5bfd 10881:407e387d00199264 13550:407b5cfafc5f7dbd 15483:408e5bd6549ddb81 16967:c0668f575cbaefed 18898:408c04ca733e8d67 20117:c071b8c41e0c4b74 ; -2508:40341df3b645a1cb 821:40341df3b645a1cb 4150:40341df3b645a1cb 7479:40341df3b645a1cb 10808:40341df3b645a1cb 14137:40341df3b645a1cb 17466:40341df3b645a1cb 20795:40341df3b645a1cb 24124:40341df3b645a1cb 27453:40341df3b645a1cb
+ts_of_last_over_time - 416 0 4006 416 11 0 ; 1507:7ff0000000000002 1802:c0896d9d12e3bb0a 4586:40817b68b91cfe07 15118:408685076e4de757 ; 
+ts_of_last_over_time - 3024 4039 40281 271 13 ; 15237:c04414eb231505da 15314:42b8b78461d7fe8b 17176:40438bb6581ac80b 20089:416c707b8e06385a 38654:c030500397640bbc 41161:c167786cdc31df29 46551:c230e72fc6dd4cad 47061:c05c7da0d4c92681 47764:c163f6d2af5c8621 50362:c0a26ac46035e2ca 50587:c0aa1076f9d911d0 52534:40a63249acc3e927 52760:411e32bf5675e64d 53551:4115215e276ebadc 54881:bfeadaecba9970c2 56831:c22d79b3bb650af7 59407:40e609cf1b56a0d4 60934:3fd93f55aeef151a ; 42720:404353b645a1cac1 42991:404353b645a1cac1 43262:404353b645a1cac1 43533:404353b645a1cac1
+ts_of_last_over_time - 3208 -1475 52624 3207 14 ; 16171:c069ea9815b3208d 16359:c08313d55ee94dd5 17993:c07ac16d4a85c5da 18643:40791bc9fafafe07 18790:c0835094b2a98edd 20670:407fc189813ae0b1 22670:c085a890e829a4bf 42286:406e1206f57781ef 47411:c08ca4ffa34773bd 48148:c086b3455fd832ab 48976:c0726594b11bd904 49143:c079c5e75a71b773 49567:4064cc8832a9890c 49817:c0660789778f6914 49898:7e37e43c8800759c 50290:c08aeb8d63ddde24 53271:40768166586292e7 54738:405bbf2ae9d55845 ; 52624:404aa2b020c49ba6 55831:404b5e76c8b43958
+ts_of_last_over_time - 3292 0 14287 3292 13 6076 ; 5154:c08a301ba2cfea63 5281:7ff0000000000002 7320:c057e7dde85d2820 8617:4053a83e89c9f948 9580:408bf043d6edc825 9784:c0449f8b49a87f28 12035:c08173c64830266f 14446:c079cfef2195b5bf ; 14287:40149db22d0e5604 17579:40149db22d0e5604 20871:40149db22d0e5604 24163:40149db22d0e5604 27455:40149db22d0e5604 30747:40149db22d0e5604 34039:40149db22d0e5604 37331:40149db22d0e5604 40623:40149db22d0e5604 43915:40149db22d0e5604 47207:40149db22d0e5604 50499:40149db22d0e5604 53791:40149db22d0e5604
+ts_of_last_over_time - 1409 1188 39188 1908 17 5746 ; 6485:c280f04d46c7ca12 7422:417e7a21692f9127 9628:bff0f5b61483440a 12626:c205613ff05d4212 15380:c2ddd02cd2a00e24 18214:c00dfb1805e9ba1e 18714:414e0e61a392b0dc 21288:c0480010d699347e 22712:c1ba176f65b9bd13 43569:42e15e2c6b40fbcb 44188:c2217ddb0834778c 44627:c0e41ff4710aee12 ; 
+ts_of_last_over_time - 6876 4803 3441 48 20 2425 ; 3200:430c6bf5263400db 5149:430c6bf526340083 ; 
+ts_of_last_over_time - 336 9262 27511 336 8 ; 19827:405f582c1dcc80a2 22143:4063c0fee09e72b4 24530:4065a8b28b2ff285 26189:4068961d06d64cf7 26936:406d849e4c1541e0 29063:4071cbb6b546048a 29688:4072b169c61dd83e 29762:4074fdb9c5ceecda 30718:4075dacb49586ee2 ; 29191:4033d3b645a1cac1
+ts_of_last_over_time - 121 0 19960 121 17 2677 ; 6147:c060be47aa8e9d1c 30396:c069b741e0263ec5 30409:4066875b1bb85bce 32045:407c71f818577b86 34447:fe37e43c8800759c 35501:c0758130102fd648 37876:4076475adde25075 39523:c08b06d203f1b166 42059:c046274cfdbd0750 42872:c082425ffbb9d068 45663:c08abd3b89edcfd0 48365:4089f552ac119b74 51125:4088a2597971e027 51528:c0855a533fae239a 53460:0 54463:c0721f7acb1b08b5 55704:402621269fd98873 58162:c080d1286d121082 59154:c086abc9e2e6fd59 59303:0 59540:408710ca1b090658 60545:c061326b5a2efde7 ; 
+ts_of_last_over_time - 1803 0 17887 1803 10 ; 14359:c081c8e662287ec8 15082:c064012348d6f925 18011:408e02e5ad0a3ec8 19502:40779cfaf6bb6202 21661:c07d995eb1172d16 23017:408bf4260e4e465c 23217:40827598687aa2fc 23685:c06562113022ee68 26472:408b6a06375f29c6 28859:c08b802e6efe8ad8 30467:c08c54f3c7e9456d 31634:4078dc325b2ccda4 34615:4085aed6cdda6bee 35693:4064211e19c02608 36931:408a063c56addd1f 39733:408d892d8a683982 40056:407c193d8703fd80 40806:c06e58f436a911d0 42201:c085445991fac7a6 42429:4076eb09fbe71810 44006:c08e2961306919ed 45339:4063a265399700db ; 19690:40338083126e978d 23296:4037378d4fdf3b64 25099:4037af5c28f5c28f 26902:403a78d4fdf3b646 30508:403e778d4fdf3b64 32311:403fa24dd2f1a9fc
+ts_of_last_over_time - 3329 -3231 1938 3143 10 ; 1667:430c6bf5263401d0 2348:430c6bf5263402b2 2928:7ff0000000000002 ; 1938:4002c8b439581062
+ts_of_last_over_time - 1174 5572 27710 1174 4 62764 ; 17793:c08abcb277393620 18440:7e37e43c8800759c 18582:408854a428144fa9 39324:c08ac8de7946b01f 39342:4082ed0c6268674f 40784:c08d3fdf1b7d46e0 43398:4088cf3d9af8e61f 43912:c07bbe2df2cd328e 45227:403f4fc44b94fc36 45790:7e37e43c8800759c 45821:4088339079148974 46052:404f9ab748b88764 53886:c04762f5d8b884a3 56858:408a0a7e019ce670 59686:c0828c1ead484bf2 60257:fe37e43c8800759c 67544:408ecf5311fa618b ; 27710:404c6dd2f1a9fbe7 28884:404c6dd2f1a9fbe7 30058:404c6dd2f1a9fbe7 31232:404c6dd2f1a9fbe7
+ts_of_last_over_time - 19528 0 29960 1812 9 35296 ; 2650:3fcd7b1ed0e1c008 5509:c1f3168ed325a07c 5962:420009a08a1d30b7 15556:40d40230c434783d 17579:c2c17137e521f749 18487:407c2d34440dee8e 20410:c1c530ca61caf30b 22476:4267c596691515cb 23882:42839c6149a58960 26235:40428af8c9936813 27909:4077c8db98a69b27 28642:c28c17fa3f5dae81 30303:c2fc4567721c6a32 32854:c2c0706c145a90c6 33598:41d00422b33afa5b 34296:bfda871c676efacc ; 29960:404125e353f7ced9 31772:404125e353f7ced9 33584:404125e353f7ced9 35396:404125e353f7ced9 37208:404125e353f7ced9 39020:404125e353f7ced9 40832:404125e353f7ced9 42644:404125e353f7ced9 44456:404125e353f7ced9
+ts_of_last_over_time - 3924 0 19343 3923 5 ; 17916:430c6bf52634006f 20379:430c6bf526340045 22920:430c6bf526340034 25069:430c6bf526340162 26101:430c6bf52634031b 28931:430c6bf52634027a 29490:430c6bf5263401e1 42442:430c6bf526340163 43457:430c6bf526340280 45235:430c6bf52634017d 46340:430c6bf5263401d6 48605:430c6bf52634018e 50948:430c6bf5263402df 53407:430c6bf526340091 55221:430c6bf526340125 55615:430c6bf526340156 57068:430c6bf5263402f2 57134:430c6bf5263400fb 58959:430c6bf52634011a 59679:430c6bf52634014c 60824:430c6bf526340206 62368:430c6bf5263400b0 64714:430c6bf526340231 ; 19343:4031ea7ef9db22d1 23266:4036eb851eb851ec 27189:403a19db22d0e560 31112:403d7d70a3d70a3d
+ts_of_last_over_time - 2070 -7975 16745 2070 2 ; 8956:fff0000000000000 10228:fff0000000000000 10547:fff0000000000000 10630:fff0000000000000 22816:fff0000000000000 24918:fff0000000000000 27162:fff0000000000000 28947:fff0000000000000 30118:fff0000000000000 30400:fff0000000000000 31197:fff0000000000000 ; 16745:4036d0e560418937 18815:4038eb020c49ba5e
+ts_of_last_over_time - 1000 1948 20190 2743 4 12321 ; 13694:4088cbe147723326 16433:40697593bd8776aa 17488:c0850751363257ca 18164:408bcfed6b577dd9 21060:c07ae183f191c914 ; 
+ts_of_last_over_time - 4181 0 19294 2087 10 ; 12693:40768029880dc2c9 14130:c08a001e27cf19cb 16014:405713b31aa803ae 18541:408dc0b4173899ce 19114:408cf7b2db6e2269 21249:4081994fcda42149 22951:407221bd8a4c8ae5 25652:c082019c70ca64ce 26760:c039424ee8e95b7d 28956:c06ad3e014dd9c76 31584:c073e121607658bf ; 19294:40331d2f1a9fbe77 21381:40353fbe76c8b439 23468:4036f374bc6a7efa 25555:4036f374bc6a7efa 27642:403ac28f5c28f5c3 29729:403cf4bc6a7ef9db 31816:403f95810624dd2f 33903:403f95810624dd2f
+ts_of_last_over_time - 18901 0 12839 3178 17 ; 15674:4044dd684682dc68 17804:404a1bfba4e8011b 20167:4052631e49c7557b 22696:40588be7b3a57ea0 ; 16017:402f5916872b020c 19195:4031cdd2f1a9fbe7 22373:40342ac083126e98 25551:4036b22d0e560419 28729:4036b22d0e560419 31907:4036b22d0e560419 35085:4036b22d0e560419 38263:4036b22d0e560419 41441:4036b22d0e560419
+ts_of_last_over_time - 6955 7575 30138 3474 4 44752 ; 25891:4051e3f84b2eecb0 26207:4057e360afdbae6e 28274:7ff0000000000002 29686:4060b310eabab698 30362:4061227b9993435b 31505:40673e81f44e0b8a 32215:40683c1796cc8112 32855:40104f4ae2336c2d 34705:4043cf80fcdc681e 35710:401aa5f6d46bf855 36772:7ff0000000000002 39433:4035bce7fffd6e4a 41449:403677ed313c28af 44378:404a2827e180ff3a 47084:40536c59537391d6 49765:405b29d58625d1b9 52061:40048108e285af6d 52153:401cd6f4ca443f0c 52770:4032dbd22a292222 54601:4014d219cb234625 56408:4024249ae4d240fc ; 30138:4041dae147ae147b 33612:4041dae147ae147b 37086:4041dae147ae147b 40560:4041dae147ae147b
+ts_of_last_over_time - 2470 -203 54726 2469 4 40214 ; 18655:c0606c546db29c16 21576:403a2f4dc7b1616f 24064:7ff0000000000002 24277:c05f55850d6a329a 25682:c23b060a0f075ff6 25826:411bd739970db154 26863:c1f0bfba3e314397 28904:c21a003daa85da71 30266:40a6d600082f73df 33038:403b5a33c4870b63 35074:bfa51236f8ffc090 41450:41cfc89262bff1ce 41683:4288bc07190c6952 65409:c274b61a000976ca ; 
+ts_of_last_over_time - 1000 6852 46221 54 10 55331 ; 34070:c20283da2da8069f 34668:404342b92aa403bf 36172:4213e1d1d04992ae 37260:40a77bcd03173f7c 38006:7ff0000000000002 39307:c2f5193bbbc53a35 39336:c2064ef28b890d09 41480:c0d051453d4d5800 43880:41bc499c1b6a3e62 45808:7ff0000000000002 48530:bfc2580ed164cfd4 63769:7ff0000000000002 65567:42136413bf95f2ad 66481:42082d1c0696facf 67713:4258fe26850a1967 68545:c1638e51604c8c84 70410:c096fe60ea748c8f 70665:c11ec5a946205b5c 71758:4029a79f42cd6c6e 74203:c0ae931186938f79 76261:c0a06d5c35b52c20 79057:c1873bdf31d45ec2 81487:c0e295497af2afb2 ; 
+ts_of_last_over_time - 327 -8225 6559 326 20 12706 ; 10763:7ff8000000000001 12376:4087b8ce8c97f32d 14156:4082bb8501c6ba2b ; 
+ts_of_last_over_time - 17399 1017 5856 3593 15 ; 7655:7ff8000000000001 8895:7ff8000000000001 9296:7ff0000000000002 9433:7ff8000000000001 9575:7ff8000000000001 9617:7ff8000000000001 10964:7ff8000000000001 ; 9449:401e9eb851eb851f 13042:4025ed916872b021 16635:4025ed916872b021 20228:4025ed916872b021 23821:4025ed916872b021 27414:4025ed916872b021
+ts_of_last_over_time - 1000 0 19620 245 14 ; 4954:c0819fc943e9d4f0 7760:c08cd50325c3f5d3 9864:408cb947000b506e 29856:408872ade0b49703 32345:c061de7844929077 34140:c08c01b11dd2e3b0 35852:c089c91d9994c855 ; 
+ts_of_last_over_time - 19907 9522 19616 3044 2 ; 20133:fff0000000000000 22334:fff0000000000000 ; 
+ts_of_last_over_time - 1820 -9629 23883 1819 9 9043 ; 12755:7e37e43c8800759c 13026:4074efd4f43a0a36 15205:c06cd18541f68997 16864:4067012ad76be092 19470:c086ea660b9733e1 21709:c06d57bcff8495a8 22205:7ff0000000000002 22234:408604fd664712a1 24256:c062ed1912fce369 24346:4089f44332499d17 24477:406a9ec51f49fefe 25600:c076c3f840484fbc 28235:40846fc903e686ef 28968:408667de24346ade ; 23883:4030dd2f1a9fbe77 25702:4030dd2f1a9fbe77 27521:4030dd2f1a9fbe77 29340:4030dd2f1a9fbe77 31159:4030dd2f1a9fbe77 32978:4030dd2f1a9fbe77 34797:4030dd2f1a9fbe77 36616:4030dd2f1a9fbe77 38435:4030dd2f1a9fbe77
+ts_of_last_over_time - 1229 7310 27643 611 8 33358 ; 21864:4057619fbb371b1a 22017:c0812245571788ef 23324:c059a64999346fa0 25681:406f90c273ba26c9 28476:c07faac25fc9be68 30523:7ff0000000000002 32464:c07f7032a6fb13ed 34695:fe37e43c8800759c ; 27643:4039ae5604189375 28254:4039ae5604189375 28865:4039ae5604189375 29476:4039ae5604189375 30087:4039ae5604189375 30698:4039ae5604189375 31309:4039ae5604189375 31920:4039ae5604189375
+ts_of_last_over_time - 7381 0 17998 3687 15 ; 11746:430c6bf52634023a 14248:430c6bf52634017b 15013:430c6bf5263401f9 17023:430c6bf526340080 17426:430c6bf52634016c 17860:430c6bf526340140 19770:430c6bf526340068 ; 17998:4031dc28f5c28f5c 21685:4033c51eb851eb85 25372:4033c51eb851eb85
+ts_of_last_over_time - 1000 0 22288 1255 3 37645 ; 6613:c063abbfdf0b08ac 6663:407d5f9dc4ceab25 6773:403a27854bf0d3ce 6893:407f4588d6dbc1a8 7306:40750d38db7fccb7 8362:4079fc9160e020f9 8517:c07a02db745f5d62 10850:408412b6d260ca1c 13380:40819e1ab0097a40 16170:40573f3a4fd48be8 16912:c08451be6276125b 26548:c08817f8f1da3ed2 27786:408e226f23cc7688 30392:c085a58211e49435 30827:c041c46b3cd2d0bb 33622:4079dc9769c3d620 35969:c08820cb620b7ba3 38514:c0607df791a04cb0 41155:c068ee6c80b8830f 42199:4028d85fd11d423d 44710:c08cfe3fbcbc48ef ; 
+ts_of_last_over_time - 1000 0 34805 2593 11 30568 ; 4142:c0742e33a851b131 6525:4056da2397b021f9 7145:405459791be29471 9802:405022de6f59815f 10586:c08ca649fb7e8351 13441:408ab63b55c9ecd5 16061:407ad9d9fc4dd852 17107:c08cfc61f53a5d29 19820:c073844a1a7c9690 20723:408a0ad6b6cbce86 20823:4084489f55ead8ce 21242:408147f0459e529b 22423:7ff0000000000002 24788:40878ebd9847a9d6 26851:4070a82dcfd35ea3 29306:7ff0000000000000 30213:c08c32adeb144e12 53779:7e37e43c8800759c ; 34805:403e36872b020c4a 37398:403e36872b020c4a 39991:403e36872b020c4a 42584:403e36872b020c4a 45177:403e36872b020c4a 47770:403e36872b020c4a 50363:403e36872b020c4a 52956:403e36872b020c4a 55549:403e36872b020c4a 58142:403e36872b020c4a 60735:403e36872b020c4a
+ts_of_last_over_time - 1000 8129 12561 3893 19 10672 ; 14006:c2b945b21943c006 16398:41e6f9cdac5df67b 16784:3fbb08f7f32323d8 24876:c2e872742f69691c 27140:c14031d8e48c6bbb 28169:421a0b35ec08f608 ; 
+ts_of_min_over_time - 1000 0 10640 2543 20 8680 ; 9574:40348f5434569678 9695:40461c78a909c548 10576:40518bf96c09b916 12431:40546798ff51eeb2 ; 
+ts_of_min_over_time - 743 -9873 42140 368 13 74121 ; 11851:403b0d977cf3d75c 14152:403b261b2958b1c2 16845:4052eee38ec163f4 17378:4008361ae812211c 19563:404a3cf074033e64 19774:40522beed0679167 20798:7ff0000000000002 44377:405c9b84722af82c 46700:406146c4c768ecf1 46736:4063d32ac456ff5a 48824:40641f67203bd324 51255:406852073fe772db 51421:406ccc169f77fcbb 52642:406f63c4fbca434c 54527:40715e1f3f14c598 55351:40747a20019ae8bc 57523:4074ee4073647dca 58306:3ff96e312c44c395 78789:40259d8e15a103a9 ; 
+ts_of_min_over_time - 773 0 51480 772 7 ; 14884:c116952d4732ec4c 16578:42828e47d10d3024 17525:424d6779e62944d0 20072:4046272bf778a8ff 20395:c2c052223a27864c 21171:c1fcdf6498ca4706 21919:40cc1680760b911b 24914:c2913d4b1c46dc0c 25800:c1aa1ce1b8df7794 26652:c0c0a7926021040c 29058:411823597d26616f 38433:c1856bf04ef7b468 47566:40814e67cd514aa9 47803:42bc45db36a239c2 48424:c06245603750a8a1 48516:c18207dd15d0b31c 51135:41a43d158b9a6cc8 52392:403c8bfa2a2de204 55281:3ffe241ae186a676 ; 51480:40499147ae147ae1 53024:404a322d0e560419 55340:404ba3f7ced91687
+ts_of_min_over_time - 1000 4246 49119 2289 16 ; 5414:40529cb2f7b67684 5746:4058cff1a7dd615c 7018:405f943adbf187f0 24197:405fe38ea2caa2fe 25364:4023a93450a29bba 26500:4035a44e5a28f126 28677:404b22cc00457f10 29220:4057de218605d950 32034:405d12ebf456aaa3 32207:4062b1e58224d226 33815:40679f890b5a603c 49244:406b347b15a8dd8a 51111:406f700a768736b0 51611:4070bc584cb346bc ; 53697:40489f3b645a1cac 55986:40498e353f7ced91
+ts_of_min_over_time - 3721 -113 5497 3721 18 ; 5191:7ff8000000000001 7442:c0608a583aa8b0ec 8504:408c161e14cc4919 8878:c08e88a3fe47a5c9 10035:406f7b12981ed420 11235:c08deb4d32403010 12279:c08000d9b2617911 12610:c086e2000f1efae7 14595:408dab07842a3109 17253:40863f6479774ee1 18613:c0483f613439bcd5 21197:c06339531f2dd213 24035:7ff8000000000001 26241:c0811e55fc6736f7 27095:c08935259b5ab0ca 28626:c08a3026c64adb28 29794:c070d788310fd6db 30981:c0290937029ee3a6 32858:4073fa30feeb3699 33530:7ff8000000000001 34854:c070466d5b6392c3 35704:c07ab59b811df09c 36843:7ff8000000000001 55954:40650b44d2c26faf ; 5497:4014c395810624dd 9218:4021c189374bc6a8 12939:40267851eb851eb8 16660:402d30a3d70a3d71 20381:40329ced916872b0 24102:4035326e978d4fdf 27823:403b1851eb851eb8 31544:403ca04189374bc7 35265:40416d4fdf3b645a 38986:4041da1cac083127 57591:404bfa1cac083127
+ts_of_min_over_time - 2306 -9062 70505 2305 6 69786 ; 12826:405140527835b83e 15181:40559ae43983ff62 17875:401f259e80159817 41382:403ef2ea99edb77f 43617:404c763af9c2acfb 45865:40570ba3181c1886 46094:405fb5c464006097 48459:406131e7551685e0 50289:406596bee0e6daaf 51072:4069bc46997056dd 53574:406e463c3cf35016 53832:4071b9ba388de789 70901:4074aa62d3f1bae4 73539:40752652f39ba31c 74562:4075c5656a80514f 75137:40771b89e0d57ab0 77456:40781200f7e7c127 78756:407899d780084b73 80661:407908795062ae96 82495:4079d383a68d2e64 83077:407a376e831b661a 84071:407ac4c4e7e6b325 84180:407d091a3abd64a0 86064:407e8e7487c32f9f 87016:4080d4b3f9eefc63 ; 70505:40535d2f1a9fbe77 72810:40535d2f1a9fbe77 75115:40535d2f1a9fbe77 77420:40535d2f1a9fbe77 79725:40535d2f1a9fbe77 82030:40535d2f1a9fbe77
+ts_of_min_over_time - 2603 120 29622 2602 3 ; 19948:430c6bf52634027b 20508:430c6bf52634030b 22394:430c6bf526340093 24665:430c6bf526340137 26300:430c6bf526340069 26828:430c6bf52634023b 29501:430c6bf526340009 31827:430c6bf526340225 34225:430c6bf5263400d8 35105:430c6bf52634013d 36068:430c6bf52634010c 36642:430c6bf526340287 38626:430c6bf52634018b 39068:430c6bf5263400b2 41760:430c6bf526340311 42095:430c6bf5263402a9 43206:430c6bf5263402df ; 29622:403d804189374bc7 32224:403fd3b645a1cac1 34826:40411ccccccccccd
+ts_of_min_over_time - 997 0 800 997 18 ; 4631:405f07608afce792 5541:405f74f45f7b4f2b 7003:40610be9b4933fcd 8020:40644e6332e4d2ce 9690:4066500341b9888c ; 4788:40128624dd2f1aa0 5785:401629fbe76c8b44 7779:401c03126e978d50 8776:40200a3d70a3d70a 9773:40236147ae147ae1
+ts_of_min_over_time - 1000 0 29504 2553 9 29906 ; 11770:40061d1888af42ee 13118:7ff0000000000002 13426:c0138a1eb6d37e20 13526:c10527208420e878 15867:4184deb437564cb1 18378:40c22dd42ee5ca7b 19537:42d038a2a5769822 20221:c075da8ff24500ab 22848:42c533a52d633a68 24636:4131a493a894f5c0 25545:4006e4d45b246878 26428:411331314a1ae712 26664:4043a4198c52e14d 28932:c0903cbfc9ab5f21 29716:3fc5afd24c0fd7a0 30763:c21ae311885eaae9 30789:c2ecc6b2c302b53b 33405:bfc4d6cacc1ff648 34365:c2b218268992c298 35222:c03d6c0ef71c4d88 37392:7ff0000000000002 37428:42b20581fa164d92 37705:4170fcd0df5207da 38371:4073c964bf0ccbe0 38537:3fd88088fbb0b4c4 ; 29504:403cee978d4fdf3b 32057:403cee978d4fdf3b 34610:403cee978d4fdf3b 37163:403cee978d4fdf3b 39716:403cee978d4fdf3b 42269:403cee978d4fdf3b 44822:403cee978d4fdf3b 47375:403cee978d4fdf3b 49928:403cee978d4fdf3b
+ts_of_min_over_time - 18663 3399 25375 1117 8 26355 ; 30207:430c6bf526340129 32738:430c6bf5263401ba 33540:430c6bf5263402cc 35277:430c6bf5263401fd 36500:430c6bf52634002e 36806:430c6bf52634031b 38390:430c6bf5263402d1 40735:430c6bf52634004d 43060:430c6bf526340022 43856:430c6bf526340142 45943:430c6bf526340261 47243:430c6bf5263402bc 49236:430c6bf52634006a 50320:430c6bf52634008e 50555:430c6bf526340206 52882:430c6bf52634009f 55248:430c6bf52634028c 57380:430c6bf5263400a8 ; 
+ts_of_min_over_time - 15490 7181 32213 1135 1 ; 2675:430c6bf5263402d1 5522:430c6bf5263400b7 6016:430c6bf526340301 6633:430c6bf5263402cd 7840:430c6bf526340048 10703:430c6bf5263401bb 13356:430c6bf526340198 15649:430c6bf526340269 16219:430c6bf526340051 18058:430c6bf526340029 19326:430c6bf5263400a6 19853:430c6bf5263402db 21240:430c6bf526340222 23070:430c6bf5263401fc 23426:430c6bf526340086 24905:430c6bf52634009f 26636:430c6bf52634010f 26831:430c6bf526340295 27753:430c6bf526340080 30587:430c6bf5263402f7 33542:430c6bf52634019e ; 32213:40320ed916872b02
+ts_of_min_over_time - 3476 6835 45816 3475 7 53109 ; 7482:430c6bf5263400bf 8713:430c6bf5263401d0 10097:7ff0000000000002 11534:430c6bf526340087 13068:430c6bf52634001d 13936:430c6bf5263400d2 16207:7ff0000000000002 36887:430c6bf5263400ab 37081:430c6bf5263402eb 38171:430c6bf5263401bd 39226:430c6bf5263401e9 41493:430c6bf5263401b2 43311:430c6bf52634002b 67516:430c6bf526340099 70467:430c6bf52634011a 71785:430c6bf526340272 71874:430c6bf526340132 73483:430c6bf526340203 74756:430c6bf5263402d5 76633:430c6bf5263402ac 76894:430c6bf526340274 78340:430c6bf5263402cb ; 45816:4045a7ced916872b 49291:4045a7ced916872b 52766:4045a7ced916872b 56241:4045a7ced916872b 59716:4045a7ced916872b 63191:4045a7ced916872b 66666:4045a7ced916872b
+ts_of_min_over_time - 18882 0 14212 3405 5 ; 9375:430c6bf5263401d9 10124:430c6bf5263401ea 12361:430c6bf526340178 14586:430c6bf526340312 15815:430c6bf5263402df 15944:430c6bf5263400d3 16421:430c6bf5263402b0 18022:430c6bf526340068 19902:430c6bf526340164 21803:430c6bf526340243 22492:430c6bf526340277 24434:430c6bf526340108 25150:430c6bf52634030b ; 14212:4028b8d4fdf3b646 17617:402fe353f7ced917 21022:403205a1cac08312 24427:403205a1cac08312 27832:403205a1cac08312
+ts_of_min_over_time - 17040 0 18611 3286 11 ; 18016:c0493e6c1ff02c9a 19615:40852fc022355d1a ; 18611:403204189374bc6a 21897:403204189374bc6a 25183:403204189374bc6a 28469:403204189374bc6a 31755:403204189374bc6a 35041:403204189374bc6a
+ts_of_min_over_time - 9114 -7736 22103 1316 11 26453 ; 24134:405da7dc2419108a 26418:405e86452f5bf0de 26963:405fccc38ef5019e 28865:400207785dd24efa 29775:404207b254703976 30432:404a916b84578290 30915:4051832b8e2899a2 31482:7ff0000000000002 33043:4059e8307083b0d2 34610:405a6f9f1c5a8489 34753:4061bb2ef8f31e3a 36320:4064d1960a6a2aed 38166:4067cc8e5b543e7e ; 22103:403cdd70a3d70a3d 23419:403cdd70a3d70a3d 24735:403cdd70a3d70a3d 26051:403cdd70a3d70a3d 27367:403cdd70a3d70a3d 28683:403cdd70a3d70a3d 29999:403cdd70a3d70a3d 31315:403cdd70a3d70a3d 32631:403cdd70a3d70a3d 33947:403cdd70a3d70a3d 35263:403cdd70a3d70a3d
+ts_of_min_over_time - 2588 8981 523 2587 8 ; 3678:c0f542e66e4224c8 5218:4140c8c27b91ff80 6218:c00decb227d0f67a 6626:c14c4885c4c02ce3 8343:c0970bc9c43e2375 10481:c209fd67ba7a91fe 12278:41e2641130a6e3eb ; 13458:400d6c8b43958106 16045:401a810624dd2f1b 18632:4020af9db22d0e56
+ts_of_min_over_time - 3948 6059 14629 3947 16 19973 ; 4729:40593693497751c4 6414:40625fe008e03ad1 6690:4067bd845cc04deb 9632:400cf527d7fe8576 10965:40486a487cbd9784 11979:40520ea6661fcbe0 12924:4003debdff928b41 14274:404342f65e9addca 14446:405065e1697efc14 15433:4053f193dd0420fe ; 14629:4029d916872b020c 18576:4029d916872b020c 22523:4029d916872b020c 26470:4029d916872b020c 30417:4029d916872b020c 34364:4029d916872b020c 38311:4029d916872b020c 42258:4029d916872b020c 46205:4029d916872b020c 50152:4029d916872b020c 54099:4029d916872b020c 58046:4029d916872b020c 61993:4029d916872b020c 65940:4029d916872b020c 69887:4029d916872b020c 73834:4029d916872b020c
+ts_of_min_over_time - 9126 -9551 39076 677 8 25133 ; 6775:406bfcf09ce3f618 7222:c08c55b062a8ee2d 8756:c081cb6331ef3637 10820:c05ff1ca8607f88d 10993:407976336c245cae 12271:c082751cadf4166d 12298:7e37e43c8800759c 13637:c054d0add07d6b6c 15625:0 16912:c0810dae8250b3f0 19064:c08203f1d305359f 20181:c07273433ef2a1da 34929:407ff3caeb53bdc7 35958:c0821d3beb679bf8 36776:c0794d5809e297e8 39725:c07de9da42c81ae7 39755:4051209e7d3d6ff5 40848:406793de7592b44b 43419:c08788513f790ca2 43686:0 ; 
+ts_of_min_over_time - 1000 -958 73968 1222 4 ; 20523:430c6bf5263400b2 22478:430c6bf5263401bc 23360:430c6bf526340131 25573:430c6bf526340262 26496:430c6bf52634017e 28134:430c6bf5263402ba 29439:430c6bf5263402c9 30805:430c6bf526340116 31900:430c6bf526340115 55938:430c6bf52634004b 56454:430c6bf52634004a 57076:430c6bf526340284 58623:430c6bf5263400c6 80303:7ff0000000000002 83050:430c6bf52634000d 85581:430c6bf526340168 85893:430c6bf526340132 86135:430c6bf52634008d ; 
+ts_of_min_over_time - 3603 0 48527 3603 6 ; 17182:7ff0000000000000 19483:7ff0000000000000 19975:7ff0000000000000 21817:7ff0000000000000 22106:7ff0000000000000 23726:7ff0000000000000 26083:7ff0000000000000 26311:7ff0000000000000 28521:7ff0000000000000 31325:7ff0000000000000 34251:7ff0000000000000 35074:7ff0000000000000 37961:7ff0000000000000 52129:7ff0000000000000 53900:7ff0000000000000 55425:7ff0000000000000 ; 52130:404a1083126e978d 55733:404bb66666666666
+ts_of_min_over_time - 15003 -8218 27137 3681 3 28256 ; 10720:7ff8000000000001 11437:7ff8000000000001 12692:408757bd7956eae4 15367:7ff8000000000001 16347:40887d7e14ba4464 18962:408b8de7f09c8195 21900:4051f219f9a7add5 23988:c079810b552181a4 26413:4080e9e013b0e293 27639:c07e93be14b4a006 29887:4037a568e3acae46 ; 27137:403ba395810624dd 30818:403ba395810624dd 34499:403ba395810624dd
+ts_of_min_over_time - 1000 -4600 19818 3974 13 ; 21295:4081f1260ef4a2dc 23634:40861c25b0ae565a 25760:408b92bbb642a25d 25781:c07d0e257f5e14b1 27768:40877e96c733beb2 28350:408975767c229450 29719:4085af995c27fbd0 31586:c07d7c622f6b1ee0 31928:c08e76b110134a53 32232:c083f5ef1147e0ae ; 19818:4037a24dd2f1a9fc 23792:403bc49ba5e353f8 27766:403fed916872b021
+ts_of_min_over_time - 6733 -9932 20399 3363 11 28044 ; 17088:7ff0000000000000 17424:7ff0000000000000 19030:7ff0000000000000 19594:7ff0000000000000 29328:7ff0000000000000 29733:7ff0000000000002 29931:7ff0000000000000 30585:7ff0000000000000 31975:7ff0000000000000 32234:7ff0000000000000 35170:7ff0000000000000 35336:7ff0000000000000 35760:7ff0000000000000 37135:7ff0000000000000 38071:7ff0000000000000 40274:7ff0000000000000 41759:7ff0000000000000 44221:7ff0000000000000 44886:7ff0000000000000 45819:7ff0000000000000 47741:7ff0000000000000 49620:7ff0000000000000 50080:7ff0000000000000 50961:7ff0000000000000 ; 20399:40429147ae147ae1 23762:40429147ae147ae1 27125:40429147ae147ae1 30488:40429147ae147ae1 33851:40429147ae147ae1 37214:40429147ae147ae1 40577:40429147ae147ae1 43940:40429147ae147ae1 47303:40429147ae147ae1 50666:40429147ae147ae1 54029:40429147ae147ae1
+ts_of_min_over_time - 1000 -5226 3314 1766 20 36543 ; 5560:fe37e43c8800759c 7121:fe37e43c8800759c 8212:fe37e43c8800759c 9476:fe37e43c8800759c 10956:fe37e43c8800759c 11467:fe37e43c8800759c 13725:fe37e43c8800759c 15947:fe37e43c8800759c 16483:fe37e43c8800759c 16503:fe37e43c8800759c 18497:fe37e43c8800759c 19679:fe37e43c8800759c 21286:fe37e43c8800759c 22591:fe37e43c8800759c 46228:fe37e43c8800759c 48730:fe37e43c8800759c 51390:fe37e43c8800759c 51430:fe37e43c8800759c 52668:fe37e43c8800759c 53253:fe37e43c8800759c ; 
+ts_of_min_over_time - 3358 -6997 20392 3358 12 80671 ; 16464:0 17678:0 28809:0 29958:0 30006:0 32681:0 34936:0 37416:0 38844:0 41818:0 44707:0 67135:0 67876:0 69619:0 71596:0 96232:0 99012:0 101583:0 ; 
+ts_of_min_over_time - 2275 -2954 2921 2274 14 7471 ; 5161:c086e1d9a7b54bf1 6738:c07429acc74b9ba9 8268:40682e8524e2637c 11208:c0887ff92b42b684 ; 2921:402089374bc6a7f0 5195:402089374bc6a7f0 7469:402089374bc6a7f0 9743:402089374bc6a7f0 12017:402089374bc6a7f0 14291:402089374bc6a7f0 16565:402089374bc6a7f0 18839:402089374bc6a7f0 21113:402089374bc6a7f0 23387:402089374bc6a7f0 25661:402089374bc6a7f0 27935:402089374bc6a7f0 30209:402089374bc6a7f0 32483:402089374bc6a7f0
+ts_of_min_over_time - 3240 1484 18354 3239 13 16622 ; 13595:421a9097298f97db 15484:4166b0826e0d745f 18234:42b980215367d0c2 18503:c2240035d1c3c19b ; 18354:402b30a3d70a3d71 21593:402b30a3d70a3d71 24832:402b30a3d70a3d71 28071:402b30a3d70a3d71 31310:402b30a3d70a3d71 34549:402b30a3d70a3d71 37788:402b30a3d70a3d71 41027:402b30a3d70a3d71 44266:402b30a3d70a3d71 47505:402b30a3d70a3d71 50744:402b30a3d70a3d71 53983:402b30a3d70a3d71 57222:402b30a3d70a3d71
+ts_of_min_over_time - 1000 0 5994 2065 14 39433 ; 4905:404e72f89bdfbf02 5246:4052052b924c5031 7610:4059e8aca21cd7f3 9818:4061536354de4ae2 9899:4062012f7af72384 12768:406549a6f48654d0 27896:4066c69649bf0ae0 30233:406c63100698261c 30940:4070c29dba97ef7a 33194:4071a4ed5c760017 35226:407368ce02208eb9 37559:407512613835e174 39347:4076d50a2a13af38 41106:407878232349506b 43313:4079c92359889117 58383:407b693778b4fcfc 60565:407de2e2aba0898e 61056:407f43f9b1e07041 62594:408124e222d79d8f 63531:4082b0d1f16c00c5 ; 5994:4043ac6a7ef9db23 8059:4043ac6a7ef9db23 10124:4043ac6a7ef9db23 12189:4043ac6a7ef9db23 14254:4043ac6a7ef9db23 16319:4043ac6a7ef9db23 18384:4043ac6a7ef9db23 20449:4043ac6a7ef9db23 22514:4043ac6a7ef9db23 24579:4043ac6a7ef9db23 26644:4043ac6a7ef9db23 28709:4043ac6a7ef9db23 30774:4043ac6a7ef9db23 32839:4043ac6a7ef9db23
+ts_of_min_over_time - 1000 -4684 25738 2447 5 ; 7807:405d0339221ef45e 9241:40632d0d22828756 9303:4065d0e6edc7ef6a 10017:406abf7a3a27d0ba 11354:402276f8d8d33b83 13301:40469a5b01b51d9a 15120:405024a149c35100 15897:7ff0000000000002 17767:40589f87a7843a52 19795:3ff3695f5b4d6e32 43852:4048e39635f42e7d ; 
+ts_of_min_over_time - 902 -3966 24597 901 2 ; 13826:430c6bf52634027b 16175:430c6bf526340165 17201:430c6bf52634020c 27073:430c6bf526340122 28164:430c6bf5263400d1 28549:430c6bf52634000e 30348:430c6bf526340081 30433:430c6bf5263401ad 31340:430c6bf5263402a9 34057:430c6bf52634017d 56910:430c6bf526340192 59674:430c6bf526340122 ; 24597:403c8c8b43958106
+ts_of_min_over_time - 1000 0 8591 1098 13 7366 ; 12297:430c6bf526340059 12756:430c6bf5263402e8 ; 
+ts_of_min_over_time - 5662 -3079 20470 3908 19 ; 9847:4037441b8d60bb38 10292:c289617182f304ec 11842:4196b6dfadc531f6 12001:413701af00fbf44e 14955:425203db495fb38a 17256:424003549b84ec04 19143:7ff0000000000002 20312:bf7d801bbf5dac00 21180:c1b2584c8e0d1a09 23151:4130a021a3857e8d 23460:c2de50d13c1def62 23912:422ba74f346b09a9 24793:c2dd641f9dee6319 25467:42b29475143fb1f7 25471:428ed9105433cc26 26377:4082d75c5f7d516a 29358:410bf36808f9f239 ; 20470:403775c28f5c28f6 24378:403775c28f5c28f6 28286:403a6083126e978d
+ts_of_min_over_time - 6575 -2311 27538 3284 12 ; 19192:c083d55e20fd197d 26695:4056c92c95c23850 28874:40802f86bf23dcab 29034:4087255e6f1c7991 29589:406818ac070465a1 29644:4085dc2c7da51135 29732:408a60d5ce347606 31313:4081cf066edd86a4 32130:408011c19ec6fd15 32236:c08991ebb9550a85 40602:c0841bf897d18caf 42525:c081bf4a14f05b19 43272:c035816eab0e7a4c 43466:bfb77284b0f55a00 44525:c08a68ee472d083d 45848:408386cb507cba9d 48454:405bcdc9e800f60f ; 27538:403ab1eb851eb852 30822:40401e353f7ced91 34106:40401e353f7ced91 40674:40444d0e56041893 43958:4046433333333333 47242:4046433333333333 50526:40483a1cac083127
+ts_of_min_over_time - 12413 1639 23724 3963 13 18275 ; 18992:c08847cb6d0634db 19544:c06e9f03f15b0015 20535:c057072435684ea4 22229:c08e5f41bab215ce 23166:408371d3501a36d7 24149:40847918fb955420 26622:40863e2bc13f9171 29327:408c83c49a814a5e ; 
+ts_of_min_over_time - 1463 0 21537 681 12 ; 17375:0 19837:0 21289:0 22638:0 24534:0 25370:0 25764:0 28667:0 28773:0 29880:0 31416:0 31484:0 33864:0 35054:0 59027:0 59530:0 61279:0 62036:0 63952:0 65363:0 66443:0 ; 21537:403549fbe76c8b44 22218:403549fbe76c8b44 22899:4036a353f7ced917 23580:4036a353f7ced917 24942:403888b439581062 25623:40395eb851eb851f 26304:4039c395810624dd 26985:4039c395810624dd 29028:403cc5e353f7ced9
+ts_of_min_over_time - 4366 0 5124 1919 20 ; 8556:7e37e43c8800759c 9011:7e37e43c8800759c 11399:7e37e43c8800759c 12037:7e37e43c8800759c 12324:7ff0000000000002 13153:7e37e43c8800759c 13597:7e37e43c8800759c 15154:7e37e43c8800759c 17236:7e37e43c8800759c 17550:7e37e43c8800759c 19738:7e37e43c8800759c 20309:7e37e43c8800759c 21724:7e37e43c8800759c ; 8962:40211cac083126e9 10881:402205a1cac08312 12800:402812f1a9fbe76d 14719:402b31a9fbe76c8b 16638:402e4ed916872b02 18557:40318ccccccccccd 20476:40344f1a9fbe76c9 22395:4035b95810624dd3 24314:4035b95810624dd3
+ts_of_min_over_time - 1390 1195 26694 1389 11 5180 ; 1242:7ff0000000000002 1580:404b37708916ab20 4499:4055011543028bb4 7413:405c78cff7dfa988 9039:7ff0000000000002 9769:40618b1f5f60df4a 16027:4064bec6d6bf37e2 17194:4068fb74c0fbc330 34079:406c5f0572f4ee04 35227:4070c1b6a62b7b07 ; 
+ts_of_min_over_time - 2619 -9928 17421 2618 7 23053 ; 11890:403d71992c9a7f45 14546:404360816cc4b962 17114:3ffab4df8703ef7c 19530:4037f4f213e385c7 20968:404806195c4dff18 ; 
+ts_of_min_over_time - 3223 0 14139 3222 9 ; 15088:c2668e7f6b7e833c 17149:c2c671a3a8ed0925 ; 17361:40312624dd2f1aa0
+ts_of_min_over_time - 2301 -625 15894 1147 14 33649 ; 17985:7ff8000000000001 20478:c063a18fe5ab38bb 20674:40871453d8863595 20859:408b1e54802047f0 23568:4074f4e7e7321f5e 26230:c06ce3d122b4ade7 28633:4068282342683760 29698:7ff8000000000001 31637:406dd37be3fad63f ; 
+ts_of_max_over_time - 486 0 603 486 10 0 ; 2150:8000000000000000 4236:8000000000000000 5033:8000000000000000 5050:8000000000000000 6308:8000000000000000 6911:8000000000000000 ; 
+ts_of_max_over_time - 2167 8471 21433 3290 12 29931 ; 23816:405907f866520287 24434:406033a7c04174a8 27254:4062da5d662f1166 28238:4063094873993ea6 30281:406540b5760158ec 32113:4067976397641f81 ; 
+ts_of_max_over_time - 2117 -854 37328 2117 4 23118 ; 19277:4055c12cca21be30 20616:405a8e08e85ee7f1 23044:405fe995b001304a 25837:40662b1421426038 27118:4069ff1ad1e031e8 27872:406be97ea0480e6a 30385:406ed97d119792c7 31645:407125335e3eeb12 31997:4071373ff0d2943b 34503:4072c753629a5a57 34683:4073550d9a4d6866 36665:4074439bb8832274 38521:401e985f0dfed0fc 40413:40263f7960ddb549 41709:40420474d5ee919d ; 37328:40370b4395810625 39445:40370b4395810625 41562:40370b4395810625 43679:40370b4395810625
+ts_of_max_over_time - 1000 0 11803 1320 4 58465 ; 16579:fff0000000000000 17733:fff0000000000000 20372:fff0000000000000 21404:fff0000000000000 24270:fff0000000000000 26479:fff0000000000000 29360:fff0000000000000 30782:fff0000000000000 33731:fff0000000000000 39592:fff0000000000000 42491:fff0000000000000 44086:fff0000000000000 46902:fff0000000000000 48821:fff0000000000000 51250:fff0000000000000 52849:fff0000000000000 53259:fff0000000000000 55850:fff0000000000000 57222:fff0000000000000 59079:fff0000000000000 61009:fff0000000000000 61773:fff0000000000000 62781:fff0000000000000 64087:fff0000000000000 ; 
+ts_of_max_over_time - 2387 -1607 22802 1190 13 ; 20786:4059cdfa49e5728d 21725:405c7edf3f34d28e 23435:4063fcadd88997b8 25509:401fcd8e43a4908f 27918:40354702b0a76073 30211:404c7782b5583e14 32894:40527053020bbc81 35151:401a1afaa4cc8d48 36569:404979acb66f34ce 37997:40565367d1fde814 40981:405b9cd730fd1916 43777:40617f3f318bcfb7 45285:4023d2d4716a311e 47921:4034155a197c5772 48177:4047237f7922e490 48785:4051474b06a08afd 50570:40567d2f3b9ae2da ; 22802:40376f5c28f5c28f 23992:40376f5c28f5c28f 25182:4039824dd2f1a9fc 26372:403beb020c49ba5e 27562:403beb020c49ba5e 28752:403e3604189374bc 29942:403e3604189374bc 32322:4040726e978d4fdf 33512:4040726e978d4fdf 34702:40419353f7ced917 35892:404248d4fdf3b646 37082:4042ff9db22d0e56
+ts_of_max_over_time - 3927 5360 7049 3926 18 ; 10607:407d512d7680708b 27871:428371056770b49b 30196:c2bbb0375023250a 31061:c08fa6ec0f8aeb7a 32668:c23317f887988347 32835:c06c34aab321f505 51625:c0052babcedaf266 53037:7ff0000000000002 54709:c00a18b4924cfd64 56858:c2706444b9434c48 57001:c01db801cc2d9589 58417:c07ae4a73e1b7b0e ; 18827:402536c8b4395810 34531:403bdef9db22d0e5 38457:40406ae147ae147b 58087:4049d00000000000 62013:404b5ac083126e98 65939:404c8020c49ba5e3
+ts_of_max_over_time - 3799 0 5683 3799 18 3433 ; 1298:40592cb741bb47d7 3162:c07df3f1baa1208a 5475:407d898c901cb063 5556:c07a2f4630d0c68c 6703:7ff8000000000001 ; 5683:3ff4c49ba5e353f8 9482:3ff4c49ba5e353f8 13281:3ff4c49ba5e353f8 17080:3ff4c49ba5e353f8 20879:3ff4c49ba5e353f8 24678:3ff4c49ba5e353f8 28477:3ff4c49ba5e353f8 32276:3ff4c49ba5e353f8 36075:3ff4c49ba5e353f8 39874:3ff4c49ba5e353f8 43673:3ff4c49ba5e353f8 47472:3ff4c49ba5e353f8 51271:3ff4c49ba5e353f8 55070:3ff4c49ba5e353f8 58869:3ff4c49ba5e353f8 62668:3ff4c49ba5e353f8 66467:3ff4c49ba5e353f8 70266:3ff4c49ba5e353f8
+ts_of_max_over_time - 2458 0 45837 2457 11 24548 ; 12808:430c6bf5263400ed 14732:430c6bf52634021f 17007:430c6bf52634015f 17821:430c6bf526340046 19260:430c6bf5263401c9 20933:430c6bf526340225 22553:430c6bf5263402ac 23517:430c6bf526340243 25271:430c6bf5263401e0 26840:430c6bf5263401f6 29245:430c6bf5263400ce 29283:430c6bf52634008f 31917:430c6bf526340062 33449:430c6bf5263402ba 35197:430c6bf5263402f6 37972:430c6bf5263400d0 40239:430c6bf5263401da 41426:430c6bf52634010e 42145:430c6bf5263400d0 43681:430c6bf526340254 44091:430c6bf52634028c 44481:430c6bf5263402c3 45109:430c6bf526340014 46409:430c6bf5263402ed 57816:430c6bf52634030b ; 45837:40368d916872b021 48294:40368d916872b021 50751:40368d916872b021 53208:40368d916872b021 55665:40368d916872b021 58122:40368d916872b021 60579:40368d916872b021 63036:40368d916872b021 65493:40368d916872b021 67950:40368d916872b021 70407:40368d916872b021
+ts_of_max_over_time - 3469 4963 14532 3468 10 14376 ; 12665:430c6bf52634028e 15531:430c6bf52634001d 16732:430c6bf526340063 18610:430c6bf526340097 19250:430c6bf52634018f 20332:430c6bf52634023e 20745:430c6bf52634008c 21407:430c6bf5263401c0 21818:430c6bf526340030 23115:430c6bf52634027b 24781:430c6bf526340095 25241:430c6bf52634011d 26103:430c6bf5263402e1 27088:430c6bf52634025b ; 
+ts_of_max_over_time - 94 0 19664 93 16 28870 ; 14454:41761e41a4aaa054 15653:42903b9322b47004 16586:c11675950b6a76d8 18593:c1d43f3819613650 18942:c1a85e133c70f4f6 20096:4033318ba5d601d7 22842:c045fa5c5c201c8a 23120:c271d718aef91962 23431:c28fe74c00a63f01 26229:c240925af47cbcbf 27202:c2f16f8fc2abc2e4 27637:42f6dc341dd92bc4 28485:c1e5f651d85f20ef 28810:c002d32568967726 30775:c1bbe0d6a480e695 ; 19664:403ccf5c28f5c28f 19757:403ccf5c28f5c28f 19850:403ccf5c28f5c28f 19943:403ccf5c28f5c28f 20036:403ccf5c28f5c28f 20129:403ccf5c28f5c28f 20222:403ccf5c28f5c28f 20315:403ccf5c28f5c28f 20408:403ccf5c28f5c28f 20501:403ccf5c28f5c28f 20594:403ccf5c28f5c28f 20687:403ccf5c28f5c28f 20780:403ccf5c28f5c28f 20873:403ccf5c28f5c28f 20966:403ccf5c28f5c28f 21059:403ccf5c28f5c28f
+ts_of_max_over_time - 7983 -574 5759 3143 16 ; 4875:430c6bf526340217 5844:430c6bf526340016 8144:430c6bf52634019d 10333:430c6bf5263401d0 10942:430c6bf5263400f8 13621:430c6bf526340151 15718:430c6bf5263402ea 18036:430c6bf526340218 20188:430c6bf5263401b7 ; 5759:4013800000000000 8902:4013800000000000 12045:4013800000000000 15188:402f6f9db22d0e56 18331:402f6f9db22d0e56 21474:402f6f9db22d0e56 24617:403209374bc6a7f0
+ts_of_max_over_time - 1000 0 18103 687 16 ; 6323:408c4e3cccda74e8 7506:c0861dd95633c334 9961:4082df071dc1c4e7 11209:c08199fa4d82ab30 11905:40852bed60be4a6c 13783:8000000000000000 16281:c085c3abddd8870e 19133:408aa5742e000956 19803:4087affd5adc13b2 21547:7ff0000000000002 24226:4083e43a0564127b 26464:c054ef5b29be7a3c 27696:fe37e43c8800759c 29904:405f6ab16989920c 31744:c08886430b8d2f46 32600:406959d5803e8d89 34724:7ff8000000000001 37103:405386df9f800770 39180:408a2ad500dd8617 40474:7ff8000000000001 42430:407f605cc2dc1099 ; 19477:4033220c49ba5e35 20164:4033cd916872b021 24286:403839db22d0e560 24973:403839db22d0e560 27034:403a76c8b4395810 27721:403bb22d0e560419 28408:403bb22d0e560419
+ts_of_max_over_time - 687 3157 16290 687 7 ; 19591:430c6bf5263400de 21340:430c6bf52634011f 23065:430c6bf526340246 26045:7ff0000000000002 26284:430c6bf52634030d 39539:430c6bf5263402e6 40861:430c6bf526340265 ; 
+ts_of_max_over_time - 1653 7363 50274 823 17 36293 ; 16639:bfde730cedcb166b 17995:4222e47a7d7e115f 20423:c0118285e76373b3 21893:4286e0e02833d6a6 22367:4232c58b714fab43 22945:c03136b243521fed 25561:c2b47823e1a3ff51 28172:4259af50fb946ed7 28426:c0dd8e6333856060 30523:c0d14cdc75eb9998 30554:42917cc5941cb012 32566:c1ba3ef08b906ea8 34039:417249bf6a6f388c 36517:4269f24b570eec08 38396:40b36a3e59c669d5 41047:c0b36cd32ed74a6e 43123:429131310ae3700c 45769:c048fabf9f48c659 46163:c25c854d98260b02 49005:41bfba7455953744 50418:c11bcf546dcf8b1b ; 50274:403c2c083126e979 51097:403c2c083126e979 51920:403c2c083126e979 52743:403c2c083126e979 53566:403c2c083126e979 54389:403c2c083126e979 55212:403c2c083126e979 56035:403c2c083126e979 56858:403c2c083126e979 57681:403c2c083126e979 58504:403c2c083126e979 59327:403c2c083126e979 60150:403c2c083126e979 60973:403c2c083126e979 61796:403c2c083126e979 62619:403c2c083126e979 63442:403c2c083126e979
+ts_of_max_over_time - 2480 -7605 76669 2676 20 ; 19397:c082eacb4d43edd5 21313:c0805af73d6bbcbb 22438:c079dcaac6ba7206 25176:405762de9a7aa8de 26496:4073472f5b315ed4 27784:c086e639a0118b13 29658:4018d33a3b312c50 31009:4079191033bc74bb 33890:c0825465ff83c4a9 34248:c078aa16f5b7737e 35276:7ff8000000000001 35401:404055d1974c565d 38106:407676efd5cf920a 38229:7ff8000000000001 56676:4088c8770d1a0874 68289:408d1839992fb440 70822:408ef2a352d593b0 71249:403a7393d22cc2d1 71729:c0706934e6d8a0f7 72457:7ff8000000000001 73776:40591c884937115e 74204:4039f826656d3754 75391:c048c7130745dde6 78085:407dbeb46e3d76cd ; 
+ts_of_max_over_time - 1000 350 11944 1695 5 ; 4714:4079fe17e01e66f1 7624:c08d00c500c71444 7874:4079c84c70164a36 10226:408871a9b2ae9baa 12500:7ff8000000000001 14929:40880ce5ced2bdf3 ; 13639:4029000000000000 15334:402ddba5e353f7cf
+ts_of_max_over_time - 795 4484 17550 394 4 57402 ; 18188:7ff0000000000002 19327:430c6bf52634010b 20747:430c6bf526340062 22961:430c6bf5263401fe 25916:430c6bf52634031a 28161:430c6bf52634003a 31038:7ff0000000000002 33690:430c6bf5263401c3 35212:430c6bf526340193 37180:7ff0000000000002 38331:430c6bf5263401db 41271:430c6bf526340219 56763:430c6bf52634005a ; 
+ts_of_max_over_time - 9252 -906 34722 1211 1 ; 16960:c06739866b9abebd 19936:c079aa25d4c49313 20401:7ff8000000000001 22969:c08bd9efc70abdf9 23225:7ff8000000000001 25297:c07e329e98d1fa38 25316:406760a0af50d54b 27748:7ff0000000000002 27985:c08eba012d3382b6 28410:7ff8000000000001 31299:4083abdcfd22e1cb 34019:c077f2024a187b53 35806:7ff8000000000001 38685:c08861b01fe8e020 39958:c08a27065456f14e 40976:7ff8000000000001 41946:408c8485b533f422 44156:7ff8000000000001 46992:c08dda44f2dcd142 61657:408335007efa6a8c 63246:c0842ee94276efc5 63724:c086262ca162d1e8 63999:40644e3f7a3070b3 87713:c059168adf528cbd ; 34722:403f4c8b43958106
+ts_of_max_over_time - 1584 -557 46221 1583 20 ; 20919:7e37e43c8800759c 22907:7e37e43c8800759c 23699:7e37e43c8800759c 26312:7e37e43c8800759c 27519:7ff0000000000002 29805:7e37e43c8800759c 42690:7e37e43c8800759c 44288:7e37e43c8800759c 45567:7e37e43c8800759c 45856:7e37e43c8800759c 48854:7e37e43c8800759c 51737:7e37e43c8800759c 53862:7e37e43c8800759c ; 46221:4046ed916872b021 49387:40486d4fdf3b645a 52553:4049de5604189375 54136:404aee5604189375
+ts_of_max_over_time - 1203 -3750 33671 1202 5 ; 10327:430c6bf5263402cc 12914:430c6bf5263400be 13587:430c6bf5263402cc 15935:430c6bf5263402eb 17015:430c6bf52634021a 19395:430c6bf5263402a2 21399:430c6bf5263400a2 22437:430c6bf52634027f 23162:430c6bf526340201 25621:430c6bf526340197 26907:430c6bf5263401f7 29783:430c6bf526340219 31805:430c6bf5263401cb 34511:430c6bf52634016b 35196:430c6bf5263402dc 37282:430c6bf5263401a1 38990:430c6bf526340169 39694:430c6bf526340295 42145:430c6bf52634026f 43752:430c6bf52634002c ; 33671:4042a4189374bc6a 36075:4043d8d4fdf3b646 38479:4045128f5c28f5c3
+ts_of_max_over_time - 1104 -4268 24899 1104 20 12634 ; 15947:fff0000000000000 18652:7ff0000000000002 18675:fff0000000000000 20187:fff0000000000000 21019:fff0000000000000 22443:fff0000000000000 22592:fff0000000000000 24525:fff0000000000000 26328:fff0000000000000 27193:fff0000000000000 29509:fff0000000000000 31503:fff0000000000000 32412:fff0000000000000 32809:fff0000000000000 ; 24899:402fe4dd2f1a9fbe 26003:402fe4dd2f1a9fbe 27107:402fe4dd2f1a9fbe 28211:402fe4dd2f1a9fbe 29315:402fe4dd2f1a9fbe 30419:402fe4dd2f1a9fbe 31523:402fe4dd2f1a9fbe 32627:402fe4dd2f1a9fbe 33731:402fe4dd2f1a9fbe 34835:402fe4dd2f1a9fbe 35939:402fe4dd2f1a9fbe 37043:402fe4dd2f1a9fbe 38147:402fe4dd2f1a9fbe 39251:402fe4dd2f1a9fbe 40355:402fe4dd2f1a9fbe 41459:402fe4dd2f1a9fbe 42563:402fe4dd2f1a9fbe 43667:402fe4dd2f1a9fbe 44771:402fe4dd2f1a9fbe 45875:402fe4dd2f1a9fbe
+ts_of_max_over_time - 14767 6727 41173 476 6 14670 ; 17242:430c6bf5263402c8 18748:430c6bf526340103 20001:430c6bf526340259 22113:430c6bf5263402c1 22311:430c6bf526340167 24060:430c6bf526340275 25371:430c6bf52634030a 27479:430c6bf52634011b 28267:430c6bf526340210 31238:430c6bf5263401e2 56185:430c6bf5263400a0 57040:430c6bf5263401c4 ; 
+ts_of_max_over_time - 14095 7113 25153 334 1 41585 ; 2069:41b1da090c99f95f 4162:403ac002f9bb6164 6750:c0796c6f227bca1d 8912:3fae66f646be5f20 9285:c1bcabbf9049716e 11832:411a44e9893155ce 13777:411d19f2046cd50e 15127:420475c64c1f63e3 17380:c1405d431e68db44 19363:4283d27795142dfc 20171:c24542dde13364e7 21132:40fee968e2f3c15a 23896:c013f6a1a8307302 25483:bfda0d39204974d0 25901:bfdda5247c7c8782 26307:423bffd5c9c0d7ae 38326:405a4932ef61aadb 39734:c0a9369591b5ddfd 41693:c0b1c9712cd78888 43376:c055d6b00cf7d386 44711:c172f3167afa0174 46676:42814406f72ad63a 47614:c02e51ce76a4bef7 47756:412b8fdb69de9961 49864:c00671920aef5968 ; 25153:403a4e978d4fdf3b
+ts_of_max_over_time - 2217 -2582 54955 1105 10 45648 ; 19959:408c21800693a08d 21240:c08b36a3d1368637 24068:c075641d944b267e 24861:4085837a25ec0eda 27407:406892f0cd449cb2 46203:4083e4ba497b33c6 48335:c03dbabf111ec184 51054:7ff0000000000002 51264:4083964bbffeb74d 51888:407b142d3ef7a99a 54410:c0800b9a584388e0 57021:c067a1f422f3cc4d 59429:4080dfb541465277 61486:c056d1a352fb0ca0 63206:4088eafa14d41798 64615:8000000000000000 64693:406ed99a4394fca5 ; 54955:404719fbe76c8b44 56060:404719fbe76c8b44 57165:404719fbe76c8b44 58270:404719fbe76c8b44 59375:404719fbe76c8b44 60480:404719fbe76c8b44 61585:404719fbe76c8b44 62690:404719fbe76c8b44 63795:404719fbe76c8b44 64900:404719fbe76c8b44
+ts_of_max_over_time - 560 9918 48020 560 5 29289 ; 14754:c1d780831f235e39 15718:c1f278c864703a5e 15821:42bb5b8d62186b5c 17333:415803c22bee08a1 18363:425904fc64782c1a 20209:c151f46e026751d9 20579:42f44b71646d8262 23520:41070dde30a7085d 32510:7ff0000000000002 34859:4109fa37c197c5b8 36516:c17a2315d326503a 50219:c28da14bf19210ea 52288:7ff0000000000002 52923:4247575e147c87cb 54020:414906054975263a 55466:4236a0fed1b61265 57413:c0f0d9b2565f3467 60048:c11194f0aca7359e 60127:c2e32a578e05f634 62032:c291bf5733e315f2 62157:42b159d55d63947a 62223:c1bec522ea8c85b1 64297:402cd208b422ade0 65215:c05ea9e84bd50d84 66640:c2f3508979a7739c ; 
+ts_of_max_over_time - 2742 -5035 7838 2742 4 ; 8630:405abeb73d71ee0a 9340:40636a84109d1609 ; 
+ts_of_max_over_time - 575 -4524 20908 575 1 44247 ; 6181:407965ec7db11b50 7597:fe37e43c8800759c 9086:40750b7a71c46642 10226:40596eb40114ad6f 11082:7ff0000000000002 11497:7e37e43c8800759c 11610:4074b24cbd9cce8b 12878:40835327d82a44a4 14030:c077a953480114f0 14217:c0834935893175b9 17047:407a9ac67a0bca63 28341:405e86cd0265be88 31296:c08cc5f5ac3ee9f6 33024:c08e1c76eb4e093a 34322:8000000000000000 36943:4084c7ea3d38adb9 39408:40715085808413ea 39756:c0805d6d56e71d89 ; 
+ts_of_max_over_time - 1445 0 76279 1445 18 ; 7402:4084ef200945d963 31186:c05a2d1fc1341852 32093:7ff0000000000000 34720:408e9f8478323170 35511:408585c4f965fb52 36229:4080f67a8519963a 37238:4089a398d92e75c9 38104:4088d0f3c8537f9c 62964:8000000000000000 63651:c08e17367516ad9d 65993:c088b8498b4eec79 68498:407959c17aab2495 71194:40893c3b1425fc71 71676:c0625ed023c2c2c3 74434:7ff0000000000002 76737:c062a322a3775da8 ; 77724:40532f2b020c49ba
+ts_of_max_over_time - 1620 5466 66748 1619 3 ; 20343:c08d0b41aef597e3 20468:408cead8a9547c45 22948:c07cea4141cbe87d 25427:40719d95b0a8cec2 44205:7ff0000000000002 44406:c08bd94d02e294c2 47338:c0685aeb2fbbc737 48876:c061c8d2ce267ca9 49070:408917a8f1b393b5 49187:40754c22808b1de5 49276:c080913f9ca171a7 50045:c087eda131380c64 52814:407d0efdd2a49a4b 70889:7ff8000000000001 70912:408e64a51e0841d0 73886:7ff8000000000001 75627:7ff8000000000001 77875:4072838cc68b6a7e 79667:7ff8000000000001 82350:7ff0000000000002 84316:40882fbfa7b9eebc 84639:4081c6a07b537b63 85405:7ff8000000000001 ; 
+ts_of_max_over_time - 1617 -6998 37054 1617 2 ; 13592:7e37e43c8800759c 14733:7e37e43c8800759c 16780:7e37e43c8800759c 18986:7e37e43c8800759c 20754:7e37e43c8800759c 21170:7e37e43c8800759c 29438:7e37e43c8800759c 31048:7e37e43c8800759c 53499:7e37e43c8800759c 53903:7e37e43c8800759c 55214:7e37e43c8800759c 57069:7e37e43c8800759c 59630:7e37e43c8800759c 61917:7e37e43c8800759c ; 
+ts_of_max_over_time - 11349 -9330 9118 2126 20 36113 ; 4427:c0736ebb10c769a8 7185:40740b195a32125c 8350:40765920bb322d0f 8813:c066f31ac9130852 9212:c053f1c8806b35fc 9589:c07e199dae548fc9 10561:4081109f807ab010 11050:c06d084d0c46cef1 12534:c08e71baf58a1760 35653:c0831f13bebcc90c 37956:4084cac64157573a 40658:408d001e4e170cc6 40863:3ffd668c854a3e78 41275:7ff0000000000000 41401:c081fef5b512abc4 41806:408f34577bb7c93f 43237:40870ffeb55541eb ; 9118:4044a33333333333 11244:4044a33333333333 13370:4044a33333333333 15496:4044a33333333333 17622:4044a33333333333 19748:4044a33333333333 21874:4044a33333333333 24000:4044a33333333333 26126:4044a33333333333 28252:4044a33333333333 30378:4044a33333333333 32504:4044a33333333333 34630:4044a33333333333 36756:4044a33333333333 38882:4044a33333333333 41008:4044a33333333333 43134:4044a33333333333 45260:4044a33333333333 47386:4044a33333333333 49512:4044a33333333333
+ts_of_max_over_time - 1000 0 25892 3921 6 28802 ; 15209:c08f3519a50a9510 17300:c05a80f780a4edca 17722:408ea0aa1ea1c096 20474:c05db862735bdb14 23128:40868c7ea55c2b1f 23269:7ff0000000000002 24634:4057d22d6d0ed40f 26004:c07e8a49fae70639 ; 
+ts_of_max_over_time - 1000 -2245 26229 1553 8 ; 16728:4035ae121bd23df0 18056:4043b33f5a6ae91d 20479:404dc74015dea586 21716:405a06be47521e1c 23830:4062b51c1a608af0 24227:4063ac39ac4d4e14 26791:4063edcb2fa69321 29751:40660abbcf88b20f 30886:4066107c3d26777e 32668:4069e71ad77ae7d6 33935:406ce7f5f73f7f16 36311:406dae14d133a06a 36388:407002f4dfe803de 37962:4070ba6bcb77a829 39664:4073644b13d1251d 40601:4074abfbb7230a06 62577:40777ba6f48b0a00 ; 27782:403dc04189374bc7 29335:403ee2d0e5604189 30888:404055810624dd2f 32441:4040f7ae147ae148
+ts_of_max_over_time - 5311 0 28927 2652 12 ; 19769:8000000000000000 21049:7ff0000000000002 23979:40557c35820c809d 41170:c071a06383e876d4 41385:7ff0000000000002 42985:c07fa2f5ec8640d9 44960:c0887379f48ef525 46253:8000000000000000 ; 28927:4037fa9fbe76c8b4 42187:404495c28f5c28f6 44839:404495c28f5c28f6 47491:404720624dd2f1aa 50143:404720624dd2f1aa
+ts_of_max_over_time - 248 963 11665 247 1 17379 ; 15171:430c6bf5263401a2 17159:430c6bf52634023b 18673:430c6bf5263401db 18856:430c6bf526340173 20808:430c6bf52634020b 23406:430c6bf526340040 25218:430c6bf5263400a9 25730:430c6bf526340177 28207:430c6bf526340293 29591:430c6bf5263402b8 32021:430c6bf526340160 32975:430c6bf52634010e 35578:430c6bf5263402fa 37682:430c6bf52634023d ; 
+ts_of_max_over_time - 643 -5563 18173 642 11 ; 20154:4080429d75d4759b 22063:406c21d42983126c 33795:408eb5a0c800bb04 36442:c0649980344394e4 36814:c089d15c0cffb072 38502:40386a80d9249c08 39688:408ca2b248491604 41948:7ff8000000000001 44672:c0336b54d9ef97e3 45308:4084be3dc2a5bed8 46971:7ff8000000000001 49213:c07155eeaf92e9bd 50305:4077032253246f05 51909:c0726d75ec9a0c48 54848:404b1627526add25 56812:40737012dba88782 58390:4041f8a08044572f ; 
+ts_of_max_over_time - 405 1039 23305 199 7 ; 19126:430c6bf5263402e2 20102:430c6bf526340072 21535:430c6bf5263402cf 24180:430c6bf526340023 26767:430c6bf526340231 28977:430c6bf526340198 31404:430c6bf52634027a 33442:430c6bf526340089 36334:430c6bf52634002d 38219:430c6bf52634014f 40976:430c6bf5263400dd 49259:430c6bf52634010f 50059:430c6bf526340005 51304:430c6bf526340010 51430:430c6bf5263402ef 52104:430c6bf52634016c 52813:430c6bf526340281 53668:430c6bf526340310 56098:430c6bf52634013a 57904:430c6bf5263401c6 59242:430c6bf5263400d5 ; 
+ts_of_max_over_time - 1659 -8443 23063 1659 19 10544 ; 15075:3fbb23dfc6386760 17770:40460eb9a843a3f9 19846:c26242f7ea0207e9 20786:c220811d0d5f186c 21693:403c029a9bf36415 21938:c23be0d194294b2b 22347:41f346707a518ef2 24295:c17e9fc924c80e3b 25341:c113ddb18d61bf2c 27941:c0d88a17d3894774 28793:41a2d5cfddf1cbdf 28915:7ff0000000000002 31081:7ff0000000000002 34043:41115bb93b1c31dd 35488:42c009148194fa61 37140:c1816c01a50df54f ; 23063:4031c51eb851eb85 24722:4031c51eb851eb85 26381:4031c51eb851eb85 28040:4031c51eb851eb85 29699:4031c51eb851eb85 31358:4031c51eb851eb85 33017:4031c51eb851eb85 34676:4031c51eb851eb85 36335:4031c51eb851eb85 37994:4031c51eb851eb85 39653:4031c51eb851eb85 41312:4031c51eb851eb85 42971:4031c51eb851eb85 44630:4031c51eb851eb85 46289:4031c51eb851eb85 47948:4031c51eb851eb85 49607:4031c51eb851eb85 51266:4031c51eb851eb85 52925:4031c51eb851eb85
+ts_of_max_over_time - 3662 8308 16770 3661 2 16620 ; 1800:40754c56b53a727b 3171:7ff0000000000002 5443:7ff0000000000000 6533:c06f46451985aab9 8253:4078c88bb675038f 10296:c0786eb490670132 12358:c07bd4205adccf70 13665:7ff0000000000000 14756:408e050f07c46b30 15350:407813ce9a8afa9f 16786:408773c9b3cff2d5 18497:c080c389d0dac0cb ; 16770:4015c5a1cac08312 20431:4015c5a1cac08312
+ts_of_max_over_time - 10031 -4376 12408 1978 6 ; 10204:0 11321:0 14123:0 15211:0 16843:0 17470:0 19718:0 20530:7ff0000000000002 22288:0 22633:0 25035:0 25525:0 34189:0 36056:0 38757:0 39811:0 41576:0 44126:0 44380:0 45600:0 48189:0 ; 12408:402e6c083126e979 14386:40317851eb851eb8 16364:4033b7ced916872b 18342:4036a20c49ba5e35 20320:4036a20c49ba5e35 22298:4039866666666666

src/promql/src/range_eval/function.rs

@@ -0,0 +1,391 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Float range-vector functions as window kernels.
+//!
+//! Each kernel follows the Prometheus function of the same name, including its floating point
+//! operation order. Arithmetic that GreptimeDB's range UDFs compute the same way is shared with
+//! them.
+
+use crate::functions::{
+    EdgeKind, add_counter_resets, count_edges, extremum, instant_delta, kahan_inc,
+};
+use crate::go_sort;
+use crate::range_eval::{FloatWindow, WindowKernel};
+
+/// A PromQL range-vector function over float and native histogram samples.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RangeFunction {
+    Rate,
+    Increase,
+    Delta,
+    Irate,
+    Idelta,
+    AvgOverTime,
+    MinOverTime,
+    MaxOverTime,
+    SumOverTime,
+    CountOverTime,
+    LastOverTime,
+    PresentOverTime,
+    StddevOverTime,
+    StdvarOverTime,
+    /// `quantile_over_time` with a constant quantile.
+    QuantileOverTime(f64),
+    Resets,
+    Changes,
+    Deriv,
+    /// `predict_linear` with a constant horizon in seconds.
+    PredictLinear(f64),
+    /// `double_exponential_smoothing` (`holt_winters`) with constant factors in `(0, 1)`.
+    DoubleExponentialSmoothing {
+        smoothing: f64,
+        trend: f64,
+    },
+    // Prometheus marks the following as experimental.
+    FirstOverTime,
+    MadOverTime,
+    TsOfFirstOverTime,
+    TsOfLastOverTime,
+    TsOfMinOverTime,
+    TsOfMaxOverTime,
+}
+
+impl RangeFunction {
+    /// Whether the result drops the metric name, as Prometheus does for every range function
+    /// except `last_over_time` and `first_over_time`.
+    pub(crate) fn drops_metric_name(self) -> bool {
+        !matches!(self, Self::LastOverTime | Self::FirstOverTime)
+    }
+
+    /// Returns the kernel computing this function over windows read with `offset_ms`.
+    pub(crate) fn kernel(self, offset_ms: i64) -> WindowKernel {
+        match self {
+            Self::Rate => Box::new(extrapolated_rate::<true, true>),
+            Self::Increase => Box::new(extrapolated_rate::<true, false>),
+            Self::Delta => Box::new(extrapolated_rate::<false, false>),
+            Self::Irate => Box::new(last_two::<true>),
+            Self::Idelta => Box::new(last_two::<false>),
+            Self::AvgOverTime => Box::new(|window| Some(avg(window.values))),
+            Self::MinOverTime => Box::new(|window| extremum(window.values.iter().copied(), true)),
+            Self::MaxOverTime => Box::new(|window| extremum(window.values.iter().copied(), false)),
+            Self::SumOverTime => Box::new(|window| Some(sum(window.values))),
+            Self::CountOverTime => Box::new(|window| Some(window.values.len() as f64)),
+            Self::LastOverTime => Box::new(|window| window.values.last().copied()),
+            Self::PresentOverTime => Box::new(|_| Some(1.0)),
+            Self::StddevOverTime => Box::new(|window| Some(variance(window.values).sqrt())),
+            Self::StdvarOverTime => Box::new(|window| Some(variance(window.values))),
+            Self::QuantileOverTime(q) => {
+                let mut scratch = Vec::new();
+                Box::new(move |window| Some(quantile(q, window.values, &mut scratch)))
+            }
+            Self::Resets => {
+                Box::new(|window| Some(count_edges(window.values, EdgeKind::Resets) as f64))
+            }
+            Self::Changes => {
+                Box::new(|window| Some(count_edges(window.values, EdgeKind::Changes) as f64))
+            }
+            Self::Deriv => Box::new(|window| {
+                (window.values.len() >= 2)
+                    .then(|| linear_regression(&window, window.timestamps[0]).0)
+            }),
+            // Prometheus regresses the unshifted samples around the evaluation time, which on the
+            // shifted timeline is `eval_ts + offset`; `RangeEvaluator::try_new` checks it fits.
+            Self::PredictLinear(duration) => Box::new(move |window| {
+                if window.values.len() < 2 {
+                    return None;
+                }
+                let (slope, intercept) =
+                    linear_regression(&window, window.eval_ts.checked_add(offset_ms)?);
+                Some(slope * duration + intercept)
+            }),
+            Self::DoubleExponentialSmoothing { smoothing, trend } => Box::new(move |window| {
+                double_exponential_smoothing(window.values, smoothing, trend)
+            }),
+            Self::FirstOverTime => Box::new(|window| window.values.first().copied()),
+            Self::MadOverTime => {
+                let (mut deviations, mut scratch) = (Vec::new(), Vec::new());
+                Box::new(move |window| {
+                    Some(median_absolute_deviation(
+                        window.values,
+                        &mut deviations,
+                        &mut scratch,
+                    ))
+                })
+            }
+            // Window timestamps are shifted by the offset; Prometheus reports the sample's own.
+            Self::TsOfFirstOverTime => {
+                Box::new(move |window| Some(seconds(window.timestamps[0] - offset_ms)))
+            }
+            // Prometheus takes the max with the histogram timestamp, 0 when there is none, so a
+            // negative timestamp reports 0.
+            Self::TsOfLastOverTime => Box::new(move |window| {
+                let last = window.timestamps[window.timestamps.len() - 1] - offset_ms;
+                Some(seconds(last.max(0)))
+            }),
+            Self::TsOfMinOverTime => Box::new(move |window| {
+                Some(seconds(timestamp_of_extremum(&window, false) - offset_ms))
+            }),
+            Self::TsOfMaxOverTime => Box::new(move |window| {
+                Some(seconds(timestamp_of_extremum(&window, true) - offset_ms))
+            }),
+        }
+    }
+}
+
+/// Prometheus `funcSumOverTime`.
+fn sum(values: &[f64]) -> f64 {
+    let (sum, c) = values
+        .iter()
+        .fold((0.0, 0.0), |(sum, c), &value| kahan_inc(value, sum, c));
+    sum + c
+}
+
+/// Prometheus `funcAvgOverTime`: the Kahan sum divided by the count, switching to an
+/// incremental mean once the sum would overflow.
+fn avg(values: &[f64]) -> f64 {
+    let (mut sum, mut count) = (values[0], 1.0);
+    let (mut mean, mut kahan_c) = (0.0, 0.0);
+    let mut incremental_mean = false;
+    for (i, &value) in values[1..].iter().enumerate() {
+        count = (i + 2) as f64;
+        if !incremental_mean {
+            let (new_sum, new_c) = kahan_inc(value, sum, kahan_c);
+            if !new_sum.is_infinite() {
+                (sum, kahan_c) = (new_sum, new_c);
+                continue;
+            }
+            incremental_mean = true;
+            mean = sum / (count - 1.0);
+            kahan_c /= count - 1.0;
+        }
+        let q = (count - 1.0) / count;
+        (mean, kahan_c) = kahan_inc(value / count, q * mean, q * kahan_c);
+    }
+    if incremental_mean {
+        mean + kahan_c
+    } else {
+        sum / count + kahan_c / count
+    }
+}
+
+/// Prometheus `varianceOverTime`, the population variance.
+fn variance(values: &[f64]) -> f64 {
+    let mut count = 0.0;
+    let (mut mean, mut c_mean) = (0.0, 0.0);
+    let (mut aux, mut c_aux) = (0.0, 0.0);
+    for &value in values {
+        count += 1.0;
+        let delta = value - (mean + c_mean);
+        (mean, c_mean) = kahan_inc(delta / count, mean, c_mean);
+        (aux, c_aux) = kahan_inc(delta * (value - (mean + c_mean)), aux, c_aux);
+    }
+    (aux + c_aux) / count
+}
+
+/// Prometheus `quantile`, which sorts NaN before every number.
+fn quantile(q: f64, values: &[f64], sorted: &mut Vec<f64>) -> f64 {
+    if q.is_nan() {
+        return f64::NAN;
+    }
+    if q < 0.0 {
+        return f64::NEG_INFINITY;
+    }
+    if q > 1.0 {
+        return f64::INFINITY;
+    }
+    sorted.clear();
+    sorted.extend_from_slice(values);
+    // `sort.Sort` with `vectorByValueHeap.Less`: NaN first, +0 and -0 tie, and which zero
+    // lands at the rank decides the sign of the result.
+    go_sort::sort_by(sorted, |a, b| a.is_nan() || a < b);
+    let n = sorted.len() as f64;
+    let rank = q * (n - 1.0);
+    let lower = rank.floor().max(0.0);
+    let upper = (n - 1.0).min(lower + 1.0);
+    let weight = rank - rank.floor();
+    sorted[lower as usize] * (1.0 - weight) + sorted[upper as usize] * weight
+}
+
+/// Prometheus `extrapolatedRate` over floats.
+fn extrapolated_rate<const IS_COUNTER: bool, const IS_RATE: bool>(
+    window: FloatWindow<'_>,
+) -> Option<f64> {
+    let FloatWindow {
+        timestamps,
+        values,
+        eval_ts,
+        range_ms,
+    } = window;
+    let samples_minus_one = values.len().checked_sub(1).filter(|n| *n > 0)?;
+    let first = values[0];
+    let mut result = values[samples_minus_one] - first;
+    if IS_COUNTER {
+        result = add_counter_resets(result, values);
+    }
+    let zero_point = (IS_COUNTER && result > 0.0 && first >= 0.0).then(|| first / result);
+    let factor = extrapolation_factor(
+        (timestamps[0], timestamps[samples_minus_one]),
+        samples_minus_one,
+        eval_ts,
+        range_ms,
+        IS_COUNTER,
+        IS_RATE,
+        zero_point,
+    );
+    Some(result * factor)
+}
+
+/// The factor `extrapolatedRate` scales the sampled increase by. `zero_point` is the first
+/// value over the increase, given only when Prometheus extrapolates a counter to zero.
+pub(super) fn extrapolation_factor(
+    (first_t, last_t): (i64, i64),
+    samples_minus_one: usize,
+    eval_ts: i64,
+    range_ms: i64,
+    is_counter: bool,
+    is_rate: bool,
+    zero_point: Option<f64>,
+) -> f64 {
+    let range_start = i128::from(eval_ts) - i128::from(range_ms);
+    let mut duration_to_start = (i128::from(first_t) - range_start) as f64 / 1000.0;
+    let mut duration_to_end = (i128::from(eval_ts) - i128::from(last_t)) as f64 / 1000.0;
+    let sampled_interval = (i128::from(last_t) - i128::from(first_t)) as f64 / 1000.0;
+    let average_interval = sampled_interval / samples_minus_one as f64;
+    let threshold = average_interval * 1.1;
+    if duration_to_start >= threshold {
+        duration_to_start = average_interval / 2.0;
+    }
+    if is_counter {
+        let mut duration_to_zero = duration_to_start;
+        if let Some(zero_point) = zero_point {
+            duration_to_zero = sampled_interval * zero_point;
+        }
+        if duration_to_zero < duration_to_start {
+            duration_to_start = duration_to_zero;
+        }
+    }
+    if duration_to_end >= threshold {
+        duration_to_end = average_interval / 2.0;
+    }
+    let mut factor = 1.0;
+    if sampled_interval != 0.0 {
+        factor = (sampled_interval + duration_to_start + duration_to_end) / sampled_interval;
+    }
+    if is_rate {
+        factor /= range_ms as f64 / 1000.0;
+    }
+    factor
+}
+
+fn last_two<const IS_RATE: bool>(window: FloatWindow<'_>) -> Option<f64> {
+    let [.., prev_ts, last_ts] = window.timestamps else {
+        return None;
+    };
+    let [.., prev, last] = window.values else {
+        return None;
+    };
+    instant_delta::<IS_RATE>((*prev_ts, *prev), (*last_ts, *last))
+}
+
+/// Prometheus `linearRegression`: `(slope, intercept)` with `x` in seconds from
+/// `intercept_time`. Needs at least two samples.
+fn linear_regression(window: &FloatWindow<'_>, intercept_time: i64) -> (f64, f64) {
+    let init_y = window.values[0];
+    let mut const_y = true;
+    let mut n = 0.0;
+    let (mut sum_x, mut c_x) = (0.0, 0.0);
+    let (mut sum_y, mut c_y) = (0.0, 0.0);
+    let (mut sum_xy, mut c_xy) = (0.0, 0.0);
+    let (mut sum_x2, mut c_x2) = (0.0, 0.0);
+    for (i, (&t, &y)) in window.timestamps.iter().zip(window.values).enumerate() {
+        if const_y && i > 0 && y != init_y {
+            const_y = false;
+        }
+        n += 1.0;
+        let x = (i128::from(t) - i128::from(intercept_time)) as f64 / 1e3;
+        (sum_x, c_x) = kahan_inc(x, sum_x, c_x);
+        (sum_y, c_y) = kahan_inc(y, sum_y, c_y);
+        (sum_xy, c_xy) = kahan_inc(x * y, sum_xy, c_xy);
+        (sum_x2, c_x2) = kahan_inc(x * x, sum_x2, c_x2);
+    }
+    if const_y {
+        if init_y.is_infinite() {
+            return (f64::NAN, f64::NAN);
+        }
+        return (0.0, init_y);
+    }
+    sum_x += c_x;
+    sum_y += c_y;
+    sum_xy += c_xy;
+    sum_x2 += c_x2;
+    let cov_xy = sum_xy - sum_x * sum_y / n;
+    let var_x = sum_x2 - sum_x * sum_x / n;
+    let slope = cov_xy / var_x;
+    let intercept = sum_y / n - slope * sum_x / n;
+    (slope, intercept)
+}
+
+/// Prometheus `funcDoubleExponentialSmoothing`; `RangeEvaluator` checks the factors.
+fn double_exponential_smoothing(values: &[f64], sf: f64, tf: f64) -> Option<f64> {
+    if values.len() < 2 {
+        return None;
+    }
+    let (mut s0, mut s1) = (0.0, values[0]);
+    let mut b = values[1] - values[0];
+    for (i, &value) in values.iter().enumerate().skip(1) {
+        let x = sf * value;
+        b = if i == 1 {
+            b
+        } else {
+            tf * (s1 - s0) + (1.0 - tf) * b
+        };
+        let y = (1.0 - sf) * (s1 + b);
+        (s0, s1) = (s1, x + y);
+    }
+    Some(s1)
+}
+
+pub(super) fn seconds(timestamp_ms: i64) -> f64 {
+    timestamp_ms as f64 / 1000.0
+}
+
+/// Prometheus `compareOverTime` returning the timestamp: the last sample holding the maximum
+/// (or minimum), where a NaN so far is replaced by any later sample.
+fn timestamp_of_extremum(window: &FloatWindow<'_>, max: bool) -> i64 {
+    let (mut best, mut timestamp) = (window.values[0], window.timestamps[0]);
+    for (&value, &ts) in window.values.iter().zip(window.timestamps) {
+        let replace = if max { value >= best } else { value <= best };
+        if replace || best.is_nan() {
+            (best, timestamp) = (value, ts);
+        }
+    }
+    timestamp
+}
+
+/// Prometheus `funcMadOverTime`: the median of the absolute deviations from the median; NaN
+/// when any sample is NaN.
+fn median_absolute_deviation(
+    values: &[f64],
+    deviations: &mut Vec<f64>,
+    sorted: &mut Vec<f64>,
+) -> f64 {
+    if values.iter().any(|value| value.is_nan()) {
+        return f64::NAN;
+    }
+    let median = quantile(0.5, values, sorted);
+    deviations.clear();
+    deviations.extend(values.iter().map(|value| (value - median).abs()));
+    quantile(0.5, deviations, sorted)
+}

src/promql/src/range_eval/histogram.rs

@@ -0,0 +1,258 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Range functions over windows that hold native histogram samples, following the histogram
+//! branches of Prometheus' range functions. Windows of floats alone never get here.
+
+use std::borrow::Cow;
+
+use datafusion::error::Result;
+use datatypes::series::histogram::CounterResetHint;
+
+use crate::functions::{EdgeKind, count_edges, instant_delta};
+use crate::grid_series::GridSample;
+use crate::histogram_eval::HistogramAggregate;
+use crate::histogram_eval::float_histogram::FloatHistogram;
+use crate::histogram_eval::sum_or_avg;
+use crate::range_eval::function::{extrapolation_factor, seconds};
+use crate::range_eval::{FloatWindow, RangeFunction, WindowKernel};
+
+/// Histogram samples of one window at their shifted timestamps, in time order.
+type Histograms = [(i64, FloatHistogram)];
+
+/// The window of one field at `eval_ts`, holding `histograms` (not empty) and `floats` when it
+/// has any float sample.
+pub(super) fn evaluate(
+    function: RangeFunction,
+    floats: Option<FloatWindow<'_>>,
+    histograms: &Histograms,
+    eval_ts: i64,
+    range_ms: i64,
+    offset_ms: i64,
+    kernel: &mut WindowKernel,
+) -> Result<Option<GridSample>> {
+    use RangeFunction::*;
+    let float = |value: f64| Some(GridSample::Float(value));
+    let (last_ts, last) = &histograms[histograms.len() - 1];
+    let (first_ts, first) = &histograms[0];
+    Ok(match function {
+        // Prometheus reads only the floats of these.
+        MinOverTime
+        | MaxOverTime
+        | StddevOverTime
+        | StdvarOverTime
+        | QuantileOverTime(_)
+        | Deriv
+        | PredictLinear(_)
+        | DoubleExponentialSmoothing { .. }
+        | MadOverTime
+        | TsOfMinOverTime
+        | TsOfMaxOverTime => floats.and_then(kernel).map(GridSample::Float),
+        CountOverTime => {
+            float((floats.map_or(0, |window| window.values.len()) + histograms.len()) as f64)
+        }
+        PresentOverTime => float(1.0),
+        LastOverTime => match floats {
+            Some(window) if last_ts < window.timestamps.last().expect("not empty") => {
+                float(window.values[window.values.len() - 1])
+            }
+            _ => Some(GridSample::Histogram(last.clone())),
+        },
+        FirstOverTime => match floats {
+            Some(window) if window.timestamps[0] < *first_ts => float(window.values[0]),
+            _ => Some(GridSample::Histogram(first.clone())),
+        },
+        TsOfFirstOverTime => {
+            let ts = floats.map_or(*first_ts, |window| window.timestamps[0].min(*first_ts));
+            float(seconds(ts - offset_ms))
+        }
+        // Go takes the max with 0 for a kind of sample the window does not have.
+        TsOfLastOverTime => {
+            let histogram_ts = last_ts - offset_ms;
+            let ts = match floats {
+                Some(window) => {
+                    (window.timestamps.last().expect("not empty") - offset_ms).max(histogram_ts)
+                }
+                None => histogram_ts.max(0),
+            };
+            float(seconds(ts))
+        }
+        Resets => float(edges(floats, histograms, EdgeKind::Resets)? as f64),
+        Changes => float(edges(floats, histograms, EdgeKind::Changes)? as f64),
+        SumOverTime | AvgOverTime if floats.is_none() => {
+            let op = if function == SumOverTime {
+                HistogramAggregate::Sum
+            } else {
+                HistogramAggregate::Avg
+            };
+            sum_or_avg(op, histograms.iter().map(|(_, h)| h.clone()))?.map(GridSample::Histogram)
+        }
+        Rate | Increase | Delta if floats.is_none() && histograms.len() > 1 => {
+            let is_counter = function != Delta;
+            let Some(mut result) = histogram_rate(histograms, is_counter)? else {
+                return Ok(None);
+            };
+            let zero_point = (is_counter && result.count > 0.0 && first.count >= 0.0)
+                .then(|| first.count / result.count);
+            result.mul(extrapolation_factor(
+                (*first_ts, *last_ts),
+                histograms.len() - 1,
+                eval_ts,
+                range_ms,
+                is_counter,
+                function == Rate,
+                zero_point,
+            ));
+            Some(GridSample::Histogram(result))
+        }
+        Irate => last_two::<true>(floats, histograms)?,
+        Idelta => last_two::<false>(floats, histograms)?,
+        // Mixed windows, and rates over fewer than two histograms.
+        SumOverTime | AvgOverTime | Rate | Increase | Delta => None,
+    })
+}
+
+/// One sample of a window, in the order Prometheus merges floats and histograms.
+#[derive(Clone, Copy)]
+enum Sample<'a> {
+    Float(f64),
+    Histogram(&'a FloatHistogram),
+}
+
+/// The samples of both kinds in time order.
+fn merged<'a>(
+    floats: Option<FloatWindow<'a>>,
+    histograms: &'a Histograms,
+) -> impl Iterator<Item = (i64, Sample<'a>)> {
+    let mut floats = floats
+        .into_iter()
+        .flat_map(|window| window.timestamps.iter().zip(window.values))
+        .map(|(&ts, &value)| (ts, Sample::Float(value)))
+        .peekable();
+    let mut histograms = histograms
+        .iter()
+        .map(|(ts, h)| (*ts, Sample::Histogram(h)))
+        .peekable();
+    std::iter::from_fn(move || match (floats.peek(), histograms.peek()) {
+        (Some((float_ts, _)), Some((histogram_ts, _))) if float_ts < histogram_ts => floats.next(),
+        (_, Some(_)) => histograms.next(),
+        (Some(_), None) => floats.next(),
+        (None, None) => None,
+    })
+}
+
+/// Prometheus `funcResets` and `funcChanges` over floats and histograms: a change of kind
+/// counts as one edge.
+fn edges(floats: Option<FloatWindow<'_>>, histograms: &Histograms, kind: EdgeKind) -> Result<u64> {
+    let mut count = 0;
+    let mut previous: Option<Sample<'_>> = None;
+    for (_, current) in merged(floats, histograms) {
+        if let Some(previous) = previous {
+            count += match (previous, current) {
+                (Sample::Float(a), Sample::Float(b)) => count_edges(&[a, b], kind),
+                (Sample::Histogram(a), Sample::Histogram(b)) => u64::from(match kind {
+                    EdgeKind::Resets => b.detect_reset(a)?,
+                    EdgeKind::Changes => !b.equals(a),
+                }),
+                _ => 1,
+            };
+        }
+        previous = Some(current);
+    }
+    Ok(count)
+}
+
+/// Prometheus `instantValue` over the last two samples of either kind; a float and a histogram
+/// give nothing.
+fn last_two<const IS_RATE: bool>(
+    floats: Option<FloatWindow<'_>>,
+    histograms: &Histograms,
+) -> Result<Option<GridSample>> {
+    let floats = floats.map(|window| {
+        let from = window.values.len().saturating_sub(2);
+        FloatWindow {
+            timestamps: &window.timestamps[from..],
+            values: &window.values[from..],
+            ..window
+        }
+    });
+    let histograms = &histograms[histograms.len().saturating_sub(2)..];
+    let tail: Vec<_> = merged(floats, histograms).collect();
+    let [.., (prev_ts, prev), (last_ts, last)] = tail[..] else {
+        return Ok(None);
+    };
+    Ok(match (prev, last) {
+        (Sample::Float(prev), Sample::Float(last)) => {
+            instant_delta::<IS_RATE>((prev_ts, prev), (last_ts, last)).map(GridSample::Float)
+        }
+        (Sample::Histogram(prev), Sample::Histogram(last)) => {
+            let interval = last_ts - prev_ts;
+            let mut result = last.clone();
+            if !IS_RATE || !last.detect_reset(prev)? {
+                if result.uses_custom_buckets() != prev.uses_custom_buckets() {
+                    return Ok(None);
+                }
+                result.sub(prev)?;
+            }
+            result.reset_hint = CounterResetHint::Gauge;
+            result.compact();
+            if IS_RATE {
+                result.div(interval as f64 / 1000.0);
+            }
+            Some(GridSample::Histogram(result))
+        }
+        _ => None,
+    })
+}
+
+/// Prometheus `histogramRate`: the increase from the first to the last histogram, adding back
+/// what counter resets dropped. `None` when the histograms mix exponential and custom buckets.
+fn histogram_rate(points: &Histograms, is_counter: bool) -> Result<Option<FloatHistogram>> {
+    let last = &points[points.len() - 1].1;
+    let mut prev = Cow::Borrowed(&points[0].1);
+    let mut uses_custom_buckets = prev.uses_custom_buckets();
+    // A reset between the first two samples makes the first one irrelevant, layout included.
+    if is_counter {
+        let second = &points[1].1;
+        if second.detect_reset(&prev)? {
+            prev = Cow::Owned(second.empty_like());
+            uses_custom_buckets = second.uses_custom_buckets();
+        }
+    }
+    if last.uses_custom_buckets() != uses_custom_buckets {
+        return Ok(None);
+    }
+    let mut min_schema = last.schema.min(prev.schema);
+    if is_counter {
+        for (_, current) in &points[1..points.len() - 1] {
+            min_schema = min_schema.min(current.schema);
+            if current.uses_custom_buckets() != uses_custom_buckets {
+                return Ok(None);
+            }
+        }
+    }
+    let mut result = last.copy_to_schema(min_schema)?;
+    result.sub(&prev)?;
+    if is_counter {
+        for (_, current) in &points[1..] {
+            if current.detect_reset(&prev)? {
+                result.add(&prev)?;
+            }
+            prev = Cow::Borrowed(current);
+        }
+    }
+    result.reset_hint = CounterResetHint::Gauge;
+    result.compact();
+    Ok(Some(result))
+}

src/promql/src/range_eval/prometheus_cases.txt

@@ -0,0 +1,404 @@
+# Generated by promql-compat cmd/narthex-golden built for amd64 (Prometheus v3.15.0 engine,
+# seed 1, 20 cases per function; arm64 builds fuse multiply-adds and change low bits).
+# Each line: function params range_ms offset_ms start_ms step_ms points ; samples ; result
+# where params is `-` or comma-separated floats and every point is `timestamp:hex value bits`.
+rate - 3203 4376 19888 3203 19 ; 12166:c257759f462f60fd 13861:c027de5a16a21d0e 15136:40d17d1ded071630 17632:418148f1bdf553bf 20580:41816ba7ea66b83e 21122:7ff0000000000002 23954:4236130864b31007 25440:4257ec5b0b91d690 27004:c06eceb438438b02 28164:c0d3d031882af4e9 30364:c006378342e8b71a 31068:406e3b2aae250fc0 31225:40af03d6d29d9143 ; 19888:40c39d2181ca0eb4 32700:c0bd72a1c75168c3 35903:409f05b26a7b8ce1
+rate - 1000 -6914 -71 80 2 ; 3998:430c6bf5263401a9 5240:430c6bf52634010d 7243:430c6bf526340122 10184:430c6bf5263401a1 11783:430c6bf52634019c 14471:430c6bf526340056 17104:430c6bf5263401a8 27488:430c6bf52634021c 28383:430c6bf526340010 ; 
+rate - 3757 -3843 11117 2319 16 ; 7635:4034d21406576acd 8860:40394ffaec0c1b9a 31699:404af55879fcd611 32340:40597420158fe74c 33524:405b15731b652dbb 36292:4014d0b1b238afaa 38516:402a5f6920832457 40683:404369a7ea0b98f1 41846:4052a934ee09f0c6 42277:400d876865d2859f 43061:402d078367f9b3c6 44627:403f154537ec658b 46384:4049d47e571f9892 48014:401c967c3319b415 48335:40207281e6f71d36 50224:403ea598fa96d798 ; 29669:40397f728e1f5f69 31988:4007f25e0b5925bf 38945:4030843e4d739ef2 41264:40265a98b1ee0924 43583:40276c433667dcd4 45902:40097171d68d54b3
+rate - 11658 0 43636 3588 7 ; 21266:40809021a5fb5c68 26526:c08ab8d387d3fe97 27947:4084c32ac131897f 29499:40702a9d37cc1d88 31539:7ff0000000000000 32225:4084ece464d3def8 34266:c083b9bfb7a568d3 36440:c064ab2566cc29a5 38015:c08e1496a56e25c2 38488:7ff0000000000002 38663:7ff8000000000001 41312:7ff8000000000001 43430:8000000000000000 45023:408232015ff793f0 47535:c0729bb3d1304175 50403:fff0000000000000 52178:c072d6c2940717fc 53716:408cf23afcc15a23 55976:40719bac9d71513d ; 43636:c02d83683dcc242a 47224:404e03237aa6aeba 50812:7ff8000000000001 54400:405bb10b98f049d6 57988:4061e3958e20a553 61576:7ff0000000000000 65164:40433f5705518d8a
+rate - 2799 -9091 4601 1396 6 ; 7929:408dbe52f87ab7a3 9719:407f7204c589796f 10848:4063a341fc8ab550 11194:407e5078aa56fae4 11276:c070106d59806c83 13833:c08ef8e2ac6852c5 16101:408e921d0c88d98e 18910:c084382a8b0f2e12 21353:c0749cfaf244b8bc 21607:c08e6b6e65818965 22121:7e37e43c8800759c 24653:c08cb47b218bcb77 26137:408b4b5233c613ec 26742:c07420b93bf8c393 27508:c08c421b3ef065f1 28508:4073b02c0b1702b1 28516:4080996aa05b4b22 29992:fe37e43c8800759c 30332:7ff8000000000001 31962:40527d84d2f96512 33238:4011c43741b60e2e 34998:c05667bb73e50262 35473:40739b24ef721385 37507:4080df8905ceda02 ; 4601:c066f4feae8ce846 7393:408b22a6077f8ece
+rate - 1000 0 16682 731 20 ; 8553:fe37e43c8800759c 9475:7ff0000000000002 10325:4071dabb14f265d2 12466:7ff8000000000001 14577:4082536eae584dfc 15903:c08ddde6e1f5d4df 17340:c0708da5579fb417 19367:408d4be9bdd87347 ; 
+rate - 7173 -6678 3440 3583 16 ; 2236:7ff0000000000002 3938:0 4027:0 4244:0 ; 3440:0
+rate - 3836 -6183 25762 3835 1 ; 17397:c0c8521462b39f93 18932:c16f818202cc6f6c 19902:c1d3a78b931b48c0 20259:c0de6021a2f73228 23024:c03627d044a08f5e 25385:bff8831a486820ae 26787:c2874b55973da272 27071:c11ce60d485e76a9 28564:42ea49ea398cee43 30272:c2f6efcdcb17763b 30556:40109e8bb76acf48 30655:c1b876d9e5228e54 31026:c2596c867a0b3789 31223:c17c63c2f0cac90c 33475:c1b3e7ffc511a25a 34346:c2bc4293cbea9661 36145:41a4ec754ad2137b 38538:c14cbfec67bab0c2 39895:c04678afdfb0c3e2 41947:42555bc62077813c 44162:414b0b2f8671678f 44513:40a62adc6e74fc70 47313:c047a4e09c57368c 49980:c034d21848b95dca ; 25762:c1a1639e0e0aba00
+rate - 1779 -5385 5547 1779 12 ; 9173:40546bdd0752f721 10458:7e37e43c8800759c 13294:8000000000000000 15047:407dd97c2e43b518 15749:4082bf28ff62e6c5 16795:c085146c629b9af3 19411:406c65c90957e208 19951:7ff8000000000001 ; 5547:7e326235016a8a6e 10884:4065c70772dc65bc
+rate - 3109 0 25058 3108 19 ; 17454:7ff8000000000001 19583:c0872cae7cdf755e 21727:403bee1a022124c1 22553:408274bbbd7f14ab 24401:c04f39d64303bfdd 24498:407151c3332f9748 25299:7ff8000000000001 26497:40641e2205ec67f8 26561:407388c20b1f60e3 29000:c08450c9e87aab65 31672:7ff0000000000002 32200:c0890d4247d29b41 32438:7ff8000000000001 35434:406ba14a7212b86f ; 25058:4061cf23898725c2 28166:7ff8000000000001 34382:7ff8000000000001
+rate - 789 0 20854 789 13 ; 21706:c05a5aba7b28af0d 22007:40607b796c814fef 22393:407032ce92847edf 24645:408a8055f7e41d59 25104:408bd05a080e0d29 ; 22432:408095a00d872261
+rate - 1000 4269 32779 3979 11 ; 7235:408bfba5ee853fba 10042:7ff8000000000001 11234:7ff8000000000001 12513:7ff8000000000001 12897:40701dffe731a610 15056:4041aeb4a41922eb 16838:40684065de60fcd6 19156:40862a6acb43425c 20818:407c28d54b28237c 22002:40838d006662188d 23250:c081e072829e055b 24708:c07aa7bc7871c866 27173:406ddd60bb756ca4 27759:40896ce21a7add71 29964:7ff8000000000001 30801:4084075ddece13db 33709:4077a0ed85b6196f 36135:408da514f259dca5 37140:7ff8000000000001 40033:408e10420964c3d7 ; 
+rate - 2919 0 35226 2918 9 ; 18598:7ff8000000000001 21532:7ff8000000000001 24499:7ff8000000000001 26021:7ff8000000000001 28168:7ff8000000000001 29132:7ff8000000000001 31992:7ff8000000000001 34992:7ff8000000000001 37918:7ff8000000000001 38749:7ff8000000000001 ; 
+rate - 2964 0 11285 2964 3 ; 3467:40793d5682208c9a 5544:7ff8000000000001 6054:7ff8000000000001 8645:c05d5bb1075d9ff0 10859:7ff8000000000001 11502:c07156767b924f4a 14073:407d196995338e1a ; 11285:7ff8000000000001 14249:40720fd54f1caaf2
+rate - 3004 0 21576 3004 6 ; 15359:7ff8000000000001 17677:4056f9423d52ecaa 18848:7ff8000000000001 19994:c08f1e4f570fb132 34248:7ff8000000000001 35644:c086bafba7d9a15c 38000:7ff8000000000001 39205:7ff8000000000001 41643:4081dd0ac5288cb5 ; 21576:7ff8000000000001 36596:7ff8000000000001
+rate - 2063 6778 13042 2063 1 ; 4674:408d95ee6e731000 6809:407967fbfe722161 8276:406c6ca86332b730 8384:4050c3f3575a12d2 11315:408b45be8063c1a1 14299:4079301583a0d111 15788:c062d7cbd293cf59 17286:c05e2b7a44204619 19908:407820bc27d90f05 21483:c0830aad64e31af5 23689:c085ac410449b6b0 24064:7ff0000000000002 25352:407581ed5b44f5a0 25628:408d308473ac4261 26081:406415b56eb91ae5 27574:406739d15b34e566 27910:407f53a179939ae8 ; 
+rate - 1000 -8947 7146 2460 19 ; 7180:7ff8000000000001 9742:c08435237a68cfe5 10675:c058a4308b057409 13116:408ee5e8ed7e239e 14966:408d5d862c06670b 17054:7ff8000000000001 18256:40661dc09dc0494f 19445:407739f4234be29c 20658:7ff8000000000001 22200:c0781473b60f2d79 25138:c083b92521352a06 25725:4076d887837be3f2 27022:40681077f1d49b06 27137:7ff8000000000001 28541:4085a720e46875ab 31316:405d8ed0800aa28e 32159:408742a5044f6311 56912:408d16addd5395e6 58254:c0795033bdcbcbbb 60289:c07392e499eebf17 62150:c08a1e619ce1fce0 63222:c062c58546d1bbce 65540:c0715a73ed3e0b73 67117:c065fa91a4078529 68120:40764c56cc3b83b2 ; 16986:409a87a9267df5d4
+rate - 3533 -6798 18545 3532 13 ; 20173:40842fa3fd1beee5 20596:4073577016a23cb6 21493:c07fa57314a3c419 22608:c03e9aee980e0bb9 24656:c06ef950cc17bb2f 25738:408f21e24040ada8 25796:7ff8000000000001 27057:7ff0000000000002 28305:7ff8000000000001 51313:c068da8cd58128ba 51728:40820308d17ea761 54583:4077a2a6fc26393f 67337:c085810afe44374f ; 18545:c05e3f78e74f2ccd 22077:7ff8000000000001 46801:407b6d6c5244829b
+rate - 1000 1319 8707 2955 15 ; 8128:430c6bf526340216 11058:430c6bf526340261 11222:430c6bf5263400af 11889:430c6bf526340037 13460:430c6bf5263402ae 15095:430c6bf526340308 15812:430c6bf526340189 18410:430c6bf5263401b2 21197:430c6bf5263400b5 23157:430c6bf526340072 23752:430c6bf526340210 24534:430c6bf52634000d 25369:430c6bf5263400c4 27300:430c6bf526340269 ; 
+rate - 4787 9628 34901 2390 16 ; 19416:40ef169e7eead616 22037:42546f4f70dc86e7 23019:40b00a32272f75e4 24358:42fa53232bd24e1b 26461:400b9c84af38e4f8 28792:41b520add038e55c 30446:c2f0d5f17c4ff73e 32727:4111e996cce286ca 34340:c036c3e23008fb5f 35255:41140c20ee432603 37775:410418b64e30a1d3 53380:42b56758f5453864 54060:c0b1df5747db9e4d 54326:4001d9c510923282 55202:c0f0b8ccb302e3c6 57609:4132561070188daf 60096:c1906f0790d59e9c 61205:40363ad9b9a16730 61345:42889e296158fbdd 62537:42e8fc2f1c49e06c 65370:c0443651f72a0da0 68081:c2b90c392f6360f4 ; 34901:42deaf6fb6859937 37291:42ddadb38c955b99 39681:419b345ea836db6b 42071:c2dec38ddfcfe33c 44461:42d14b440ee842d0 46851:40f6de1ffbefdd29 49241:40efe635b0efbbc8 65971:c0d2a134a244411d 68361:4114bebaed125845 70751:c17a6e6ec7cd2146
+increase - 2205 -359 19097 1099 7 ; 3076:42af857241143d0a 3247:3fbdbbe7a189d878 3384:c216622de8a01905 11267:c1e39d15b5e18d03 13022:40a99c5837673fdb 14854:bff3f0e9f09951d8 16523:c1d3e53dc960d719 18666:c0d10ce701d24068 21301:41b4efc4a54249b6 23498:4223ac266220fc1d 23670:c2bac39ddb83d857 23873:c0e77097573126a1 26358:41b0f6d4775b75f4 27883:c09521294f62a4f2 27911:c117fc8c079127f9 30272:41b4734f1a5ab9ee 32274:41e7084f9c5c99b0 32962:c1744f8460e4ad87 33190:40a51c96d42f52dc 35373:c008739e0817fd48 37590:c2f0009507b3b412 ; 23493:c2d11dd90c633408 24592:c0f1947181640000
+increase - 281 -4273 15096 280 17 ; 4407:4084737e036df553 5526:4078c4d5f11af4a0 6364:c081d7cf002fbd94 8275:40811f3b9cd7e4ba 8688:4073dba50406a76f 8932:c087937acbb2d52d 10166:407703398404780c 11095:4084c178eecf0c04 12088:c08df8d0c188bc43 22570:0 23934:c0862869f04fbdec 24111:7e37e43c8800759c 24543:407c610412a92200 27232:407964160c74da3c 30067:c08943e4d0251b13 31647:c0877835a88629b9 31902:4085912119844bf0 33298:c07530f1154a26ce 33707:c0726dcc0de91b62 34674:c084e4cb8c5a68bb ; 
+increase - 12450 -4076 46590 1101 5 ; 18337:40062bd1942bd176 19534:c11829480573a86e 19663:413f0bb23a18d9fa 20522:c24f0f522310ba67 21580:40769c6139348a36 24026:3fd176b5ae3ad338 26353:3fd72dedf7d8f898 26520:c2f5052dfd816506 26619:411706e427d4a6ed 27284:4249eb2a60755a08 28820:4258d7403dde00fc 29052:42e854fe458c96ff 29455:c16561630417fe3d 31906:40a3ccae644885ae 54710:bfbc854e51cb0ee8 57428:7ff0000000000002 58221:c10262d6a67b547f 60567:c2b4ac35cc06a2f9 63277:c297be93aa0cce30 63543:c0e4a80bc8647b07 63980:c2111ec381d36924 64412:c27cb11a6f4f72de 65507:c2c36c9a9c80c3a6 ; 
+increase - 7951 0 15344 3972 8 ; 15980:4050ae1fa4396f5b 18507:4053d35b5f6da1aa 18841:4058ae30b2aab021 19081:405d6b9f2bf6492d 21948:400a85e4bfb198a8 24240:4036d33963816277 25351:40411a9995ef59f3 ; 19316:404fa87cf6208968 23288:405213e3df4d91db 27260:4044f728686c6a0d 31232:403ae6447d71d799
+increase - 1000 300 17136 1397 10 ; 13595:7ff8000000000001 16190:407f42ad49666a1f 19058:c0848dec0bc81fbc 21893:7ff8000000000001 22870:c08b6db6f796db48 24248:c08c030d63117397 27184:7ff8000000000001 27662:7ff8000000000001 29127:7ff8000000000001 30246:40800b7443c45704 31890:7ff8000000000001 33264:4060935825cd7164 36129:408588d7212d9a7c 37073:c0824b2b6acaea63 37108:c085e9fa8e3b481e 37581:7ff8000000000001 38457:7ff8000000000001 38633:7ff0000000000002 38947:c084dd878ba59d87 40578:c0651d6087baae4c ; 28312:7ff8000000000001
+increase - 899 523 33628 898 15 ; 28100:430c6bf526340119 30749:430c6bf5263401af 32718:430c6bf5263400ec 35695:430c6bf526340151 38075:430c6bf5263401bc ; 
+increase - 53 4685 37043 52 15 ; 17686:7e37e43c8800759c 18537:7e37e43c8800759c 18733:7e37e43c8800759c 18846:7e37e43c8800759c 20876:7e37e43c8800759c 22448:7e37e43c8800759c 23194:7e37e43c8800759c 23575:7e37e43c8800759c 26335:7e37e43c8800759c 28676:7e37e43c8800759c 29308:7e37e43c8800759c 30231:7e37e43c8800759c 32067:7e37e43c8800759c 34238:7e37e43c8800759c 37233:7e37e43c8800759c 37386:7e37e43c8800759c 39491:7e37e43c8800759c 41210:7e37e43c8800759c 43739:7e37e43c8800759c 43836:7e37e43c8800759c 46196:7e37e43c8800759c ; 
+increase - 7139 0 37477 3566 5 ; 15193:c08ae6f904aeb810 16195:40779370daa497cc 16868:c070d9702c4146e3 18946:408eb2d14d4cbe92 19921:c065a359ba62952c 22468:7e37e43c8800759c 25002:408cef5d1ff0695e 26240:408496f7dde6f075 29148:c07fd6c70907df29 29254:c0713268e6030ca8 29603:c070a0982d56d9de 32383:c053689749ae2bc6 32559:c06982c545a6346b 33039:408ec9304ed73696 34882:c08e4b0ce3a26434 35291:c079a1eeaebd7603 36192:4089a80a67b9b6d7 39126:405658e74652ada9 39543:406a9c9b4fc81465 39993:c086b26cbeb8af5d 40351:408be01f5c9e2b1f ; 37477:40a0eec4d05eada0 41043:40ad86caa610bd61 44609:4093e8a688edea52
+increase - 573 6839 15728 573 3 ; 1414:407578aa49371f9f 3828:7ff8000000000001 6546:407f29597350cc92 7071:7ff8000000000001 9022:c06e5597efe93953 9988:7ff8000000000001 11687:407e6d13239509b9 14362:c08068f4382f5280 14793:4084ed84d66962b1 17070:c0825e3aa6442a6b 19107:4076f4d485aaeee3 20785:c06cf8654ed178d0 ; 
+increase - 6085 -5819 18709 3039 7 ; 21480:430c6bf526340241 23186:430c6bf526340016 25192:430c6bf5263402b3 27901:430c6bf52634031a 30624:430c6bf52634001d 32910:430c6bf52634016a 35308:7ff0000000000002 36538:430c6bf526340320 38545:430c6bf5263402a4 41402:430c6bf526340021 43069:430c6bf526340054 45274:430c6bf5263400af 46127:430c6bf526340077 47723:430c6bf52634014f 48155:430c6bf526340109 50930:430c6bf5263401a2 52501:430c6bf52634022f 54212:430c6bf52634014a ; 18709:43203f5d9606d7b0 21748:40688f21f237a41e 24787:403ceb876b117b83 27826:4311437715710dff 30865:4058ca5821efe5ae 33904:431da843a2179840 36943:431e445f6eb5a128
+increase - 3167 1719 42889 3167 12 ; 16620:fe37e43c8800759c 17263:7ff0000000000002 19049:fe37e43c8800759c 22024:fe37e43c8800759c 22902:fe37e43c8800759c 24737:fe37e43c8800759c 27091:fe37e43c8800759c 28606:fe37e43c8800759c 30569:fe37e43c8800759c 31813:7ff0000000000002 33799:fe37e43c8800759c 35069:fe37e43c8800759c 35737:fe37e43c8800759c 38343:fe37e43c8800759c 53426:fe37e43c8800759c 55989:fe37e43c8800759c 56479:fe37e43c8800759c 58127:fe37e43c8800759c 59045:fe37e43c8800759c ; 58724:0 61891:0
+increase - 1000 -8325 31552 562 7 ; 9374:404dfd3642238f2f 11136:7ff0000000000002 11467:4059b658b987fccd 13378:405bf4748386c9d1 14737:405d07f9eca0093f 17438:40624a788814f427 39647:40656ce5f9d49e76 40533:406adf037785563d 41776:406c842feffbf176 41986:406d7936e55c35d3 44527:407101d543e0992d 45149:4072a928ece4ab53 45729:40739213c06029ec 46561:40761c7045963f78 49302:407689c764664fd7 72818:40799ba276dc30da 74198:407b5c37bbda99ce 74612:407c17c3b799cf17 ; 33800:40308dcdaea7f892 34362:402d762b85c8d452
+increase - 2006 -6980 75724 2006 17 ; 16752:406158861cac9c86 19286:407f719b2a3e2c20 21017:4081e42e5c1c7b0a 23424:7ff0000000000002 25838:c086038f97560f2a 28140:c06b742089980e0b 41617:c08ebb9f7edb8c9a 44429:fe37e43c8800759c 44781:c086f27a5ad4dafb 45273:c05d95f196577622 48141:c056681271f71a6f 49564:c06e977a580ad628 51971:408294bbfce4d15e 74341:c08b8ac28a7dc49e 74515:c02a4746f090f066 76147:408261ae3ebef4d2 77444:408572aabda53364 ; 
+increase - 1000 -8912 6239 2313 14 ; 2014:430c6bf526340195 2918:430c6bf526340294 5285:430c6bf52634015b 8005:430c6bf52634015c 8354:430c6bf5263400c9 9410:430c6bf52634030b 10166:430c6bf526340224 12914:430c6bf526340210 15045:7ff0000000000002 17137:430c6bf52634020e 38595:430c6bf5263401fb 39384:430c6bf5263402c1 39946:430c6bf526340136 42290:430c6bf526340002 44459:430c6bf5263401cb 45571:430c6bf5263402ed 47594:430c6bf526340019 49312:430c6bf526340233 52189:430c6bf5263400ba 53985:430c6bf526340059 56581:430c6bf5263400e7 59541:430c6bf526340157 ; 
+increase - 10586 -9561 11012 3933 10 ; 15490:430c6bf5263402c1 16816:430c6bf526340155 18055:430c6bf526340255 20417:430c6bf52634002a 21101:430c6bf5263402b8 37914:430c6bf52634027b 39158:430c6bf5263400d5 ; 11012:4321077eca2b3488 14945:4321c37937e08193 18878:4312b4bb40f5bac6 30677:4320d3abc9c190f5 34610:431c6bf5263400d5 38543:4319d709e3f7b77f
+increase - 15727 1317 50067 3188 2 ; 9171:c08b503202590e68 11822:7ff8000000000001 12930:404c755f2f064464 14044:7ff0000000000002 15094:7ff8000000000001 16779:401fe443ef8bb9a6 18166:4075b71b516cd1ea 18573:4077b9d1afeb384c 21389:c08a3600545fdf30 21533:c0869bcacd008691 22188:4084cb4671c118c8 23108:c04abbba6c434cec 25114:4079ec3557ba98b1 25585:7ff8000000000001 25767:c08b093f932f3c05 26460:7ff8000000000001 45259:c08d5becbdcf3a38 48258:c06af9602146de13 50731:c07dd5fecb61f977 52407:408924f11c267f8a 53749:7ff8000000000001 ; 50067:4092d116f060f00d 53255:4076a3ca6c7a9062
+increase - 1000 7934 9298 1933 9 ; 8825:4081b9f4199623dc 11650:c07b51de3d87c54c 12774:c0858b4a4f4a67e4 13251:7ff8000000000001 15017:40838a5d1571e3e0 15850:7ff8000000000001 17529:406391d6c0059622 19455:7ff8000000000001 21952:408aaec1c5a5f7e2 23478:4067e53bb31af3a3 26042:7ff8000000000001 ; 
+increase - 2154 0 23924 2154 10 ; 13916:430c6bf5263401ec 14723:430c6bf5263401b5 15162:430c6bf5263400e7 15231:430c6bf526340310 15952:430c6bf526340185 17664:430c6bf5263402b4 18898:430c6bf5263401a9 19509:430c6bf5263400c0 21455:430c6bf52634010e 21814:430c6bf52634011a 23395:430c6bf526340265 24332:430c6bf5263402e4 25642:430c6bf526340165 27298:430c6bf5263400e3 28833:430c6bf526340050 29339:430c6bf526340174 ; 23924:404c2f6c538d5bcf 26078:43175dd63fa70aea 30386:4052400000000000
+increase - 5948 -2512 30876 3530 10 ; 6651:414469624d49c086 9404:c2240e384941016a 11180:3fddf38d26182008 13595:c0f06251e71ad5dd 15931:c1cec99b42c7027d 18711:425de1e23713a122 19948:41121c190406f0fb 38024:c116605575460bb6 38677:c03ec56e8efdf413 39360:42fb94a07e08e653 40142:3fd61d720ca67dbe 41192:c0ca4253b36f67bb 41989:c2edb4e2c72b4aca 44479:bffcb1c079180fc1 47215:40db7a3965388ce2 48063:c28898fc6eea1552 49896:7ff0000000000002 52168:c1f27f5425f35501 54513:c013c3b658ded5fe 56910:c2411a6f4224f2bd 57331:40f12d84cce6642b ; 37936:430214be8c633369 41466:42f0cdf1abcba876 44996:42f0e7c55736fd0e 48526:c29898fc6eea1552 52056:41fc2e0e62d453f5 55586:41f54f61a414be24 59116:42511a6fcb911924
+increase - 3809 0 32655 3808 17 ; 30450:430c6bf526340239 32903:430c6bf5263401ab 35091:430c6bf5263401a0 35328:430c6bf52634006c 36787:430c6bf5263402d0 37887:430c6bf52634028e 39633:430c6bf5263400bc 42603:430c6bf526340163 44669:430c6bf5263402b6 47607:430c6bf5263401cf 49718:430c6bf526340224 52149:430c6bf5263401d3 52695:430c6bf52634021e 55524:430c6bf5263401ce 57004:430c6bf52634013e 59327:430c6bf52634001c 60005:430c6bf5263401ee 61412:430c6bf5263401f9 64354:430c6bf526340292 66261:430c6bf52634030a 66504:430c6bf526340099 66721:430c6bf526340017 76676:430c6bf526340029 77146:430c6bf52634015e ; 36463:4326524087d58caf 40271:432304f5dc43743d 47887:43126c7ea1428fe6 55503:4035dfffffffffff 59311:4315870bd89caa74 63119:4052c11d196a73a8 66927:4321d0ec00e23f33 78351:4053500000000000
+delta - 2667 -29 22426 1330 5 ; 3689:7ff8000000000001 5616:40791bc3217324e1 6529:c088678cebb69297 6531:c080bc423d2195ac 8158:4080384cd9e633b6 9961:7e37e43c8800759c 11604:406b1f19a0ed697e 13892:7ff0000000000000 16890:408b6a11ae86772a 17178:c06cfdeda631a77c 18109:7ff8000000000001 18488:408649a37e0df447 21325:40660e07d5332c2f 23267:c0823a6af1e9eb88 24217:c07c9271cb745243 26413:40739401cadca748 28025:408cb7ed597e5fb3 ; 23756:c0904d7ce7cbbb75 25086:4076225dfd4884b9 26416:408d3d1eab8a59fc
+delta - 15813 7514 16982 709 12 ; 13678:40105935be175887 14342:3fd4bfaf851d57e7 16608:403b9f787ea3f0cb 18307:40483a640359faeb 19611:4057b4984709e03f 20964:406150b845d986f4 22147:406381a7e7a64543 22189:4064deb16b117e4d 24002:40664dcefe9056ae 26465:401796cf5772e16e ; 21945:c01898510014dcaa 22654:c01e1a758b8b0611 23363:c01e1a758b8b0611 24072:c01e1a758b8b0611 24781:40415b4df3c1359b
+delta - 913 0 21295 912 12 ; 19463:0 20694:0 22041:0 23912:0 26691:0 28545:0 28972:7ff0000000000002 29106:0 31590:0 34587:0 35573:0 35924:0 38382:0 41325:0 41462:0 43678:0 45935:0 ; 
+delta - 1000 -2431 5643 649 3 ; 6166:430c6bf5263400ec 8125:430c6bf5263400f0 8806:430c6bf526340209 9343:430c6bf526340180 9886:430c6bf5263401c4 10963:430c6bf52634002e 11033:430c6bf5263400da 11783:7ff0000000000002 12332:430c6bf5263402af 14298:430c6bf526340045 16883:430c6bf526340263 17038:430c6bf526340033 17311:430c6bf52634017b 19672:430c6bf526340211 21422:430c6bf52634009e 23284:430c6bf5263400d7 ; 6941:c03fe3df9536d2b5
+delta - 1166 -6899 20507 1165 12 ; 10964:fff0000000000000 11982:fff0000000000000 12364:fff0000000000000 13362:fff0000000000000 13878:fff0000000000000 14614:fff0000000000000 15745:fff0000000000000 16475:fff0000000000000 17621:fff0000000000000 19315:fff0000000000000 20943:fff0000000000000 21090:fff0000000000000 21375:fff0000000000000 21429:fff0000000000000 23848:fff0000000000000 26244:fff0000000000000 26743:fff0000000000000 28830:fff0000000000000 30718:fff0000000000000 33244:fff0000000000000 35310:fff0000000000000 37954:fff0000000000000 40375:fff0000000000000 43149:fff0000000000000 45464:fff0000000000000 ; 20507:fff8000000000000
+delta - 6459 -4325 33402 3226 5 ; 14226:fff0000000000000 16979:fff0000000000000 19427:fff0000000000000 20066:fff0000000000000 22069:fff0000000000000 23073:fff0000000000000 25416:fff0000000000000 26151:fff0000000000000 28875:fff0000000000000 30161:fff0000000000000 32912:fff0000000000000 34738:fff0000000000000 34878:fff0000000000000 ; 33402:fff8000000000000 36628:fff8000000000000
+delta - 3256 -8002 14484 3255 3 ; 7440:c0218dfeaa1190ec 9621:4157351b0355d34c 11009:3fdf59b519f1e340 12416:4284527a84993b58 15011:400fb462b4c06346 15569:c2534e68718fd671 18465:42f5afe85b3d9320 18795:c19efef26925ec92 21534:413a3bb8105fe094 23451:40cd03e5c6919bd9 26441:42b8bdc07349eb65 29369:42292b0ddcb421fa 30451:c0e045b296a707c8 30556:c261dfac132680dd 32059:42f2fc16a6c7d84d 32322:41f1fecc24cda570 33973:4136428943bf893e ; 
+delta - 2827 0 21947 1410 14 ; 2610:407e0d3b18cc5273 2897:407d3d93110e4abc 4668:7ff8000000000001 10204:c0850fcb6d9c1e3e 10438:7ff8000000000001 10903:c088387fec9c0d02 13709:7ff0000000000002 14143:7ff8000000000001 14482:4085144ab2e79801 16038:4074b79aeffd4f00 16082:408e0e5e4b48467f 17848:c0563abdb61f511e 20313:4078c17e4c5d46b8 21042:406ef42c1089b4f2 23249:408397ef752be54a 24155:7ff8000000000001 24963:40754d1bca4b3ed6 25681:40357c44ad23e6b0 ; 21947:c0728ed08830d87e 23357:407e5eef563ec4ab 24767:7ff8000000000001 26177:7ff8000000000001 27587:c081ca49b6cb6933
+delta - 3894 8077 12989 1028 2 ; 15062:4072ed111f7a5335 17490:c084e75dc2e89948 19092:407ff0f502e1ae90 21946:40854865e3acfdc6 ; 
+delta - 1189 -9994 23276 1189 6 ; 20778:bff4ae04e3484680 22472:c08c3d2e389d7bda 24597:c081b78ef9f31ea4 26813:408c89c85f89f222 27768:4081d439dbacd9db 29804:407fcb15fbcf02ae 32593:7ff8000000000001 34937:7ff8000000000001 35007:c08a4348ab342979 36987:408b452872910b11 37824:7ff8000000000001 38019:407f87a4520e0353 38863:40897cc6b631ca3e 40114:408db13f078b9127 42346:c07f79fa97fee5d8 44551:4080e7f02d55d38d 46424:c08b80d19e3a2a2a 55062:7ff8000000000001 55896:408279254371efe1 ; 25654:7ff8000000000001 28032:c07a82d537585e1a
+delta - 1000 -6545 23869 1411 2 ; 3420:8000000000000000 4351:8000000000000000 5735:8000000000000000 8595:8000000000000000 11395:8000000000000000 11744:8000000000000000 14169:8000000000000000 16362:8000000000000000 17598:8000000000000000 19903:8000000000000000 22410:8000000000000000 22712:8000000000000000 23549:8000000000000000 24867:8000000000000000 27301:8000000000000000 29969:8000000000000000 30874:8000000000000000 32532:8000000000000000 32949:8000000000000000 34149:8000000000000000 35364:7ff0000000000002 ; 
+delta - 2657 9094 11836 1325 14 ; 14618:c13cdd6aaae62d17 17325:c2c24faeda9f4aa9 17872:c1bc65ac0192883c 19270:c1fc060a5f8cb889 22183:c1b207bedf48d645 25172:407352d0ec2fdd14 46140:41b956679afd3cce ; 27736:42d24fa0a7c949e0 29061:42c9027df45a497a
+delta - 2644 1007 16258 2643 16 ; 18457:4051da38784642ec 21321:405570007896527c 22395:405579b5bc957354 24878:405b9a1b7106cebb 26222:405cd2de4483c8b9 27473:4061ed5dbf78b1eb 28172:4066865ef41a63a0 30048:40671deeca9ee39c 46885:406b4ad87f105f9d 46943:406d5df6cd7348ab 49080:40710ecb8a832045 51372:40731e895e925ff4 53333:4074d59cac7f4cfc 55602:3ff57f3cdd1c83b5 56094:4042462463cb313c 59004:40543eab56d37f2c 61032:406024d88da0de46 64028:406042f0f90cbe55 ; 24187:3fd7e649f545e415 29473:40560039ff4b5bbe 47974:403fc39b0865f027
+delta - 12415 2444 8911 1721 9 ; 9261:7e37e43c8800759c 10236:c05edc16bf4bb17d 11693:405f1ec8c1e33535 ; 14074:fe47e43c8800759c 15795:fe41eb2d66005835 17516:fe41eb2d66005835 19237:fe41eb2d66005835 20958:fe41eb2d66005835 22679:fe41eb2d66005835
+delta - 11591 -5814 20658 3594 8 ; 21182:fe37e43c8800759c 22701:fe37e43c8800759c ; 20658:0 24252:0
+delta - 169 0 15827 169 18 ; 12549:430c6bf526340296 14779:430c6bf5263401e7 15655:430c6bf526340255 17348:430c6bf5263400e5 19622:430c6bf526340283 20482:430c6bf5263402b5 21779:430c6bf52634007b 24442:430c6bf5263401ff 25207:430c6bf5263402ca 27859:430c6bf52634027b ; 
+delta - 1000 -1772 19230 1976 9 ; 3088:430c6bf5263401db 4846:430c6bf52634024e 5840:430c6bf5263401c4 8272:430c6bf5263400e1 9331:430c6bf52634028d 11868:430c6bf526340108 12881:430c6bf5263400e2 14104:430c6bf52634010b 16056:430c6bf52634021e 18899:430c6bf526340065 20018:430c6bf5263402e3 20339:430c6bf52634014d 23312:430c6bf5263401c5 40662:430c6bf5263402b0 42060:430c6bf5263400b4 42108:430c6bf52634008a 45003:430c6bf526340150 47072:430c6bf5263401e5 ; 19230:c053a9e4e27e0199
+delta - 1168 7274 43416 1216 11 ; 11329:4046c847fe3ab8a3 12335:404b88c25060cd1f 15318:4052fb4ed7cbdaa9 17728:405a91c67583ceb0 18516:405aa7426f704b89 21516:4014ae447e0e9725 21686:4039f34f41dd3be7 24459:403f9ca2f9cbfa8b 31944:404a74e5abbf1758 32473:404c08da5903365a 34980:4059595d314a3df0 35932:4023bd866b58ab1f 38417:4045766c5a13346e 39346:40489ef3deda584e 40280:4054293cba7cbf9c 43051:405e185f74b5f5fc 43470:40637df756faf796 44381:4067417612944fe8 44660:4069d521de127c4e 45148:406ae8583dac5d21 66977:406e35e27dd57cc7 68950:401787181afe5424 71420:4044d900123726f4 71843:40563a3aebfa2906 74176:405ad83fb3a5696a ; 43416:c05c12b9b0502d72
+delta - 1000 3917 21131 3683 1 ; 19747:8000000000000000 33870:8000000000000000 57163:8000000000000000 57815:8000000000000000 58392:8000000000000000 58738:8000000000000000 ; 
+delta - 5505 -2472 16735 922 11 ; 19707:c074ab4ab419b387 21814:404c6dfa43eb93cb 24508:c08453fe09251862 25871:408999428cf572f4 26626:7ff8000000000001 ; 19501:408314c0c2537706 20423:408fa4c9acb14908 21345:408fa4c9acb14908 22267:c076eafc1cec933b 23189:c09695bf6d29fa3d 24111:4090297e2afacdd2 25033:7ff8000000000001 25955:7ff8000000000001
+irate - 6783 2384 27519 3388 10 ; 16155:41f68d42887af00d 17652:c0e7cbf9ec2de845 18318:40d8e65212d9510e 18399:c045e68f2081e975 19343:c002711124506550 20970:c02164695e61fec9 22485:40586205e4bee566 36614:4088f35627b41ab6 39174:4101ad4371fb0b22 39445:42f7424bbd607f61 40145:c22386915bca5a97 41563:4135748d0d12a641 43827:c07b0d9aeee2817b 44262:7ff0000000000002 45656:c0b11b5fd1bdac4c 48057:c0423468dd605a12 ; 27519:4051878205d9bba6 44459:421b8a670f34808a 47847:c067e6069af1b46b 51235:409c43429284993c 54623:409c43429284993c
+irate - 3466 -997 1969 3465 6 ; 1194:430c6bf526340216 3080:430c6bf526340180 3368:430c6bf5263402e0 6173:430c6bf526340167 6710:430c6bf526340199 8877:430c6bf5263401c2 ; 5434:42f443d93ba37bc0 8899:4002eb9001e3e23b
+irate - 15037 6406 19364 430 2 ; 10250:4034e864e98dd5f4 12582:4041b9417b8bc474 12858:404e417495d9c02f 12984:4057b4fc0b9d9cea 14921:4060fcab4f8fa695 17673:406390dfb848e7bb 18152:4063e6c520ad222b 19948:4064abbc0d2434e0 20266:4066a5cfab5bc136 21162:406c71e08645a7b3 22587:40705dac794a0803 23832:40725a75851766a1 25466:7ff0000000000002 26344:407427bb74f74bd3 ; 19364:4056b3f4b18224c9 19794:407105a7087b1d40
+irate - 6443 -1071 9125 3218 12 ; 10752:407323d58744bac2 13113:40874f7de933a7c6 13217:7ff8000000000001 15033:4086c3e7af6e090f 17576:c0868514c7c8237b ; 12343:7ff8000000000001 15561:7ff8000000000001 18779:c071b6142b2a8a70
+irate - 5033 7462 9094 2513 14 ; 8218:fe37e43c8800759c 8298:fe37e43c8800759c 10445:fe37e43c8800759c 11906:fe37e43c8800759c 13932:fe37e43c8800759c ; 16633:0 19146:0 21659:0 24172:0
+irate - 1000 9003 4248 2654 15 ; 6128:40727c5f010640b1 6299:c0822b75986fe033 7923:7ff8000000000001 10294:408777278dc78706 10405:c0635557f1c02be7 13040:c080f90c561c60aa ; 20172:c095c595c670a024
+irate - 3649 0 12626 3648 4 ; 14472:c07d53ac65a8a2e7 16396:4105e326b3b01aab 17027:4174f957f85d89d7 18656:c250b8f14d151a1f ; 19922:c24487ea2e8ca0ef
+irate - 1048 0 -147 1048 5 ; 2476:405d5585a7d02eda 3201:4061235bffbe0f0d 3799:4062268f88aa331a ; 4045:402b1726ed03c492
+irate - 585 0 10330 585 4 ; 14677:404fd381293676ca 15616:4053a471c3512526 15903:405d88e635a2fed0 16242:4060f5eec3ae190c 17039:40656f7e05523629 ; 
+irate - 3251 0 10893 1495 2 ; 7598:7ff8000000000001 8349:7ff8000000000001 8920:7ff8000000000001 9601:7ff8000000000001 11260:7ff8000000000001 ; 10893:7ff8000000000001 12388:7ff8000000000001
+irate - 1000 8061 18161 1111 16 ; 18572:4281be79acb34c5b 21084:c2244878995fd99e 22102:40024669a7baa072 ; 
+irate - 2345 0 36206 1169 2 ; 16037:c078e74cbe172082 17057:4084054b5b598ba1 17234:7ff0000000000002 17596:c08064ee64697ffc 18913:40880e4add8ae302 20489:407d10f5ead7df81 21450:4063bc4a40189d0c 23869:c082c26eb523a4e3 26860:7ff8000000000001 27288:7ff8000000000001 30163:c0522ba35645982a 31716:c07325c4e58eb30c 33631:7ff8000000000001 36287:c0816689d04c54ba 36350:c08527b5252611c2 38026:c073474f38396d7b 40343:7ff8000000000001 42743:408d0b977011013d 43311:408ac6238ad4aeab 46201:c07df4d1cc0eb22a 47264:7ff0000000000002 49827:7ff0000000000002 ; 37375:c0c4fcb9cd7d21df
+irate - 1000 -790 28563 509 10 ; 14414:7ff8000000000001 14675:7ff8000000000001 17590:7ff8000000000001 18605:7ff8000000000001 19888:7ff8000000000001 21372:7ff8000000000001 23388:7ff8000000000001 24039:7ff8000000000001 26610:7ff8000000000001 27680:7ff8000000000001 29872:7ff8000000000001 31656:7ff8000000000001 ; 
+irate - 3075 7419 13286 2849 4 ; 9121:bfd41e65ecf13040 9885:c201206fe6680ac2 10882:422686f11aac990b 17787:c2c160f3f366b119 18057:4252a28488b40c91 20980:c0a32039e39cb893 23886:c2c74c5b6868b253 25353:3fcce2e2797953a0 27983:41d25563e1fb8b5a 28696:c0155e174355f9ca 30535:40b2647777909e31 33502:bff4fa599c81236f 33710:42531cadb7a2751b 36431:41b9af857ef28e0c ; 18984:422ae3b3c3328934
+irate - 2333 5069 18781 2332 16 ; 11163:fff0000000000000 12721:fff0000000000000 14128:fff0000000000000 14446:fff0000000000000 15180:fff0000000000000 15261:fff0000000000000 17552:fff0000000000000 20060:fff0000000000000 20299:fff0000000000000 22834:fff0000000000000 23416:fff0000000000000 23889:fff0000000000000 24944:fff0000000000000 26864:fff0000000000000 28153:fff0000000000000 28872:fff0000000000000 29516:fff0000000000000 53889:fff0000000000000 55361:fff0000000000000 ; 21113:fff8000000000000 25777:fff8000000000000 30441:fff8000000000000 35105:fff8000000000000
+irate - 2231 3217 17095 2848 17 ; 18547:430c6bf5263402dd 20769:430c6bf52634024d 23231:430c6bf5263401f0 23487:430c6bf52634014a 24508:430c6bf5263400e7 24732:430c6bf5263400d8 25298:430c6bf52634000b 25550:430c6bf52634017c 26365:430c6bf5263402c0 27326:430c6bf5263402b8 28111:7ff0000000000002 48507:430c6bf526340021 63927:430c6bf52634025f 65586:7ff0000000000002 ; 28487:432fb87d085a0a15 31335:430d933c5e18d18c
+irate - 3167 -3586 10994 3167 5 ; 11257:c03301947166532b 12101:c14430a44b98cf2c 13279:40de3deeb9ed08fc 14970:414359d4e57e1fe9 17767:c0a2dd229af0d6ff 20208:41b4b097b9f91961 22418:42c4b833268c3bcb 24938:420f3e59ee98b558 27723:40f2317530cd91cb 29698:4043f49c51a95c22 31764:4027b1c6df1f5052 33971:c1a59d31bc24e35a ; 10994:414156fc7114be9c 17328:41a0f3b895d6646b
+irate - 3684 0 17801 3683 16 ; 6626:4068fb23991f4d3c 6629:4187a8d70f8feb0a 8301:c221f8f3ca9fc702 10783:422742b6723d6c5f 11372:42b31f5f7b464c7b 13745:42f9ca007d682994 14031:3fc11e8767914348 14994:c2b568f1a0fbb445 16688:4257eb3abcdf290c 24785:c10510a1b173793d 25883:40d1ef7c6bdffa70 27775:bfd8b83540518c2d 28426:c03ee665613285a0 30116:c1eeb6b7eb688bdb 37378:c06f129b4d8337d8 39748:415006b432b0ee0e 42492:425691f692a10cf8 ; 17801:42a9b7f7551e065d 28850:c047bb92ae891d18 39899:413b0ccdf2562b68
+irate - 1798 -8422 10645 1798 19 ; 14070:4086f20d645c8d41 16694:c04271c34eb5562d 18787:40754ef1d8c41462 21130:c05e2b976987bb18 21616:406031ab2a0ea61a 24234:407d33f731b9a968 25993:c075079fe3c19241 ; 14241:40801710e6815bf4
+irate - 1000 0 37996 3689 16 ; 19353:430c6bf5263402a8 20787:7ff0000000000002 20909:430c6bf5263402b1 21663:430c6bf526340115 23591:430c6bf5263401a8 26512:430c6bf526340088 27617:430c6bf52634028d 28107:430c6bf5263400c6 30147:430c6bf526340315 32981:430c6bf5263400cc 33572:430c6bf5263402a8 36236:430c6bf5263401b9 37011:430c6bf5263402fa 39328:430c6bf5263400ee 40449:430c6bf52634009d 41017:430c6bf52634000b 43968:430c6bf52634021b 46579:430c6bf52634015c ; 
+idelta - 1385 -3851 22608 1385 4 ; 13122:430c6bf5263401fe 21001:430c6bf526340083 22961:430c6bf526340192 24036:430c6bf5263400af 24425:430c6bf526340266 27113:430c6bf52634030d 29862:430c6bf526340269 30298:430c6bf5263402aa 31187:430c6bf52634016f 33805:430c6bf5263401ee 35111:430c6bf526340053 ; 26763:4020400000000000
+idelta - 19392 -8101 8124 1446 1 ; 9033:4035d20fb2ce27f2 11082:404e12ebe33238e5 12883:40562dcda594fc21 12942:40610839f52b2231 14966:40647b8cb95543cf 17374:4068cdaf78685a6a 20152:406e30c251ff0e35 22167:4071750f1def3ae2 22231:40722e9ce801d510 23276:4074326dace2e7d8 23966:4076c15ca9f9fdd7 24792:4077986eb5059868 25831:4077c52cfcc7384a 26056:4077fe22a9b9b6d0 28165:407901566569a507 28658:40790a5aad6de1c4 30398:40794c7e02410aea 32464:4015dc28917e4bf6 34167:4040ec3bbc31abe2 34246:404ed817c57a3cda 34811:405753387d082ac2 ; 8124:403b9a9621510cf0
+idelta - 1651 7553 11861 822 8 ; 6825:c073479ec5b3d557 9267:4060492dc8bb8288 11881:4089e3bb8f268739 13793:c085b1d9912d67b5 16306:c088cf9f0588dbae 19108:c06924072bfe46cd 28436:c08ad3cf2343b071 29841:c08b186941a817e8 38822:7e37e43c8800759c 41156:404a00684e2b8154 42896:c07a479bcfb47838 44860:4085e584de35c5fc 46529:7ff0000000000002 47273:c080a26bc6916dbb 48440:7e37e43c8800759c 65410:c0814eceedf1c738 66821:40315fc7f747b4ae 68836:406a3ca87dd0836d ; 
+idelta - 793 0 18824 792 18 ; 13920:7ff0000000000002 16504:430c6bf5263402eb 17772:430c6bf526340293 19259:430c6bf52634031c 20808:430c6bf5263402e2 21239:430c6bf526340004 24211:430c6bf526340283 25493:430c6bf52634026b 26586:430c6bf52634027b 29492:7ff0000000000002 30086:430c6bf52634028a 30564:430c6bf5263401f5 31065:430c6bf5263401c1 ; 30704:c032a00000000000
+idelta - 794 1804 30101 794 8 ; 10247:c0818979f3eccfb7 10608:406f75f4760e7298 11897:0 18833:0 19888:4086ae800f9565e7 26801:c05e900d49c9cdb6 28081:8000000000000000 28722:c0896d9dd466d973 30223:c08270c0da976680 32790:c0813084deb20816 34098:4084ddbca5dad28c 34183:408d32da37bb9630 36401:40835fab2891511c 37472:fff0000000000000 39674:c07bdf544aaf9bc7 39881:407586e8db79e388 41850:408b099eae902373 43693:4082ab77bedd31bd 45985:40438b18d9346e27 46263:c08670f821ef7032 48148:c08d6988877dddf7 48773:4064ad625efd8de1 49097:7ff0000000000002 49133:c08c706a53cef5ec ; 
+idelta - 1923 0 70798 958 4 ; 9638:c0885dff6fbc9202 11009:7e37e43c8800759c 11782:c04b1bc35895f1cc 12594:4081920fb2fd1078 14379:4072f8d1edda21ff 17079:408d3206a8475ebf 19351:4089a9ed08454af8 31924:c08453ccbf8ceac1 33253:c064d5bc421eac21 35472:c06e17c7a136b61a 36464:407750ae00999f12 37983:4060e2b3cdff3a18 38267:c07b3344421f6c38 40080:406c7195027d61d1 41590:40576aac42ef1343 42251:4086bf0c0fbdda5d 43066:c063a63a4c79888c 45992:c08002cc3d0a5062 46793:c060c0f72cd308e8 66271:4078dec57adf7a25 67534:7ff0000000000002 68268:4059732b6a1c8b71 70965:c05b9c7103d3fbed ; 
+idelta - 17661 9682 13464 697 1 ; 12171:4081980f711808e8 13887:c0435da38840806e ; 
+idelta - 1505 -5209 69247 1505 4 ; 9991:404cee0064cd50a2 12569:404f414a4b626b3c 15210:404f89da75032797 15736:4056879ca25b42c2 16033:405d08069984c279 16233:4062e9cfef08c896 18565:406923220f4054ea 38335:406e4152067e2e2b 39985:401c981c5aa66b6e 42264:4011750e2a371bc4 44561:403e797436e204e2 47305:404448d82f2c240d 47778:4050df069ae5590c 48244:4059a438b3fe03fa 50634:40603030deb03b66 51437:4064eb1d2f8b6583 52530:4064f6df6ab84f5e 52604:406a1b3e0016be1a 72237:406b73bd141d8cfa ; 
+idelta - 2999 7252 54941 1496 13 ; 9127:c0ad926b6dbd7cb3 9751:c05cd1f9bfe338cb 10720:4093e00af96278f0 13170:7ff0000000000002 26713:c25c032eb1cb0711 49676:c1b948b89e62fd01 51902:c20eb0d051175c9b 53755:40711bd1c09dcba5 55983:40c986f5a207b82c 56779:c007da705b7d3cae 59595:4010c07e11e2f3ee 61117:4180753f0520322e 63665:3f950457e908de80 64788:407e1cdc61a73599 66620:c0007db634acfdd3 69524:41e949a60570f33b 70556:41a455421989ac5f 70641:3fc7465e5e15f41c 86782:41a5ff9c922efa0d 89697:423a61aa0f0ded31 90692:c1acea16e37b8dbb 91192:411b4eb12219bbee 93209:4074fdfa8f12830b 95974:c06b1571d9fdf87f 98122:c245eed0cfe20b44 ; 59429:c20de68a8c2444b3 63917:40c8fe171402c9cf 65413:c0c98873490d7000 66909:401cadb63fa19245 68405:4180753ee39f360a 72893:407e1c8850479176
+idelta - 1000 -814 53882 747 12 ; 19521:430c6bf5263402b2 20452:430c6bf52634015b 20983:430c6bf5263402b1 23456:430c6bf526340112 32242:430c6bf526340026 34896:430c6bf52634008a 36828:430c6bf526340026 39263:430c6bf5263400bb 41568:430c6bf5263402b7 43575:430c6bf526340267 43881:430c6bf526340022 46537:430c6bf5263400e0 49111:430c6bf5263402be 51153:430c6bf5263400e0 52432:430c6bf52634001d 52465:430c6bf526340208 52661:430c6bf5263402c6 53018:430c6bf52634016a 53124:430c6bf526340215 55608:430c6bf526340104 57991:430c6bf52634022d 58449:430c6bf5263400c8 61286:430c6bf5263401cb ; 
+idelta - 1331 0 29904 662 7 ; 21434:430c6bf5263402d6 23098:430c6bf526340100 24140:430c6bf52634003f 24454:430c6bf52634005e 24762:430c6bf526340121 25292:430c6bf5263402bb 27659:430c6bf52634029b 28745:430c6bf526340088 31512:430c6bf526340030 33166:430c6bf5263401f5 34256:430c6bf5263400fb 34274:430c6bf52634011e 34282:430c6bf526340217 36381:430c6bf526340210 37380:430c6bf526340211 39583:430c6bf5263401d6 40735:430c6bf5263400b9 41062:430c6bf526340014 43486:430c6bf526340194 ; 
+idelta - 1000 0 20814 1617 3 ; 4862:42b80676331639d2 5007:41413cfc9200b101 5763:4182662398892c25 7891:c15645e6401a5721 9507:3fdac07853940c1e 10201:c175ff53dfa90e2b 11336:c2535b75f5e3386b 12905:c248bd29555bafe5 14451:422a3771417c2403 15171:c01123de3836d658 17930:c0cb26ba7a4e3a64 18594:c0934ea17d5bb4e0 20545:c183be6ee16e4e03 21149:7ff0000000000002 23687:c2ed25941952b815 25327:c1d81e9d88c101e9 25377:421c598524d5225e 27877:c0fbd7dd44e1aea8 30007:c114b5db16acf21c 30384:4012f2f092e7f5e2 30528:c0103e88812556e4 33339:42bbb925f0ea1c96 35692:c2b57a78b653fd9b ; 
+idelta - 1000 1651 25168 2932 16 ; 8622:7ff8000000000001 9267:4019523a8ffda252 29448:7ff8000000000001 31740:c08c83ecfa4d6718 33281:c082cee444b7d2dc 33298:7ff8000000000001 35152:407427c8f5a85612 35564:4083344a12102a05 47209:405469b606e108b2 49915:7ff8000000000001 60449:40785bb72ea99361 60924:c08b4ea1d6c4852f ; 
+idelta - 15927 0 2927 408 4 ; 2468:7ff0000000000000 3082:7ff0000000000000 4094:7ff0000000000000 6258:7ff0000000000000 ; 3335:fff8000000000000 3743:fff8000000000000 4151:fff8000000000000
+idelta - 1081 -9753 46140 1081 4 ; 17941:40554404189676bb 18044:4059f547cbe0fd20 18602:405a8776efe8d300 20928:405ae52915f67236 21330:405bec02a8f112f9 24185:4060be8f5260695f 24647:40632769b9cee10c 43053:4064999c8057fb32 43066:4067ef4919293941 45501:4019e4b100290d9b 46277:403f0e5caecb9059 46945:404fc8ec35db67c2 47422:40583f743e995368 49792:405c515f5b890527 50745:4061e432717c898c 51170:3ffeb6f11053c57e 54016:403eea53902989fa 55991:40495d2f7d1005e9 57075:4053e2e12e5a1753 57611:405637b0e2b8c5f0 60420:4060bdfef6595fe5 67342:4063a5ee01b6c64f 69759:406630d21c02d59c ; 48302:4022a67da2f574e8
+idelta - 932 2237 17001 932 13 ; 6978:7ff0000000000000 9602:7ff0000000000000 12378:7ff0000000000000 14888:7ff0000000000000 15714:7ff0000000000000 15936:7ff0000000000000 17367:7ff0000000000000 20284:7ff0000000000000 22090:7ff0000000000000 24048:7ff0000000000000 26792:7ff0000000000000 29685:7ff0000000000000 30701:7ff0000000000000 30843:7ff0000000000000 32163:7ff0000000000000 34925:7ff0000000000000 36858:7ff0000000000000 39504:7ff0000000000000 40211:7ff0000000000000 43077:7ff0000000000000 45309:7ff0000000000000 ; 18865:fff8000000000000
+idelta - 7143 5280 14870 3568 13 ; 19231:7ff8000000000001 22031:7ff8000000000001 24263:7ff8000000000001 25751:7ff8000000000001 26810:7ff8000000000001 26992:7ff8000000000001 ; 29142:7ff8000000000001 32710:7ff8000000000001 36278:7ff8000000000001
+idelta - 1000 7302 11518 889 1 ; 7076:7ff0000000000002 7401:4144d72474f9bd95 8351:c1c351cd3df2f077 8988:425bd95e844cb487 20105:41db9693b7e77758 21853:c27f00f3150912e8 24492:bff646e5e6bea066 25953:40667a203e3a63c2 26014:41a3a178f626512f 26529:c111e031313d9304 27505:406027b02d0719ae 27638:3f60dd5cfc496e00 28762:c1513804453d7795 29191:40b687a744a04c6e 29897:c0998a13f6ecfcb6 32729:403df34c067e65b1 ; 
+idelta - 1268 0 10231 1267 12 ; 7489:430c6bf52634004e 7895:430c6bf526340083 10298:430c6bf526340217 ; 
+idelta - 77 0 119967 35 1 ; 17495:423dfb2af8ac4f8a 19308:417759f36e6a2206 20085:428643124d3a4cf6 22511:40771deb7d522076 24239:4073146ce16327f4 27103:425bfa1b287ccdf0 28282:c04b7e7261827e5b 28766:4291a1e97c25f472 49609:c16039fdc94bae6a 69164:bfc58f58e940b4d2 71816:c03cfac915d1f7c0 71918:42580b7a1f1ebc69 94500:c0f029a36fcb2477 95969:c1e133dd806d4294 97004:c06ad948c4e917bd 98210:c0410c577d23c264 122006:4030278775249abf 123011:c2f98b94fb8a403e 123576:c057967bcf07eb84 124331:c2a19ce2b0a293bb 126027:42a1d27200b5bdf2 127390:c1ab1dfc2156db3f 128888:c1f05bd400b1241c 129666:c070e73b43456cbc 130038:c2e94b7c1785d75c ; 
+avg_over_time - 1635 -2422 49962 1634 3 ; 19656:4061b660c9675127 22164:c1e4ca0b73833261 23320:41517f18751b6338 33903:428179fd854c3313 34223:4100e0c3fb68a13c 34317:c101790ee464db18 36005:403d7b6474cd3aaf 38169:40e3b81271f5fc55 40700:c1fc736e15a76a22 43601:c0e82e17bb53f877 45377:c01341a520ad41c0 45992:41066b3c8afdde99 48041:c0df36e54dc54145 50916:bfca1c93d3566636 51074:c176f00926d32e61 62690:c2d7ec258767627b 64987:c0a0a281ed11dae4 66516:c21e48ad8d25c817 ; 49962:c166f0092a16c0db
+avg_over_time - 1000 4336 8399 851 8 ; 1815:fff0000000000000 2266:fff0000000000000 4861:fff0000000000000 5347:fff0000000000000 7090:fff0000000000000 7944:fff0000000000000 9426:fff0000000000000 10131:fff0000000000000 10322:fff0000000000000 10335:fff0000000000000 13142:fff0000000000000 25223:fff0000000000000 26735:fff0000000000000 ; 9250:fff0000000000000 10101:fff0000000000000 11803:fff0000000000000 12654:fff0000000000000 14356:fff0000000000000
+avg_over_time - 7701 -2866 23453 1695 8 ; 1720:430c6bf526340261 4272:430c6bf5263402c8 5900:430c6bf52634004c 7297:430c6bf5263402e8 8847:430c6bf5263402fe 18867:430c6bf5263401ce 19181:430c6bf5263401df 19777:430c6bf52634006e 21109:430c6bf526340256 22685:430c6bf52634021f 33746:430c6bf526340085 36034:430c6bf5263402dd 36962:430c6bf5263402a8 38337:430c6bf526340290 40327:430c6bf526340153 42909:430c6bf526340067 45045:430c6bf526340226 45375:430c6bf526340008 46677:430c6bf526340064 47602:430c6bf526340260 48212:430c6bf5263401a8 ; 23453:430c6bf5263401b6 25148:430c6bf52634023a 26843:430c6bf52634021f 31928:430c6bf526340085 33623:430c6bf5263401b1 35318:430c6bf526340204
+avg_over_time - 2188 -9047 27103 2188 19 ; 3857:407e03cbbe7439ba 6636:c08d69adf3c08d13 8301:404ce93a1449af02 8637:7ff8000000000001 8740:4086f56ee3967ef3 9768:7ff8000000000001 11987:405bc3f62d5acff7 13625:40889f2b7f233ea4 16158:7ff0000000000002 17669:7ff8000000000001 20379:c081e09da7960f80 20822:407a9475037a8e8e 22742:c07b4c6a8ded9ecb 24927:406802b2bbdff6a7 25528:7ff8000000000001 26338:c0879543eb44c4a0 26825:c06e8094822fccef 27466:4063b7f76a828ac0 28048:40839e95378c58c8 ; 
+avg_over_time - 41 9946 38356 40 13 ; 14126:c0109ec7df3103a7 15742:c074610ccb099e64 18356:404d0641f61714b8 19297:7ff0000000000002 19509:4082b425af45debc 20023:407e5320f12cd5fc 35787:c075f19f5fe3ab77 38195:7ff8000000000001 38216:c065f76b3cd27600 39168:c0737626d6682b7f ; 
+avg_over_time - 3376 0 7416 3375 2 ; 10115:406d2301b62b401a 11192:4072715243946ef1 13672:c08ad77ec7d93087 15403:c07bde3027dbc509 ; 10791:406d2301b62b401a
+avg_over_time - 3965 0 36443 3964 19 ; 11163:c22299a3daa407bd 13695:42214b62f2abaae7 14763:40dfec45a7f8d951 16085:c27ac1b942b77483 17625:412af65ddce1cf12 19075:4141fe879760664f 20504:c171804deb5a4256 20927:41f143652259528a 23222:c23b6af04a787d77 44875:42f7dc03cc2be3bf 47084:c0b0d9e42c518a26 49909:4055ebade2d4166b 51201:bfec1b9d9e9726d8 52988:3fcb83c9f3113144 54194:4066c0d15f1bdff1 55056:c11e23671289c482 55851:c2187a2706006290 57299:40a36d63d3db305c 59383:40d234ca08c38556 61339:c2c68ac38b8c3b26 62777:411ab3937d89aabb 63658:c1b20c7f14056fd3 ; 48335:42e7dc03cc2ad621 52299:4045b376a796e81d 56263:c1f87a45268e7ed0 60227:40c4a276833eeb62 64191:c2ae0e66134718f7
+avg_over_time - 3618 0 4011 3617 7 ; 8926:430c6bf5263401b5 9158:430c6bf52634014a 9298:430c6bf5263401d2 11170:430c6bf526340104 13476:430c6bf526340110 13754:430c6bf5263401d3 ; 11245:430c6bf526340175 14862:430c6bf526340172
+avg_over_time - 3029 0 9859 3028 6 ; 13819:404a6ddd30d0d970 15632:4051004780199ba8 15887:40599bb6076ee0b0 ; 15915:40529ba40aa5a305
+avg_over_time - 1000 16 3219 2022 14 ; 5191:c21b7beff5430e78 7984:407edba4cfc45438 8693:c152f42859b391ec 11525:c0be779ccccf4413 ; 5241:c21b7beff5430e78 9285:c152f42859b391ec
+avg_over_time - 77 -2784 17410 2178 3 ; 20833:4059a5ee846b7bbe 21113:405fee42fa525b4c 21416:4065000403108368 23105:40670b460ba36c06 24778:406caa864b41d61f 25876:40700cda2556356a 27748:40714221a5617907 30680:40740ff1c9c7698a 32477:4075cf0f9b9a21d6 35007:407791d0be8f03a8 ; 
+avg_over_time - 3811 1357 6061 3811 15 ; 10818:430c6bf526340029 12851:430c6bf5263401d9 13873:430c6bf52634024c 15411:430c6bf526340160 16575:430c6bf5263401f0 37019:430c6bf5263401a8 39453:430c6bf5263401e4 39759:430c6bf526340315 41474:430c6bf526340107 43334:430c6bf52634031a 45625:430c6bf52634010c 48124:430c6bf526340028 ; 13683:430c6bf526340029 17494:430c6bf5263401d7 21305:430c6bf5263401f0 40360:430c6bf5263401a8 44171:430c6bf526340200 47982:430c6bf526340213 51793:430c6bf526340028
+avg_over_time - 3772 0 23292 3772 9 ; 10656:430c6bf526340017 10864:430c6bf5263402be 11599:430c6bf5263400db 11962:430c6bf52634007e 12293:430c6bf526340268 12720:430c6bf526340142 13183:430c6bf5263400c9 14696:430c6bf526340096 16481:430c6bf52634009a 17142:430c6bf526340211 18651:430c6bf526340221 19753:430c6bf526340063 22678:430c6bf526340228 24172:430c6bf52634029f 24212:430c6bf526340121 27113:430c6bf526340175 30019:430c6bf526340163 31144:430c6bf526340106 ; 23292:430c6bf526340146 27064:430c6bf5263401e0 30836:430c6bf52634016c 34608:430c6bf526340106
+avg_over_time - 11321 0 21905 3172 11 ; 17557:c086ee64d4707fe5 19531:40635bb7c7917b73 21896:4060344e33bc87dc 24275:c07083272ec30582 25135:c0825e84380560f6 27434:c081d36f482fa1f0 ; 21905:c062b8847226a96c 25077:c0664bf6ecfe81d2 28249:c0737f4e24668193 31421:c0743339c553b1d8 34593:c07da25a0fb9ae6f 37765:c081d36f482fa1f0
+avg_over_time - 1139 -8660 30630 2555 4 ; 20107:430c6bf526340218 20800:430c6bf526340029 21103:430c6bf52634008a 22458:430c6bf526340023 23854:430c6bf526340093 26667:430c6bf5263401e0 28103:430c6bf52634016b 29747:430c6bf52634002d 30044:430c6bf5263401c1 32246:430c6bf526340289 34466:430c6bf52634004a 36842:430c6bf5263401f5 38377:430c6bf526340018 39390:430c6bf5263401a9 41811:430c6bf526340038 43506:7ff0000000000002 46437:430c6bf52634021e 47073:430c6bf5263402a5 49645:430c6bf52634028d 51258:430c6bf5263401ed 52400:430c6bf526340282 54484:430c6bf52634003d 56969:430c6bf526340100 58769:430c6bf52634029c 60923:430c6bf52634013c ; 30630:430c6bf526340018 33185:430c6bf526340038 38295:430c6bf52634021e
+avg_over_time - 4415 0 36964 2204 16 ; 13926:4060a38145180df5 23109:4065bc5025056a22 30840:4067d99a559d2c44 33225:40683dd8a79774bc 35124:7ff0000000000002 35816:406b80f41870fa25 37109:407067f969bc8bc7 39133:40707b0729eb24ab 39176:4070bbfcffebb2f0 39386:7ff0000000000002 41225:40204b5584b4c772 41674:404236aca6787cac 42694:40463ecfdb705f2a 44531:404645b30a4ad66a 45283:405576729139d475 48137:405aae58742cdd02 49146:7ff0000000000002 50937:405cfa476d8124e2 52021:40604f30fb61ea59 52257:4062596c30e3ebf7 53855:4067adfe87042230 55849:40695f6c35c2c0c0 57237:4069725bc7bce1c5 58956:7ff0000000000002 60108:406a361da668a481 ; 36964:4069df6660043770 39168:406f17a715401e58 41372:406910ac1fdc84cf 43576:40564d073c4e74a6 45780:404a6a052ba9d6ca 47984:40504ca60b2f9fd5 50188:405aae58742cdd02 52392:405f3e768e8e6ba1 54596:406234efda82a2bc 56800:406886b55e637178 59004:406968e3febfd142 61208:4069d43cb712c323 63412:406a361da668a481
+avg_over_time - 1000 686 8864 2388 10 ; 10421:4087874ec1dd1b66 12351:c08665ccabb5e73c 12913:7ff0000000000002 15860:4083f790a87f9775 ; 11252:4087874ec1dd1b66 13640:c08665ccabb5e73c
+avg_over_time - 747 7170 27308 746 2 ; 18751:407d8b9aec20bd2b 20299:c08365d03c10a671 21397:c07e64bf76445a70 23826:7e37e43c8800759c 25137:c06b0becfacc2bef 26441:c08ef46ae49fd408 28071:4085c73e25f78781 29811:c0877b33da1aa8e7 30145:c087a9e60dee25ab 31432:c07c28d57e0ce147 33865:7ff0000000000000 35227:407500fb8a693a17 37492:c06e7053ea52be20 40473:406a4320f3dfaf46 ; 28054:c08365d03c10a671
+avg_over_time - 2676 -3388 11826 2676 2 ; 2831:407c46d2e70f5551 3577:c06c7e0c6460dc7b 5274:4072d430361a1297 7368:c051f5185a5d51e9 9314:c08ce10f4261b80b 9753:7ff8000000000001 10702:c06f3b312dad484e 12712:407216e47328c489 13111:c07cda4b7e34b468 16085:c0622be5ecc0016f 16556:c08be4835bb6726c 18631:fff0000000000000 20349:c0818a51d6a72feb 22902:c08c8af046d44177 23044:c0190216304695fe 24231:0 25748:c071a9cadb5a047f 25958:4072d6c2d3192d6a 28099:7ff0000000000002 28230:408d62761c309491 ; 11826:c05586ce1617dfbe 14502:c08037be6b733964
+avg_over_time - 1000 0 10902 1099 7 ; 3348:7ff0000000000002 5665:c2535356b6e5d8f5 6078:4152dc7921650ba5 13120:c1f1a8ac0cc845c6 14180:c043d828335cf890 14406:41129d4558808e25 16151:3fd3eb24a40e5cf0 17597:c119e43d16571434 ; 14199:c043d828335cf890 15298:41129d4558808e25 16397:3fd3eb24a40e5cf0
+min_over_time - 3181 0 22274 3181 17 ; 6224:40005ab1b3bb8377 7440:40314531fb4634c8 9819:401d48dbd04f6b9c 10068:403efc1d5ef49aff 12216:40526e89d9744910 14739:405271a4be55e71e 17236:4059364bb5c39960 19213:405c105bbcf28c8c 31985:40629e4aa9770274 32460:4065e66f313eae5a 47246:4065fe11bdf9def6 49071:406ac7382025279e 49616:406e596c00883ddf 52614:407165c5a4a79082 54569:7ff0000000000002 55736:4071d2dcad423875 57622:40740449524233ce 58710:40769c2edb46bb12 60382:4078f6d23c3b6df1 61139:407a4ed8ca68bd10 63293:407c081fba3b8e29 65187:407cb6cfba6b2e14 ; 22274:405c105bbcf28c8c 34998:40629e4aa9770274 47722:4065fe11bdf9def6 50903:406ac7382025279e 54084:407165c5a4a79082 57265:4071d2dcad423875 60446:40740449524233ce 63627:407a4ed8ca68bd10 66808:407cb6cfba6b2e14
+min_over_time - 1851 9345 26978 1850 11 ; 6332:c08d96149851b7e5 8775:408c319620f83440 11294:40695faf0bc3ffc9 13028:408bcae9c7075761 15178:c0823fc94484d1af 16970:4073c7a83a1572e8 19195:4083b152a34d1b81 21405:c088fb4aa076eb95 24402:c08d174bdad032a2 26349:fe37e43c8800759c 29283:7ff8000000000001 32125:40863f94a20d31da 34003:8000000000000000 34772:408231e522e8f309 37071:c08e6c399475eb2a 37971:c066aa09043d5bfd 40905:407e387d00199264 43574:407b5cfafc5f7dbd 45507:408e5bd6549ddb81 46991:c0668f575cbaefed 48922:408c04ca733e8d67 50141:c071b8c41e0c4b74 51842:c080d5bae98e26d7 ; 26978:4073c7a83a1572e8 28828:4083b152a34d1b81 32528:c088fb4aa076eb95 34378:c08d174bdad032a2 36228:fe37e43c8800759c 39928:7ff8000000000001 41778:40863f94a20d31da 43628:8000000000000000 45478:408231e522e8f309
+min_over_time - 4835 -3300 24418 3798 16 ; 17979:430c6bf526340281 19108:430c6bf5263401e8 20164:430c6bf5263400b0 20751:430c6bf5263400a0 23572:430c6bf5263401c3 24199:430c6bf526340131 26787:430c6bf526340060 28944:430c6bf526340239 30816:430c6bf52634023f 31138:430c6bf5263402f0 33272:430c6bf526340158 33754:430c6bf526340162 36292:430c6bf5263400bd 38436:430c6bf526340057 40528:430c6bf5263400c0 40691:430c6bf526340154 43546:430c6bf526340244 44312:430c6bf526340019 45074:430c6bf526340185 47198:430c6bf5263401cf ; 24418:430c6bf526340060 28216:430c6bf526340060 32014:430c6bf526340158 35812:430c6bf526340057 39610:430c6bf526340057 43408:430c6bf526340019 47206:430c6bf5263401cf
+min_over_time - 1789 6316 8740 735 11 ; 6862:4088a7d9acd57a9b 7886:40649a2edaebe7aa 10239:408c5b4660162eee 12152:c06d33a28b6f1102 ; 13885:4088a7d9acd57a9b 14620:40649a2edaebe7aa 15355:40649a2edaebe7aa
+min_over_time - 9 -4386 5932 1 18 ; 3078:40263dddce95d172 5632:c134fac226f69242 8041:c0de81358fb4b181 9280:420b8a43e72bdb6e 10816:3ff10373f1400cc1 13708:42a092c809d09563 24775:422e04db3375f607 25759:c0d06bc8fe6aa3b1 25826:42c30ad92270664d ; 
+min_over_time - 3536 0 14518 3535 12 ; 4278:430c6bf5263400ee 4670:430c6bf5263402c1 7651:430c6bf5263400a5 9118:430c6bf52634024c 11571:430c6bf5263400ef 13565:430c6bf526340289 16140:430c6bf5263401b9 16827:430c6bf5263400d0 18866:430c6bf5263401d4 20163:430c6bf52634002c 21126:430c6bf5263400a0 21330:430c6bf52634002c 23581:430c6bf526340302 ; 14518:430c6bf5263400ef 18053:430c6bf5263400d0 21588:430c6bf52634002c 25123:430c6bf526340302
+min_over_time - 1000 -3030 22805 3148 3 ; 17482:430c6bf5263400b9 19533:430c6bf526340102 21791:430c6bf526340127 24273:430c6bf526340029 24387:430c6bf52634030c ; 
+min_over_time - 7155 0 18891 3574 4 ; 19381:fff0000000000000 19388:fff0000000000000 ; 22465:fff0000000000000 26039:fff0000000000000
+min_over_time - 1000 0 12495 126 8 ; 16392:430c6bf5263400bd 18288:430c6bf526340186 19173:430c6bf5263400a6 21153:430c6bf5263402c1 23798:430c6bf5263401da 25647:430c6bf5263400bd 26600:430c6bf526340180 26971:430c6bf52634025f 27775:430c6bf52634013b ; 
+min_over_time - 1000 7085 16474 804 5 ; 4117:7e37e43c8800759c 5050:7e37e43c8800759c 6195:7e37e43c8800759c 7854:7e37e43c8800759c 7915:7e37e43c8800759c 8858:7e37e43c8800759c 11160:7e37e43c8800759c 13667:7e37e43c8800759c 14292:7e37e43c8800759c 16128:7e37e43c8800759c 18642:7e37e43c8800759c 19487:7e37e43c8800759c 21555:7e37e43c8800759c 24462:7e37e43c8800759c ; 16474:7e37e43c8800759c 18886:7e37e43c8800759c
+min_over_time - 1000 4759 13361 3432 7 ; 12017:7ff0000000000000 13923:40844db2a26b6271 14466:c08790b8bb7f19f7 17330:c088ecc13fa97212 20264:407bc152f8ac3ef5 20642:c08f34df9d5ef97d 21537:7ff0000000000000 22041:c05579d4968b1e7d 23067:408d50a63d366bcf 23216:c080b3e92a8ef1fa 24333:c06e973fd31e77a9 ; 16793:7ff0000000000000 27089:c05579d4968b1e7d
+min_over_time - 1000 0 33879 3547 6 ; 20479:c07c41a8f003e9b1 25956:40753989c0aa883b 27571:c07d1752337d1305 28078:4071737a6184a724 29389:408e18f7fc1d9584 31891:407082de038daf9e 34427:c06962f770761f44 36679:8000000000000000 ; 37426:8000000000000000
+min_over_time - 425 -5614 22883 209 5 ; 15260:7e37e43c8800759c 17858:7e37e43c8800759c 19797:7e37e43c8800759c 22564:7e37e43c8800759c 25300:7e37e43c8800759c 27586:7e37e43c8800759c 29077:7e37e43c8800759c 31664:7e37e43c8800759c 32411:7e37e43c8800759c 32537:7e37e43c8800759c 33530:7e37e43c8800759c 33730:7e37e43c8800759c 35225:7e37e43c8800759c 36564:7e37e43c8800759c 37370:7e37e43c8800759c ; 23510:7e37e43c8800759c 23719:7e37e43c8800759c
+min_over_time - 357 310 25829 973 19 ; 20657:404b3c0681a6b79c 22493:40559ca70ad51c8d 23327:4058d09dc4efc2fa 25085:4061697e29353d6c 26048:4065b1f6762df9fa 26990:40669e9520589da4 27002:4069de968cbe49ff 28989:406a2864d04ec6cf 31542:406d3cd0e513d20a 32689:406ef5d2b01ddd13 33481:4071591f0ce6a4b3 34148:4072469ec64f6896 37000:401a7f5335b85d4f ; 34586:4072469ec64f6896 37505:401a7f5335b85d4f
+min_over_time - 1000 0 11070 858 13 ; 15715:7ff8000000000001 27857:7ff8000000000001 30107:7ff8000000000001 30417:7ff8000000000001 30442:7ff8000000000001 32982:7ff8000000000001 35609:7ff8000000000001 36256:7ff8000000000001 ; 16218:7ff8000000000001
+min_over_time - 6579 0 13708 3286 10 ; 18183:430c6bf52634008f 20393:430c6bf526340150 ; 20280:430c6bf52634008f 23566:430c6bf52634008f 26852:430c6bf526340150
+min_over_time - 7507 0 36267 3750 20 ; 17140:c044c8bccbea4f25 19527:40373c7f19c3fc2c 22083:42bfcb04cd62c9a4 24478:c2c3977e99d000c8 25147:40336c243ef48688 25708:c0777e201a571de3 27971:406bcd72b5f4c8dc 29939:41eb32fd37a6426a 32836:c2ee35f49c4038f7 35434:42a207a037c2592b 36007:42ca89694fbc4653 36673:420ee2aeeb58e858 38432:3fcd7b1ed0e1c008 41291:c1f3168ed325a07c 41744:420009a08a1d30b7 51338:40d40230c434783d 53361:c2c17137e521f749 54269:407c2d34440dee8e 56192:c1c530ca61caf30b ; 36267:c2ee35f49c4038f7 40017:c2ee35f49c4038f7 43767:c1f3168ed325a07c 47517:c1f3168ed325a07c 55017:c2c17137e521f749 58767:c2c17137e521f749 62517:c1c530ca61caf30b
+min_over_time - 16661 0 1422 134 18 ; 6270:40872db6fbf84217 7944:4087c8db98a69b27 8677:c08821dc9584807f ; 
+min_over_time - 1000 5846 7448 559 5 ; 6918:404ea54b73c52b1b 7616:405064422daee892 10144:401fedbf5b312790 10453:7ff0000000000002 13231:404383443bdf559e 14087:4050f8843ce65ca7 15013:40543e620780cbf6 16471:405d70d43ab5f74d 18634:4060db8791639fec 19186:4062d9e384c529d4 19386:40686b58bd322e86 ; 
+min_over_time - 3714 0 14204 3713 8 ; 4878:7ff8000000000001 6652:7ff8000000000001 7551:7ff8000000000001 7710:7ff8000000000001 9975:7ff8000000000001 21553:7ff8000000000001 22290:7ff8000000000001 23599:7ff8000000000001 25518:7ff8000000000001 27332:7ff8000000000001 28871:7ff8000000000001 29398:7ff8000000000001 32299:7ff8000000000001 32994:7ff8000000000001 33060:7ff8000000000001 49738:7ff8000000000001 51601:7ff8000000000001 52311:7ff8000000000001 53253:7ff8000000000001 54398:7ff8000000000001 56556:7ff8000000000001 59042:7ff8000000000001 67988:7ff8000000000001 ; 21630:7ff8000000000001 25343:7ff8000000000001 29056:7ff8000000000001 32769:7ff8000000000001 36482:7ff8000000000001
+max_over_time - 5216 0 20813 3279 18 ; 12268:430c6bf5263400aa 14903:430c6bf5263400f7 15443:430c6bf5263400c0 16181:7ff0000000000002 17329:430c6bf52634000d 19573:430c6bf5263402ed 19847:430c6bf526340208 21833:430c6bf526340301 24667:430c6bf5263400b7 26729:430c6bf526340244 28989:430c6bf526340304 29844:430c6bf526340132 32266:430c6bf5263401b2 ; 20813:430c6bf5263402ed 24092:430c6bf526340301 27371:430c6bf526340244 30650:430c6bf526340304 33929:430c6bf526340304 37208:430c6bf5263401b2
+max_over_time - 1000 0 7098 1540 3 ; 6038:c0b1287f45f1008d 6987:c07d0a11dcf8db52 8282:c18546c16a9724c1 10439:4032002139a49bd4 11876:c14fbd24cf984efc 13760:418602057a97e322 16287:415228ddeb2c4be0 16860:41f14419d0ef64ad 18995:3fd205707045c3e0 20697:3fc2912464a87dd8 23398:c21ad4db15993319 24506:c2a6f912b5bd5d36 ; 7098:c07d0a11dcf8db52 8638:c18546c16a9724c1
+max_over_time - 6951 -7575 26649 3472 16 ; 11367:c0a869e77597ccd9 13467:c260e491e624180f 13644:42c05e1673bc65c3 13941:bfc39608fbf0ec60 15855:c2f0d4223723d2b2 17982:4038f281a10454fd 20160:4115c9e789c504af 20637:c2449f2d07f2e1da 35936:7ff0000000000002 36563:c27ef2351b2b399b 39060:c0756786117fbb4d 41214:4059d194ebe66102 42287:407d3deac814109d 42292:c2b64392f0ab8141 44874:c29098284ad082e4 47243:c2e02cd3fa14257b 54547:c18a2b2cc9eff644 55400:409dbdaccb5b7f6c 57983:c0e8080e85aa9dd7 ; 30121:c27ef2351b2b399b 33593:c0756786117fbb4d 37065:407d3deac814109d 40537:407d3deac814109d 44009:c29098284ad082e4 47481:c18a2b2cc9eff644 50953:409dbdaccb5b7f6c 54425:409dbdaccb5b7f6c
+max_over_time - 10247 0 26168 3807 6 ; 19775:c089d2c6d9e90cd4 20940:4079e51c54ec7bc3 21445:c08766a41129f18f 24010:7ff0000000000002 26652:c05d702a596caffb 26920:7ff8000000000001 27243:7ff8000000000001 27998:7ff8000000000001 ; 26168:4079e51c54ec7bc3 29975:4079e51c54ec7bc3 33782:c05d702a596caffb 37589:7ff8000000000001
+max_over_time - 1000 9499 21706 1159 16 ; 17628:40624b0129b9856d 19465:4089f25605474290 21493:408cdeb83aaf0553 24199:c08e0b691f17ed42 24412:c06f55850d6a329a 25817:c06d04302923201c 25961:408c8247429d619e 26998:7e37e43c8800759c 29039:c08172ed79ef6bff 30401:404d3ae152284265 33173:408118605ad4671e 35209:c05493c9af29c20d 41585:fe37e43c8800759c 41818:7ff8000000000001 65544:c071ca7876cbd3c4 65624:c08b5ff4ea78b61d 68548:c05cbac59875d0fe ; 27501:40624b0129b9856d 29819:4089f25605474290 34455:c06f55850d6a329a 35614:408c8247429d619e 36773:7e37e43c8800759c 39091:c08172ed79ef6bff
+max_over_time - 160 0 57563 1665 16 ; 23230:430c6bf526340019 25246:430c6bf5263402bc 27269:430c6bf526340168 28570:430c6bf5263402f9 28599:430c6bf52634025b 30743:430c6bf52634028b 33143:430c6bf5263400b0 35071:7ff0000000000002 37793:430c6bf526340263 53032:7ff0000000000002 54830:430c6bf52634031e 55744:430c6bf52634009d 56976:430c6bf526340067 57808:430c6bf526340163 59673:430c6bf526340303 59928:430c6bf52634001c 61021:430c6bf5263401d5 63466:430c6bf526340141 65524:430c6bf526340082 68320:430c6bf5263400a0 70750:430c6bf526340089 72511:430c6bf52634020e 74421:430c6bf52634003f 74653:430c6bf526340097 74980:430c6bf526340063 ; 70883:430c6bf526340089 72548:430c6bf52634020e
+max_over_time - 2240 1692 16855 2240 17 ; 18757:408c1bdbdb2c67a4 19570:c0852629561d9dc2 21912:c062b8f379608af8 ; 21335:408c1bdbdb2c67a4 25815:c062b8f379608af8
+max_over_time - 1872 -7769 26778 1871 9 ; 14183:430c6bf526340070 16776:430c6bf526340202 17188:430c6bf52634015e 18226:430c6bf52634022b 20084:430c6bf5263401b6 21986:430c6bf52634023a 23190:430c6bf52634003a 23616:430c6bf5263400e4 25326:430c6bf526340219 25627:430c6bf526340253 28117:430c6bf526340161 29273:430c6bf52634006f 29742:430c6bf5263402d0 30585:430c6bf5263400e3 31629:430c6bf526340072 33961:430c6bf52634010c ; 26778:430c6bf52634010c
+max_over_time - 3321 3395 482 3321 15 ; 5321:430c6bf526340277 7634:430c6bf5263401d4 8124:430c6bf52634002f 10255:430c6bf526340134 11968:430c6bf5263402f8 11997:430c6bf5263400c7 14019:430c6bf526340263 14109:430c6bf5263400cf 14240:430c6bf526340115 ; 10445:430c6bf526340277 13766:430c6bf5263401d4 17087:430c6bf5263402f8 20408:430c6bf526340263
+max_over_time - 1941 6408 25485 2878 11 ; 2081:3fcffbbe7a0eac90 4469:407ea15836a048e6 18915:41bd95371e47e7da 20866:415277cfdcd981f4 23796:417f75170715dceb 25311:c043a4178d7cda65 27112:40b04e913e23a792 29234:c1d8a87cf7c8229d 31653:c2c645182a203249 ; 25485:41bd95371e47e7da 28363:415277cfdcd981f4 31241:417f75170715dceb 34119:40b04e913e23a792 36997:c1d8a87cf7c8229d 39875:c2c645182a203249
+max_over_time - 2486 0 9433 2485 8 ; 10814:fe37e43c8800759c 12102:fe37e43c8800759c 24343:fe37e43c8800759c 25237:fe37e43c8800759c 27383:fe37e43c8800759c 29827:fe37e43c8800759c 30475:fe37e43c8800759c 31240:fe37e43c8800759c 33426:fe37e43c8800759c 36275:fe37e43c8800759c 48930:fe37e43c8800759c 49776:fe37e43c8800759c 50210:fe37e43c8800759c 50998:fe37e43c8800759c 51569:7ff0000000000002 60255:fe37e43c8800759c 61735:fe37e43c8800759c 62831:fe37e43c8800759c 64268:fe37e43c8800759c ; 11918:fe37e43c8800759c 14403:fe37e43c8800759c 24343:fe37e43c8800759c 26828:fe37e43c8800759c
+max_over_time - 2743 -9947 28377 2743 9 ; 2653:403a27854bf0d3ce 2773:407f4588d6dbc1a8 3186:40750d38db7fccb7 4242:4079fc9160e020f9 4397:c07a02db745f5d62 6730:408412b6d260ca1c 9260:40819e1ab0097a40 12050:40573f3a4fd48be8 12792:c08451be6276125b 22428:c08817f8f1da3ed2 23666:408e226f23cc7688 26272:c085a58211e49435 26707:c041c46b3cd2d0bb 29502:4079dc9769c3d620 31849:c08820cb620b7ba3 34394:c0607df791a04cb0 37035:c068ee6c80b8830f 38079:4028d85fd11d423d 40590:c08cfe3fbcbc48ef 43041:c08616d0b3aec582 ; 28377:4028d85fd11d423d 31120:c08cfe3fbcbc48ef 33863:c08616d0b3aec582
+max_over_time - 1988 0 65062 1988 11 ; 13043:c10faed9ff30a9b5 15389:c00b01a23a83620a 17606:c2533331f7f2c625 18866:c03607f80c324251 32629:7ff0000000000002 34582:c1760083aeacff99 36240:40d84cd17b1a9426 36428:428011d7fdea41d1 37810:4283c905305a7022 40079:c03c22fac8a173c0 40614:42f43dd012a687ff 42263:c016c1d39e8218cc 59158:40602115c242b10a 61529:414a31eadf2c82a2 61964:c25717ea8487d9bb 82453:400b2389ce98bfe8 104246:c2fb4cbe59d255fa 104839:c0c7f5ce3a66e57f 107450:c1147e7e28ad16c9 109123:3fd5b3f91ea6e3c2 109810:c152a6709bf31668 111525:c0d27644eee1fe83 ; 82954:400b2389ce98bfe8
+max_over_time - 1251 4092 12393 1251 11 ; 13897:424570eaefd4da61 16229:40a89e11ddf7a446 16846:40622bf43eff3833 17025:418e7064b438715f 19426:4063e8fb08c2b811 19669:419f7837273069d9 21193:42388c2dc2ac2589 21312:3fd9407f72016d04 23855:c037f7e56417ada7 ; 18648:424570eaefd4da61 21150:418e7064b438715f 23652:4063e8fb08c2b811 24903:419f7837273069d9
+max_over_time - 4837 0 7631 2415 9 ; 3598:c25adc2a6d721cb9 6424:40b22f076b887be7 8190:c25597c76e7f9068 ; 7631:40b22f076b887be7 10046:40b22f076b887be7 12461:c25597c76e7f9068
+max_over_time - 7841 0 26748 3917 7 ; 16187:7ff0000000000000 30070:7ff0000000000000 31869:7ff0000000000000 34192:7ff0000000000000 34503:7ff0000000000000 35524:7ff0000000000000 36560:7ff0000000000002 37521:7ff0000000000000 39952:7ff0000000000000 40861:7ff0000000000000 41002:7ff0000000000000 42449:7ff0000000000000 ; 30665:7ff0000000000000 34582:7ff0000000000000 38499:7ff0000000000000 42416:7ff0000000000000 46333:7ff0000000000000 50250:7ff0000000000000
+max_over_time - 1646 -2829 12474 1646 11 ; 12594:c182a525458d40a1 14718:c132693877752b3b 16327:40b8ab00cc5a6dfb 18950:42fc5e11334605b0 21353:41d1a43056aee718 23670:c22007e30e5eebf3 23842:418037d49d5c0314 24552:4215f7bcfdda46b4 26170:c214dbce48aaaf34 ; 12474:c132693877752b3b 14120:40b8ab00cc5a6dfb 17412:42fc5e11334605b0 19058:41d1a43056aee718 22350:4215f7bcfdda46b4 23996:c214dbce48aaaf34
+max_over_time - 1000 6201 3753 1651 20 ; 918:c02f0072a010a27c 1666:403cc312e7786370 4661:7ff8000000000001 ; 8706:403cc312e7786370
+max_over_time - 730 0 52477 729 11 ; 12539:411823597d26616f 21914:c1856bf04ef7b468 31047:40814e67cd514aa9 31284:42bc45db36a239c2 31905:c06245603750a8a1 31997:c18207dd15d0b31c 34616:41a43d158b9a6cc8 35873:403c8bfa2a2de204 38762:3ffe241ae186a676 40414:c2dc9e46461a5718 43170:40af46c87c460d9c 43739:428f0380085c7ea8 46129:c2f0ff17ca5e9130 46159:c07dcfc0449b65d6 48797:c1b24d762efd1995 69726:c2c516d0739f78ef 71852:42225357a66430eb 73787:bfd47caf443fe2f4 76200:4140eaf47315b30a 76311:c06896e100c89f8d ; 
+max_over_time - 4785 0 50878 2389 11 ; 20162:4073e95ed8275dbc 22860:405c57deaa0b4a14 23486:7ff0000000000002 24157:4076f6f133988cee 26206:40707d9c9ec51655 27519:c08de3c76cf8c963 30439:7ff8000000000001 32690:c0608a583aa8b0ec 33752:408c161e14cc4919 34126:c08e88a3fe47a5c9 35283:406f7b12981ed420 36483:c08deb4d32403010 37527:c08000d9b2617911 37858:c086e2000f1efae7 39843:408dab07842a3109 42501:40863f6479774ee1 43861:c0483f613439bcd5 46445:c06339531f2dd213 49283:7ff8000000000001 51489:c0811e55fc6736f7 52343:c08935259b5ab0ca 53874:c08a3026c64adb28 ; 50878:c06339531f2dd213 53267:c0811e55fc6736f7 55656:c0811e55fc6736f7 58045:c08a3026c64adb28
+sum_over_time - 537 0 14542 537 10 ; 5328:4073fa30feeb3699 6000:7ff8000000000001 7324:c070466d5b6392c3 8174:c07ab59b811df09c 9313:7ff8000000000001 28424:40650b44d2c26faf 29161:c083e4dbd9cdf18b 31739:40537cfc2358e874 34571:7ff8000000000001 36517:408a66f0902eb6a8 37238:c089affec35d3ab3 38210:7ff8000000000001 38502:4084c9a768bf78c7 40736:4086647ebc6d1fdc 42661:40898a49a5f9783b 43347:c06e1fffd1bafba1 44325:c071061cdfc9ee9e 45920:c07e25b42509531e 46943:c089044fd0b22f45 49680:c07dbd945de4ba7d 50266:c08eb76a9012d060 53090:404c32a4134954d0 56063:7ff8000000000001 57086:c082d28eb6226408 ; 
+sum_over_time - 1000 -2213 36804 2098 7 ; 21342:fff0000000000000 22780:fff0000000000000 23508:fff0000000000000 25342:fff0000000000000 26705:fff0000000000000 29182:fff0000000000000 31304:fff0000000000000 31362:fff0000000000000 31471:fff0000000000000 32799:fff0000000000000 33933:fff0000000000000 34663:fff0000000000000 37209:fff0000000000000 37420:fff0000000000000 38359:fff0000000000000 38398:fff0000000000000 40604:7ff0000000000002 40870:fff0000000000000 41950:fff0000000000000 42510:fff0000000000000 ; 36804:fff0000000000000 38902:fff0000000000000 41000:fff0000000000000
+sum_over_time - 16380 -7526 27505 1348 13 ; 2824:c0887b4fbe84a109 5430:405aca61a992ec26 5978:4086805ab88f393d 7293:408ca6bd120e8ef1 7947:4082c07f0bee94a3 17520:408a88ec24aba38c 20490:c086bdd5ce28758c 22846:c07c327c994fdfd4 24442:c052af67012ad17d 26426:4086077129ddfbe0 28271:4089c29b675e2ab3 28972:c0713abe278e825d 29617:407ef3911a0e00ad 31219:c07a8113dd40be66 31232:c0518136990e76db 34143:c08d1ffba86dc65f 36316:c076b31faf50f0e5 38433:c08514a8cdbb3e4c 40730:4032fb043e2c357e 42582:c074b3ed980abb97 42618:4070507018526d15 44269:408006d9c4d7f705 47011:40839980e76cf3b0 48607:40826056e1e63812 ; 27505:c08d17375aa9ce58 28853:c094386399292365 30201:c081b2f16429d13e 31549:c09363cd18f287c5 32897:c088ae5be53d1fa0 34245:c085c096e32663c5 35593:c096fce366704373 36941:c08df2ed08088fe1 38289:c0978c14adcfbcb3 39637:c0957c38809cc306 40985:c08b87c03f7757fe 42333:c0724ed2bb223fd7 43681:4083f8924adca673
+sum_over_time - 17138 7980 24396 2966 15 ; 13917:430c6bf526340171 16078:430c6bf526340103 18459:430c6bf5263402b7 20916:430c6bf526340297 21452:430c6bf52634010a 23776:430c6bf526340192 24179:430c6bf5263400e7 26183:430c6bf5263400ce 28207:430c6bf52634017c 29478:430c6bf5263401ac 29601:430c6bf526340281 31934:430c6bf5263401b7 34206:430c6bf526340151 35953:430c6bf52634029b 36324:430c6bf526340275 36912:430c6bf5263401f4 ; 24396:431c6bf52634013a 27362:432550f7dca7014b 30328:4331c37937e0811a 33294:4338de76816d8169 36260:433ff973cafa81b2 39226:4341c37937e08105 42192:43438a388a43c125 45158:434717b72f0a416a 48124:43438a388a43c130 51090:433ff973cafa8210 54056:4338de76816d81c7 57022:4331c37937e08142 59988:432550f7dca701c1
+sum_over_time - 2411 2037 16776 2410 14 ; 9548:40895f88c1024f30 12016:7ff8000000000001 14603:40800d07ca20cec7 16664:406bc64cd9896d83 16785:7ff8000000000001 19562:7ff0000000000002 22255:7ff8000000000001 24786:c0820cf4baf19ef7 25588:c044ce40ab85b90c 27325:7ff8000000000001 29248:406d729183ec474d 32087:c07f4b8e58105f87 33809:c08cd2e79f500473 34193:7ff8000000000001 ; 16776:40800d07ca20cec7 19186:7ff8000000000001 26416:7ff8000000000001 28826:c08359d8c5a9fa88 31236:7ff8000000000001 33646:406d729183ec474d 36056:c0963c5765ac1a1b 38466:7ff8000000000001
+sum_over_time - 2527 0 23346 2527 7 ; 21342:c28b0c2468d64e0a 23551:42d93dad081a2afb 26481:c286695a0625f02e 26528:41f0096fb84a97cd 27365:c04611847d0684d7 29345:4010e08b82743370 30595:c00be5b7a547d629 32543:c1b3102bcd93df7c 33660:c113a1541d44f87a 35791:c10218478b52b6fb 37532:c224ac512bd03c2d 38296:3fdb16e45402a38a 39536:c0a9eda422d0b222 39983:c073a69d4b7ddccd 41009:c206d0d7cd3af29b 41038:417c4d512f28288c 41799:c2f03e32a6b1eb29 42755:42b789600e1effe5 44234:4106b7e5f405e7ac 44634:c2730af53f99fb8e 47116:c0e49a4c1cabbf65 48298:41c5c643834df5d8 ; 23346:c28b0c2468d64e0a 25873:42d93dad081a2afb 28400:c28661554e4b2bfa 30927:3fe76d7d7e8242dc 33454:c1b3102bcd93df7c 35981:c11cad77e2ee53f8 38508:c224ac512bcf6376
+sum_over_time - 9597 0 11434 2079 10 ; 9231:7ff0000000000002 10011:c07faa66d43a5141 11397:4047b9f37dbf5c98 12211:c0810907c7b4179b ; 11434:c07cb328648265ae 13513:c08f629bf9f54a72 15592:c08f629bf9f54a72 17671:c08f629bf9f54a72 19750:c07f1ad11fb043a3
+sum_over_time - 5135 -5680 13619 2868 15 ; 16038:430c6bf526340002 17387:430c6bf526340256 ; 13619:431c6bf52634012c 16487:430c6bf526340256
+sum_over_time - 1000 2035 48608 858 19 ; 20349:0 21573:0 22804:0 23011:0 25923:0 26572:0 26778:0 29682:0 30550:0 33525:0 33616:7ff0000000000002 34559:0 35276:0 35670:0 36760:0 39631:0 41925:0 43643:0 44898:0 46716:0 48658:0 51493:0 ; 49466:0 51182:0 53756:0
+sum_over_time - 2359 -9872 417 1176 7 ; 4567:430c6bf526340132 6176:430c6bf526340203 7449:430c6bf5263402d5 9326:430c6bf5263402ac 9587:430c6bf526340274 11033:430c6bf5263402cb 16296:430c6bf526340050 16603:430c6bf5263400f4 19449:430c6bf526340069 19509:430c6bf526340068 21471:430c6bf52634025a 22119:430c6bf526340298 23118:430c6bf5263400aa ; 417:431c6bf526340290 1593:432550f7dca701fb 2769:430c6bf5263402cb 7473:431c6bf5263400a2
+sum_over_time - 1977 0 16688 1976 1 ; 2376:4044c8ef039bee1e 3114:c083c97471af6a3e 3573:c0599bb82567715f 4076:408992d3df5d0c2f 6971:7ff8000000000001 9104:408e756f2277165c 11302:408102d7a9fe5f2f 11396:c0808582e6e4b360 13381:c07e92e1cb806cde 14637:c081d76edddc3610 14938:c08eba31616f2988 39047:4050702eb7b5b2b0 41148:c074e307bcbcae5b 55498:408cc5c63e76f07f 57782:c08ae7f2c7b19e5a 58327:c088df882202ac40 60229:7ff8000000000001 62894:405ee80b623454cf 64526:40875caaa682bb16 65502:4089972430e64f01 67321:7ff8000000000001 68882:40757230d78ee7df 70449:c08c9ad6a4cddd6d 70592:407bc37457752f25 ; 16688:c08eba31616f2988
+sum_over_time - 865 0 2139 429 2 ; 3476:430c6bf526340139 5547:430c6bf5263402ed 8188:430c6bf52634022d 9027:430c6bf52634015c ; 
+sum_over_time - 2937 0 33840 2937 7 ; 21540:3fda0523be08c174 21785:41b7747e4cae32e6 22645:42e7056caae9f7ac 24160:41de782cbc1ec08e 26694:3fd2b4f4ef893316 27979:c001cfe94883d819 29491:40e862e90c28ae94 31176:4010ea28e75072c8 31452:4076686b46c0bf04 34394:c06140f1be824f77 35727:42f6fa117197c6ce 36741:c2bd213e75c7188d 37686:c1adfef3d9e39a2a 39036:41e07330b9494bee 39208:428e1aa7b0d0b85b 40195:c214260f098067d9 42830:4059b26491c8886a 43046:40527fc279232b3e 44849:3fc056f86cbd0f8c 46860:40e73cd09f1217f1 49416:bfc99f7f9a949d3a 52108:c0057b09520432ea 55025:427ccd53a66373ef 55821:400ac2492f9b9092 58438:40e7b26a07cb8ff3 ; 33840:4076ac13ea5e00cf 36777:42f527fd8a3b4ca5 39714:428e1e4c812fa320 42651:c214260f098067d9 45588:40661d2943910918 48525:40e73cd09f1217f1 51462:bfc99f7f9a949d3a
+sum_over_time - 1000 0 20932 1499 2 ; 11467:bfdf9a4090cc322c 21812:c0a41f54105926ce 24280:4011cb53afd6bb47 24439:4169ebda80b6df50 25995:41b8eaf2d7a119c7 26733:c07ad6fc2e52b17b 29555:c2372940ed6b0a72 30941:c105bced061fcf49 32045:c0a772e23b5ad752 34132:bff57373c904ab1a 36744:415218fc73e3c301 39173:c0af84e929014dae 41260:c287cfdd27ebe7b8 42811:4221fd14047e6977 43126:c1c960232ea73fcf 45740:41afcca72e2c4063 48256:415cfed64e71d109 50042:c2a3da2237858653 52975:40ddc527a97db8ca 54500:40d39e1cc0f268de 54765:40aaa51fd6118ace ; 22431:c0a41f54105926ce
+sum_over_time - 7885 2908 39805 3939 19 ; 42072:fff0000000000000 58060:fff0000000000000 59651:fff0000000000000 61009:fff0000000000000 63690:fff0000000000000 65237:fff0000000000000 66303:7ff0000000000002 66462:fff0000000000000 67956:fff0000000000000 69495:fff0000000000000 71940:fff0000000000000 72252:fff0000000000000 73627:fff0000000000000 73921:fff0000000000000 75143:fff0000000000000 75347:fff0000000000000 ; 47683:fff0000000000000 51622:fff0000000000000 63439:fff0000000000000 67378:fff0000000000000 71317:fff0000000000000 75256:fff0000000000000 79195:fff0000000000000 83134:fff0000000000000
+sum_over_time - 7781 -6239 21081 3887 11 ; 10358:8000000000000000 11665:8000000000000000 14267:8000000000000000 16359:8000000000000000 18370:8000000000000000 19862:8000000000000000 21732:8000000000000000 24367:8000000000000000 26721:8000000000000000 27352:8000000000000000 29163:8000000000000000 ; 21081:0 24968:0 28855:0
+sum_over_time - 837 9591 -1768 837 1 ; 2851:405aa937f27350df 3505:40607ef0feffa262 4349:40618a67d34c1bb6 5066:406431891a38672c 7914:4065412206978880 10290:406908eeca01fbb9 10521:406b42b9ae8a75fc 12480:406d9751f100a665 14324:406dab41d50eca1b 15283:40702739c8bdfc75 17745:4070d006816d10e3 18825:40733bcb528bd87c 19817:40200197c419a67a 21679:404b60bad1dbf496 21728:404f08295d3423bc 23247:40574f8a25c5a20b 25111:405dcc17c076f488 25344:40620c606076052d 28009:4067222b635d6f2c 29434:406bce4eb1f10844 30230:406f4f3ac6f063dd 33153:40142ce972aa70ba ; 
+sum_over_time - 4588 -6528 65779 2992 20 ; 9203:c2f227753065e838 9783:c140076cf8781e55 11416:c250447a80e41b3b 11684:c223fcc8e842d47a 13557:c1e328465696dab4 16253:41f2482df99e87e8 25987:41c69fd71439b885 43860:41b0e7829141c974 46136:c0d2080b1181b28e 46395:c13c0d265d10a397 46683:3fe8166afb733694 48881:c2b9e3b00cdeeb63 49817:427caa2e88dac780 51401:41e8fd7d70b2d72d 54121:c1713e1b864ddb49 55054:c11adbc958e8256b 56040:41448e9f54467768 59023:bfb7a0b22a0a79f4 59221:c07b3c907e1c56e7 60912:40cda0bd97c4b1ca 62970:40407de3f495a3b7 65113:c17ceb658038fe2f 66204:c2ba5dfa6f12aeb7 ; 
+sum_over_time - 4407 -3869 44797 2200 3 ; 10828:40423d21aad3903e 10848:4044d7c85a0fccc7 13529:404cd1f8b4da7604 14409:404ec5754a44eb18 38046:4052a37b9307d98a 40182:405692b31b69f9d9 40904:4058e8ac8f6fb5b1 41489:405a7682792af5da 43156:405bf5a6ffcbbe00 45038:40628e0ac64ea331 48007:4068caedc7c044bc ; 44797:4075ac7c470773f6 46997:4068caedc7c044bc
+sum_over_time - 3530 -9430 61093 3530 19 ; 14722:0 16977:0 19457:0 20885:0 23859:0 26748:0 49176:0 49917:0 51660:0 53637:0 78273:0 81053:0 83624:0 83655:0 84659:0 85034:0 86267:0 87166:0 87823:0 89400:0 90085:0 ; 71683:0 75213:0 78743:0 82273:0
+count_over_time - 2453 -2171 18210 2453 4 ; 20349:40616b010c31055f 22092:c074623e5d7e5fc0 22161:408c57faa9997028 24265:4085eb735b625d04 25914:c0677ba88206b378 26218:c070fc3b5b44adc6 28457:7ff8000000000001 30942:c0894a93455abb60 32803:4070543e9e66bbc2 32958:c087661c2bfe0f3f ; 18210:3ff0000000000000 20663:4000000000000000 23116:3ff0000000000000 25569:4000000000000000
+count_over_time - 3782 -4824 39637 3782 3 ; 6516:40741c64b7c1a239 8771:7ff8000000000001 11640:40494aabf97ecf3c 26768:c0805ea6abc8e360 29105:4088dcc1607b105d 29812:408415b251ed3878 32066:c07b238eb54d678b 34098:40603633c54c9291 36431:404ff8039aa7696e 38219:7ff8000000000001 38507:408b3c5fe253012e 38587:406bcdc8515fe6dc 40352:408a31f51223cea8 42915:c081fb81cc534f4a 43153:7ff0000000000002 45719:408b087282790b83 46033:c085761ded091522 47171:7ff8000000000001 49497:404f2c039528501c 66045:4086aeb69abd5fde 67264:4081ba39f3278bee 69304:4077009e3bc88166 71824:40535d048835268d 73339:c069ccb4225260ee 73976:c089841bf91c9ade ; 39637:3ff0000000000000 43419:4008000000000000 47201:3ff0000000000000
+count_over_time - 3938 0 51384 3937 9 ; 5600:7ff0000000000002 7470:40552d662f940e0d 9498:3ff3695f5b4d6e32 33555:4048e39635f42e7d 35017:4057ff25362cf39f 37942:4059b3ebe4d8afc4 40113:40619cfefa461726 42072:4061fbac955adb54 42904:4064cbabe96dd1e2 43794:7ff0000000000002 45345:4067f356c3bee3a7 46116:3fe1c9742e62bae3 48680:4030ebeb23dba72f 50706:4020157b19832332 50904:40455357f041d2a4 52407:4023c0ae48e4debd 54970:40252f28df71f7dc 55094:404261a409e0bd1a 56189:40494b851ab8c41c 57122:405479c5ca545386 57496:7ff0000000000002 ; 51384:4008000000000000 55321:4008000000000000 59258:4000000000000000
+count_over_time - 3777 7601 -2115 3777 10 ; 2168:430c6bf52634030c 2898:430c6bf5263401a2 3960:430c6bf52634008f 4590:430c6bf5263402dc ; 12993:4010000000000000
+count_over_time - 7581 0 24168 3343 6 ; 14528:430c6bf526340021 15413:430c6bf526340020 15416:430c6bf526340082 17258:430c6bf526340226 18365:430c6bf52634021b 20858:430c6bf526340235 21981:430c6bf526340045 24184:430c6bf52634019e 26959:430c6bf526340282 28622:430c6bf52634024a ; 24168:4010000000000000 27511:4010000000000000 30854:4008000000000000 34197:4000000000000000
+count_over_time - 56 5652 26763 55 13 ; 19836:7ff8000000000001 21523:7ff8000000000001 23683:4085d0f279a1c28d 25293:408108c9b3b726f4 28068:7ff8000000000001 29137:7ff0000000000002 31293:c07e6c5c20e00875 32205:c0517081931a808c 47983:407e93379a871029 48755:4082a5d7f00c8c30 ; 27203:3ff0000000000000
+count_over_time - 3959 8893 26705 1976 11 ; 19399:7ff8000000000001 21658:7ff8000000000001 22596:7ff8000000000001 22804:7ff8000000000001 31170:7ff8000000000001 33014:7ff8000000000001 34697:7ff8000000000001 37423:7ff8000000000001 39109:7ff8000000000001 39303:7ff8000000000001 39782:7ff8000000000001 42460:7ff8000000000001 44106:7ff8000000000001 46480:7ff8000000000001 49086:7ff8000000000001 50589:7ff8000000000001 52843:7ff8000000000001 54037:7ff0000000000002 56031:7ff8000000000001 ; 28681:3ff0000000000000 30657:4000000000000000 32633:4008000000000000 34609:4000000000000000 40537:3ff0000000000000 42513:4000000000000000 44489:4000000000000000 46465:4000000000000000
+count_over_time - 1697 0 17933 2836 11 ; 11829:7ff0000000000000 14592:7ff0000000000000 16698:7ff0000000000000 28936:7ff0000000000000 30770:7ff0000000000000 31753:7ff0000000000000 33788:7ff0000000000000 36674:7ff0000000000000 39535:7ff0000000000000 39621:7ff0000000000000 41034:7ff0000000000000 57673:7ff0000000000000 58066:7ff0000000000000 59362:7ff0000000000000 80533:7ff0000000000000 81641:7ff0000000000000 84328:7ff0000000000000 84913:7ff0000000000000 85081:7ff0000000000000 85427:7ff0000000000000 ; 17933:3ff0000000000000 29277:3ff0000000000000 32113:4000000000000000 34949:3ff0000000000000 37785:3ff0000000000000 40621:4000000000000000
+count_over_time - 1645 -9712 40100 3807 3 ; 20085:c08579ff1d0b6719 20680:c08c64061fcb4613 23060:4076e274e1c0de00 23515:c08addc620fd1cd5 23815:7ff8000000000001 26066:7ff8000000000001 27982:c0892af79783d9cf 28755:c07297542674c231 29080:c08162ef2658dfc4 31333:7ff0000000000002 42832:c05e0ad543021d34 ; 
+count_over_time - 1000 0 69336 307 10 ; 6046:40877ca28102b9d0 6490:c079018355afdafa 8962:4058d2ca03366d18 9537:40881585a1837c81 10108:4088e2dc9c0adfb8 12027:7ff8000000000001 13555:c0783baaf9d89b42 14393:408408bedee7eaa0 36405:c083af343c77824a 38345:c08566e10adb0431 39116:408b9275fb0f083e 40729:7ff8000000000001 41459:404d329e26a6939a 47717:4038915535eebdee 48884:40763d964cbae218 65769:40551d379ddd625d 66917:7ff8000000000001 67306:c0504744990da157 69641:c08dd96807b850e5 ; 69643:3ff0000000000000 69950:3ff0000000000000 70257:3ff0000000000000 70564:3ff0000000000000
+count_over_time - 1000 -1022 39649 103 10 ; 7076:430c6bf526340067 7707:430c6bf5263401ba 9365:430c6bf5263400b2 10671:430c6bf526340258 11744:430c6bf526340244 13983:430c6bf52634029f 14224:430c6bf5263400d4 15483:430c6bf5263401e5 16931:430c6bf52634010f 18385:430c6bf526340020 18745:430c6bf5263400dc 21528:430c6bf5263402e6 24471:430c6bf5263402fd 24592:430c6bf5263402a5 26187:430c6bf526340042 28750:430c6bf5263401f0 29138:430c6bf526340015 30192:430c6bf526340206 36018:430c6bf52634024c 36165:430c6bf52634015f 37372:430c6bf5263400e1 37510:430c6bf5263401bb 38405:430c6bf52634002d 39414:430c6bf526340241 40694:430c6bf5263401cc ; 39752:3ff0000000000000 39855:3ff0000000000000 39958:3ff0000000000000 40061:3ff0000000000000 40164:3ff0000000000000 40267:3ff0000000000000 40370:3ff0000000000000 40473:3ff0000000000000 40576:3ff0000000000000
+count_over_time - 3590 474 41870 3589 4 ; 1483:430c6bf526340280 15788:430c6bf52634002d 17835:430c6bf52634030e 19038:430c6bf5263401b9 19510:430c6bf526340035 20695:430c6bf526340142 22923:430c6bf5263401d5 23858:430c6bf52634023b 25099:430c6bf526340284 26121:430c6bf526340099 26854:430c6bf526340134 27731:430c6bf5263400de 29303:430c6bf5263402e2 29409:430c6bf526340288 30218:430c6bf5263401aa 32358:430c6bf526340065 33508:430c6bf5263401e0 35606:430c6bf5263401a0 35821:430c6bf52634002c 38535:430c6bf52634027d 40161:430c6bf52634028e 41762:430c6bf5263401bc 54077:430c6bf5263402db ; 41870:4000000000000000 45459:3ff0000000000000
+count_over_time - 154 8062 1298 154 12 ; 5279:40430e906820cfdd 6225:7ff8000000000001 8720:408bdb4416e7b448 ; 
+count_over_time - 7981 0 3616 3987 2 ; 5074:c140c552e420b422 7820:40af06d2271bcf90 9812:7ff0000000000002 12689:3ffea777611a59b6 14284:3fdc182187bbe66c 14634:42dcdb20271cd7d6 16248:c111be4455729b13 16658:4276d192bb3a174a 16663:42a4d00011e021ba 39608:c19ea0819c76597e 40372:c286ec8649cfc6bc 42554:428e113dc2045e1d 45185:c1b232fac3c02b43 47130:c00775b494aea290 48079:40eeb07efd9d9a7d 48120:c1524a9fa261964a 49618:40aa7b65bda37c96 51353:c28df8b81175ddad ; 7603:3ff0000000000000
+count_over_time - 3418 7350 58420 206 13 ; 19382:7ff8000000000001 20582:c081e61a93678f99 27875:c0842b212624e3f1 28305:c0501ddd2010ca11 30153:407b4f4766da12a4 31036:c07e0af44bcbd436 31771:c08317609b50f858 33688:408d3450479cd868 35827:c07ede9a13d3e233 38194:407a9d80571d1372 40836:c0852dacb6addbaf 42224:4057dd6dbde0a0b3 44618:c07a47b33368160d 47339:40663eeabb67db05 49120:c08efc251d33eaea 49179:404307dd6d711914 49408:7ff8000000000001 50273:c03441dec2446dbf 51880:c03066bc267d564a 52047:c07c34aab321f505 70837:c0808a1e399b0d5f 72249:7ff0000000000002 73921:7ff8000000000001 76742:7ff8000000000001 ; 58420:4010000000000000 58626:4010000000000000 58832:4010000000000000 59038:4010000000000000 59244:4014000000000000 59450:4018000000000000 59656:4018000000000000 59862:4018000000000000 60068:4010000000000000 60274:4008000000000000 60480:4008000000000000 60686:4008000000000000 60892:4008000000000000
+count_over_time - 1000 0 27430 3405 18 ; 2389:7ff8000000000001 4750:408822f45b9c580c 6731:4083a772a29d29e2 8717:c08bd0127665629e 11355:c088b69ab73c49bd 14029:4068cd18698d52b0 15425:408f0dcb60cd43bb 16933:c08713f0258fce03 19275:c08e4bd17028f5ca 21077:7ff8000000000001 21461:7ff8000000000001 22391:c0687bd0171ebb00 23059:c08d7ee450ae00b5 24403:c0841b99485e4a68 24512:c07d133203136736 24770:7ff8000000000001 26546:408ef2c82504f192 29153:c069aa1ab960efb9 29402:c084cff67002ef86 31959:408d2771bc00448b 33148:c062b3428b9de41c ; 27430:3ff0000000000000
+count_over_time - 3457 -3590 16122 3497 7 ; 2952:40571d7b0cb13e74 4800:405ced59fe2b0df6 6677:405f1012f56d0a3f 15280:4060853f2d977ab1 18192:40615d570e8d0598 19908:40670097d10384fc 21959:7ff0000000000002 42907:406b4285fd83d290 45869:406e9b80474148ea 47971:406f1213d8102a5f 49585:4071e73e2fe3190f 51550:4074180060c97ce0 51595:4074607b9e50f050 54052:40237fc79511becd 54963:4017831f2ae50ef0 55663:4040b635e29894d6 56845:4047d22911e24a6b 78348:40508942682816a4 79261:4053b637a7801d9f 81580:3fda6c31951868ac 81930:404273d80dcffb30 82502:4050200f13051e34 83820:405c5b1e61eb6d22 ; 16122:3ff0000000000000 19619:3ff0000000000000
+count_over_time - 1165 -1994 12973 1164 11 ; 7160:7ff8000000000001 10079:4074bcfec3a372a3 10715:c05c5e498affa56e 13608:7ff8000000000001 14975:4079be7351a87f30 16333:401581d11702ef20 18936:4076976e657246d3 20654:407dc8c01c16f160 20820:408eba9d456a2b68 21943:7ff8000000000001 ; 14137:3ff0000000000000 15301:3ff0000000000000 17629:3ff0000000000000 18793:3ff0000000000000 19957:4000000000000000
+count_over_time - 3589 0 19176 3589 10 ; 15659:403fac50e389b110 17554:4020da6e5237ad72 17677:40410ad4d16f2174 19318:404e64c1b91635b0 21921:405181cc4f420927 24830:405b586fe47879ce 26232:405d750b6b8abac2 27870:40623cb3409febfc 28771:40662becdce7ed17 31186:406734cdb48f7766 31293:406aca3c3828cf72 31502:7ff0000000000002 31755:406c119db46a5721 34208:406f18ba54437dd9 36759:4071f2e49148834c 38525:40727d3ceb01c62f 40676:40751d759d040877 41818:40780c73128e2693 48806:40797f5060ba04d5 ; 19176:4008000000000000 22765:4000000000000000 26354:4000000000000000 29943:4000000000000000 33532:4008000000000000 37121:4000000000000000 40710:4000000000000000 44299:3ff0000000000000 51477:3ff0000000000000
+count_over_time - 3443 0 28758 1718 2 ; 32792:417ddcdff3e05c27 32935:41436e954cdee48e 33432:c1bacfd52eb8ca26 34754:420de919e28d24b5 37703:c2b2cd5ae2d7b851 ; 
+last_over_time - 1000 -8405 40463 1407 8 ; 17730:428c7be624f74307 18033:4290a6aab622e962 18098:bff5f9fa55ed3541 19424:41b5eb4c5c98bf05 21100:c2bb440d493e6b13 23277:42b33638d9a6b1af 46267:41b404f44dff2c78 47094:c25cecd6eb1f83a9 49344:c14ca905ff337988 49672:c2a2b3aea93dd1cb 52473:427dbdd537c75292 54940:40e3cf32548536f0 54966:c220f9f618e14759 56245:4223e1c4b87a2798 58526:422a681bde35c736 61209:c1eb800e86a59f77 63463:42f50c1b846dc3a6 66150:c17454ca69134480 72285:c27c2880824f581f 73371:c232e3843fc56978 74370:409999594cc06977 75361:c0a536c1daed7aa2 76472:c07d7f798ba89257 76711:41933a4524bd2891 89966:3fcb87483e176444 ; 41870:c2a2b3aea93dd1cb 44684:427dbdd537c75292 47498:c220f9f618e14759 50312:422a681bde35c736
+last_over_time - 332 0 15903 331 4 ; 13983:430c6bf52634027c 16020:430c6bf526340157 25009:430c6bf5263402a8 ; 16234:430c6bf526340157
+last_over_time - 293 0 5866 143 8 ; 1619:c08bb26cbfb5d8de 2611:40815081e5f58eca 3755:406777c2ae1c3bb6 6158:c086ffd69118e943 6727:7ff8000000000001 8814:c06c08f0e59596a4 11360:403952af384903ee 11514:407235df71c88b82 13651:c0813dec7706a903 14360:7ff8000000000001 14806:405cd674ab67818e 17491:c08e92f4965df0d7 17921:c082c1f128875750 18335:4080f9fb60544eba 18394:7ff0000000000002 18788:c08e9fb6ea3551e3 ; 6295:c086ffd69118e943 6438:c086ffd69118e943 6867:7ff8000000000001
+last_over_time - 2709 0 21834 1351 1 ; 9340:7ff8000000000001 12256:7ff8000000000001 14991:7ff8000000000001 38934:7ff8000000000001 39388:7ff8000000000001 42385:7ff8000000000001 43945:7ff8000000000001 45341:7ff8000000000001 45651:7ff8000000000001 48389:7ff8000000000001 51217:7ff8000000000001 53484:7ff8000000000001 54282:7ff8000000000001 57005:7ff8000000000001 58879:7ff8000000000001 59642:7ff8000000000001 ; 
+last_over_time - 16250 -9636 43885 3335 12 ; 19408:40e703267e89e794 21435:c0392ffea25656a8 22721:c0cb22fe761d63b4 25208:41178cdc537d122f 26553:7ff0000000000002 26831:c07e11afbca1ff95 27599:c25923b7ad88b57a 28387:c0dbf7605f3abfd1 49416:c1077041df99a297 51081:40451b105d15d41f 53697:4284c1fdcba21fe7 54123:413286c56c569ea6 56689:c252bb2cf5e68611 57797:42c5c89c039985e0 60027:4040f0df7d8e1783 60206:41dc60e625024d31 60403:414bfa8920f89c8a 61478:42135daf91a222be 64388:c151b3b83db9821e ; 43885:40451b105d15d41f 47220:c252bb2cf5e68611 50555:4040f0df7d8e1783 53890:42135daf91a222be 57225:c151b3b83db9821e 60560:c151b3b83db9821e 63895:c151b3b83db9821e 67230:c151b3b83db9821e 70565:c151b3b83db9821e
+last_over_time - 19098 -3862 12476 1369 14 ; 12059:4088cbab0fa36e35 13777:4077c4498332cadc 16120:c072e0bfaf038b1c 18440:4075b7f6633140bc ; 12476:c072e0bfaf038b1c 13845:c072e0bfaf038b1c 15214:4075b7f6633140bc 16583:4075b7f6633140bc 17952:4075b7f6633140bc 19321:4075b7f6633140bc 20690:4075b7f6633140bc 22059:4075b7f6633140bc 23428:4075b7f6633140bc 24797:4075b7f6633140bc 26166:4075b7f6633140bc 27535:4075b7f6633140bc 28904:4075b7f6633140bc 30273:4075b7f6633140bc
+last_over_time - 1555 -6324 36904 1555 17 ; 9355:4089b90091a5242b 24077:404e6ddc98049385 24412:c02536980a11bbf6 26382:c08ea5835829cc3e 29034:c0734c1e87604b6e 30556:c0709a132e479e3f 32524:7ff0000000000002 33675:c06e2f1a8b9dadf7 36615:c089663e8a3ea8a2 52107:c07cad89efd534e2 54922:7ff8000000000001 57285:c08e9591868add78 58703:c04b1fbea68253b1 60619:c0627dcccf9b77f3 61056:4075847dc184f8b4 63059:c07b05c74bdfe3aa 65520:c063e74a4b46cab2 65730:3ff736ab57aa3890 68461:407ef1585f7ca7df ; 46234:c07cad89efd534e2 49344:7ff8000000000001 52454:c04b1fbea68253b1 55564:4075847dc184f8b4 57119:c07b05c74bdfe3aa 60229:3ff736ab57aa3890
+last_over_time - 2920 0 3807 2920 3 ; 7173:fff0000000000000 9452:fff0000000000000 11795:fff0000000000000 12483:fff0000000000000 14270:fff0000000000000 17087:fff0000000000000 18410:fff0000000000000 19683:fff0000000000000 21500:fff0000000000000 23868:7ff0000000000002 24838:fff0000000000000 27178:fff0000000000000 30043:7ff0000000000002 32879:fff0000000000000 34677:fff0000000000000 36493:fff0000000000000 37590:fff0000000000000 38235:fff0000000000000 ; 9647:fff0000000000000
+last_over_time - 1222 9642 32307 1222 20 ; 35800:c059168adf528cbd 38052:407b7bd732442bf1 39093:4087896d65a65af6 ; 45749:c059168adf528cbd 48193:407b7bd732442bf1 49415:4087896d65a65af6
+last_over_time - 3175 0 38637 3175 18 ; 14476:c08a5c9f0848a827 17037:c0865fc85c1c45fc 29922:4048ea25931b8c3e 31969:40563794ca627eb4 32551:c0850fb63644fab0 35434:c07252a8553d8a14 38017:7e37e43c8800759c 38176:7ff0000000000002 39692:c05c7b2298f8d412 40309:c0243b49ed3a3260 42896:407b605282025f47 43569:c05d6d66e7c4922c 45917:c06ea960f196c3ef 46997:c07e21c401a7c19e 49377:c07b32bf7a6f74d7 51381:c07e77699d6f4bf1 52419:4086e06e8659442e 53144:c08788963f9fbe23 55603:40852a32fb427e2b 56889:40886aefacd868b7 59765:c085eb75695c55d6 61787:fe37e43c8800759c 64493:c0743af7a15ec850 65178:c05311cb273ac601 67264:c08974b1b4faf778 ; 38637:7e37e43c8800759c 41812:c0243b49ed3a3260 44987:c05d6d66e7c4922c 48162:c07e21c401a7c19e 51337:c07b32bf7a6f74d7 54512:c08788963f9fbe23 57687:40886aefacd868b7 60862:c085eb75695c55d6 64037:fe37e43c8800759c 67212:c05311cb273ac601 70387:c08974b1b4faf778
+last_over_time - 4405 0 27080 2199 8 ; 14633:408559be679907c0 16240:40485e61d0f973ae 18491:408668ae98a618cb 18916:7ff0000000000000 21366:c082c8885b5933cd 22350:fff0000000000000 22928:407b61b003ccbea7 23760:c06309cb59588386 25800:406cb999282b7eee 25830:7ff8000000000001 26695:c08912eeaad8df2f 29205:c08053cc86632165 31888:c0638f87087c1109 32633:c06b354844561ac5 34093:4051acf546944fc8 35405:fe37e43c8800759c 37395:c08bd4c8b2cefe12 39428:c08d2b14979d5a9b ; 27080:c08912eeaad8df2f 29279:c08053cc86632165 31478:c08053cc86632165 33677:c06b354844561ac5 35876:fe37e43c8800759c 38075:c08bd4c8b2cefe12 40274:c08d2b14979d5a9b 42473:c08d2b14979d5a9b
+last_over_time - 1406 9380 15376 1406 7 ; 12083:40428ab73dcef882 13162:4044caf295a4850a 15060:4044f231d0ee43c1 17396:404880fa0dff046e 17963:7ff0000000000002 20934:404e3f8af8873f92 45881:405b4f85e0fc6fb9 ; 22406:40428ab73dcef882 23812:4044caf295a4850a
+last_over_time - 1000 0 39737 2487 6 ; 18644:4221a5781be3140d 20660:42417e9f1b8311d5 22781:423d246ddc3a2680 23456:c1dbb637f290ce7b 43039:bfd46cb09b8ad53c 44468:42565e12ab8151de 44552:41dbeebc23417264 45278:bfdd393c1ebb6210 45799:40e48b0c5b02f4a1 47021:c1f8c3a1cefd3ee7 49597:42c3c9de98309716 62647:c146df5445c09b1d 64591:c1813b49d6a27864 ; 44711:41dbeebc23417264 47198:c1f8c3a1cefd3ee7 49685:42c3c9de98309716
+last_over_time - 1000 -9960 21008 322 19 ; 14994:c06fa21b87586f28 15730:c04080bc007d1402 18031:7ff0000000000002 18702:405989ad1d2bbc6d 21596:7ff8000000000001 23555:c056c467e77a485c 25238:7ff8000000000001 27979:c08659739a959457 29566:407e5d904794cce2 30269:407b6a7c0117a543 30815:c08e8fa06f3a23c2 32492:408d82f71413515a 33826:40847f8386a68980 34667:4080e17baae554e9 35503:406ee75eacd9a328 38438:4086aafe760559b6 38883:7ff8000000000001 41711:c075641d944b267e 42504:4085837a25ec0eda 45050:406892f0cd449cb2 63846:4083e4ba497b33c6 ; 21008:c08e8fa06f3a23c2 21330:c08e8fa06f3a23c2 21652:c08e8fa06f3a23c2 22618:408d82f71413515a 22940:408d82f71413515a 23262:408d82f71413515a 23906:40847f8386a68980 24228:40847f8386a68980 24550:40847f8386a68980 24872:4080e17baae554e9 25194:4080e17baae554e9 25516:4080e17baae554e9 25838:406ee75eacd9a328 26160:406ee75eacd9a328 26482:406ee75eacd9a328
+last_over_time - 1000 0 42998 124 16 ; 14436:c0856472bef3506f 14767:407b006b5333e7f3 17461:c07860a0f53020cb 18527:c086a37e9e1442b9 19749:c06d2a07b7481f35 20151:c08c382d18dcd35e 21759:4088929e897e1f5d 46058:c086f243ed0653d4 46452:c081950394640b8f 48871:40835ea354115bc8 51127:7ff0000000000002 51607:4079436b60e4edd3 51906:c07e14ca6c44e720 53512:8000000000000000 54019:408f337dd094d526 55482:408352731ed63f1f 56055:408d0d9a9f8d2ea7 56294:c0741cb9063443d1 58168:c087811376373cc0 58268:c08ddea283d07de9 60617:407a99d2b1c253ae ; 
+last_over_time - 16079 0 11200 1592 4 ; 5010:7ff0000000000002 5645:4247575e147c87cb 6742:414906054975263a 8188:4236a0fed1b61265 10135:c0f0d9b2565f3467 12770:c11194f0aca7359e ; 11200:c0f0d9b2565f3467 12792:c11194f0aca7359e 14384:c11194f0aca7359e 15976:c11194f0aca7359e
+last_over_time - 1000 0 54542 1380 13 ; 20882:fe37e43c8800759c 23716:fe37e43c8800759c 23767:fe37e43c8800759c 25841:fe37e43c8800759c 26841:fe37e43c8800759c 27097:fe37e43c8800759c 28730:fe37e43c8800759c 31258:fe37e43c8800759c 33094:fe37e43c8800759c 35013:fe37e43c8800759c 37646:fe37e43c8800759c 39531:fe37e43c8800759c 42339:fe37e43c8800759c 43627:fe37e43c8800759c 44337:fe37e43c8800759c 46637:fe37e43c8800759c 47629:fe37e43c8800759c 50035:fe37e43c8800759c 50493:fe37e43c8800759c 53054:fe37e43c8800759c 55180:fe37e43c8800759c 57095:fe37e43c8800759c 58139:fe37e43c8800759c ; 55922:fe37e43c8800759c 57302:fe37e43c8800759c 58682:fe37e43c8800759c
+last_over_time - 1408 0 15384 1408 16 ; 19746:7ff0000000000002 20161:c2c0c92d0c33819e ; 21016:c2c0c92d0c33819e
+last_over_time - 19465 0 16052 2533 9 ; 9254:c077a953480114f0 9441:c0834935893175b9 12271:407a9ac67a0bca63 23565:405e86cd0265be88 26520:c08cc5f5ac3ee9f6 28248:c08e1c76eb4e093a 29546:8000000000000000 32167:4084c7ea3d38adb9 ; 16052:407a9ac67a0bca63 18585:407a9ac67a0bca63 21118:407a9ac67a0bca63 23651:405e86cd0265be88 26184:405e86cd0265be88 28717:c08e1c76eb4e093a 31250:8000000000000000 33783:4084c7ea3d38adb9 36316:4084c7ea3d38adb9
+last_over_time - 1000 -6210 44871 3225 6 ; 20403:3fda430ce232c090 44683:41ee389f486a7814 45997:42e3c6ea8055d69d 48174:c1f13dba32a01736 49695:c07e2b307471e334 50322:4178ec2ec3417a9f ; 44871:4178ec2ec3417a9f
+present_over_time - 1000 0 24031 1962 2 ; 19611:7e37e43c8800759c 20615:7e37e43c8800759c 21481:7e37e43c8800759c 22126:7ff0000000000002 22183:7e37e43c8800759c 22476:7e37e43c8800759c 23200:7ff0000000000002 25542:7e37e43c8800759c 26025:7e37e43c8800759c 28412:7e37e43c8800759c ; 25993:3ff0000000000000
+present_over_time - 7634 0 75425 2093 10 ; 9979:fff0000000000000 10800:c08963ccc83c5a74 29136:4073d6674fb13e66 31019:4076c5bad98184b0 33913:c08d0b41aef597e3 34038:408cead8a9547c45 36518:c07cea4141cbe87d 38997:40719d95b0a8cec2 57775:7ff0000000000002 57976:c08bd94d02e294c2 60908:c0685aeb2fbbc737 62446:c061c8d2ce267ca9 62640:408917a8f1b393b5 62757:40754c22808b1de5 62846:c080913f9ca171a7 63615:c087eda131380c64 66384:407d0efdd2a49a4b 84459:0 84807:4070402f6f3a7b30 86612:407b8af994010cc9 86993:406c55ddfece5ba4 ; 85890:3ff0000000000000 87983:3ff0000000000000 90076:3ff0000000000000 92169:3ff0000000000000 94262:3ff0000000000000
+present_over_time - 16321 0 -812 2286 17 ; 2761:c050506fa0a3f67d 4327:40867d8fc15e24e7 4719:c08805647fb53a07 6885:406b11408a15e8fb ; 3760:3ff0000000000000 6046:3ff0000000000000 8332:3ff0000000000000 10618:3ff0000000000000 12904:3ff0000000000000 15190:3ff0000000000000 17476:3ff0000000000000 19762:3ff0000000000000 22048:3ff0000000000000
+present_over_time - 105 0 26459 104 15 ; 6232:42c4d480a899cedd 8438:c1e670d3cc4a82f3 9343:c2fb5c6e2c32e107 25298:3ffccc3f0fce8c5e 47749:413c51eb9477a1e4 50389:42c6652833ead261 52940:4177bd5e58413736 55227:3fbc82b0a88e07a8 58082:4114fdf0350e14b4 59224:c2f288240b2e26d6 59796:c02f1791b47242a6 62554:40cf51579cee3cb0 63719:409bef68e9feb853 64182:c201194b474b2349 64581:c2c223aeca80d902 64958:c2b5e692d0c42fa4 65930:42196dc17122b1a9 ; 
+present_over_time - 1000 0 35016 3921 6 ; 28997:c0831f13bebcc90c 31300:4084cac64157573a 34002:408d001e4e170cc6 34207:3ffd668c854a3e78 34619:7ff0000000000000 34745:c081fef5b512abc4 35150:408f34577bb7c93f 36581:40870ffeb55541eb 36930:408bd357ae53f66b 38350:c07e3c13c588820d 40083:7ff8000000000001 41328:7ff0000000000002 43419:c05a80f780a4edca 43841:408ea0aa1ea1c096 46593:c05db862735bdb14 49247:40868c7ea55c2b1f 49388:7ff0000000000002 50753:4057d22d6d0ed40f 52123:c07e8a49fae70639 ; 35016:3ff0000000000000 38937:3ff0000000000000 46779:3ff0000000000000
+present_over_time - 1812 -225 29443 1812 15 ; 14522:407dc41515c4329b 15496:c07beff66f57d31b 16185:c07f62f0810c1d26 17491:7ff8000000000001 20353:408302d179962ea9 23230:4078e17345586ef3 25881:c07622ee2d654209 26641:c07fda957d28aa54 26794:c0787463f2792c55 28880:7ff0000000000002 30662:406c88c81d318dc2 31929:c043770c25217806 34305:c08782cb7c76b2b6 34382:c06f46bab78fdb1c 35956:c080eab598c72a2d 37658:40860571a6fdc316 38595:c06698ccf6687730 60571:4088f960cc1fff85 62467:c08c9551ed267c2d 64875:c0786e09763b2f44 67810:7ff8000000000001 68141:7ff8000000000001 69168:c0750e6e4742d2fc 70187:408ee8d5ff232a9e 71730:c08d836479e42572 ; 31255:3ff0000000000000 33067:3ff0000000000000 34879:3ff0000000000000 36691:3ff0000000000000 38503:3ff0000000000000
+present_over_time - 6111 0 23989 3052 8 ; 11780:430c6bf5263401f4 12699:430c6bf5263401d5 14851:430c6bf52634010f 14889:430c6bf5263401a2 16877:430c6bf52634023b 18391:430c6bf5263401db 18574:430c6bf526340173 20526:430c6bf52634020b 23124:430c6bf526340040 24936:430c6bf5263400a9 25448:430c6bf526340177 ; 23989:3ff0000000000000 27041:3ff0000000000000 30093:3ff0000000000000
+present_over_time - 1344 -1446 5997 1343 20 ; 2917:430c6bf526340160 3871:430c6bf52634010e 6474:430c6bf5263402fa 8578:430c6bf52634023d 10673:430c6bf5263400e2 ; 5997:3ff0000000000000 7340:3ff0000000000000 10026:3ff0000000000000
+present_over_time - 1000 -2457 34823 1210 11 ; 14737:430c6bf526340046 14835:7ff0000000000002 14995:430c6bf526340280 17475:430c6bf526340001 18042:430c6bf526340312 18703:430c6bf526340119 19587:430c6bf52634014f 22231:430c6bf52634028b 23543:430c6bf5263401b0 24061:430c6bf526340231 25282:430c6bf52634014c 25507:430c6bf5263402dd 26647:430c6bf52634001a 27047:430c6bf526340132 27768:430c6bf5263401fc 30243:430c6bf52634026c 30924:430c6bf52634008a 32362:430c6bf5263400f8 34374:430c6bf52634015c 35281:430c6bf52634029a 35803:430c6bf5263400cd 37164:430c6bf526340199 39889:430c6bf5263402a8 42773:430c6bf52634029e ; 34823:3ff0000000000000 40873:3ff0000000000000
+present_over_time - 1147 -3021 28937 1147 6 ; 6395:430c6bf52634005f 8701:430c6bf52634003a 11443:430c6bf52634025c 12471:430c6bf5263402dd 13605:430c6bf5263400fc 16206:430c6bf52634009f 17808:430c6bf52634008c 18102:430c6bf526340033 20548:430c6bf526340024 20829:430c6bf5263402e3 22527:430c6bf52634010b 23867:430c6bf5263400fa 26224:430c6bf526340023 26751:430c6bf526340317 29114:430c6bf5263402c7 29300:430c6bf5263401d7 29917:430c6bf5263401c5 32612:430c6bf5263402f8 34688:430c6bf526340154 35628:430c6bf526340039 36535:430c6bf526340236 36780:430c6bf526340143 37189:430c6bf52634021c ; 30084:3ff0000000000000 32378:3ff0000000000000 33525:3ff0000000000000 34672:3ff0000000000000
+present_over_time - 1000 0 9759 234 1 ; 12616:408b8d6813397bba 15046:c054d492a12a0842 15056:c08d8a8dc4920bec 18018:4081c65f77ebb82e 19463:408609faa860aabd 21115:7ff8000000000001 23774:4083fdad82e5b0e3 25765:7ff8000000000001 26115:4082bbf38a19f8e0 26567:40754c56b53a727b ; 
+present_over_time - 1000 -1302 12483 307 17 ; 12428:4109a0dc7e9412d8 13707:3fd47821151ffdca 14884:c15c7cba1d05eb0c 15099:4039c5e4ebc86910 16929:4279076588142a11 18697:3ffd1b25fd97ee0a 19108:413eca568247b4b6 21394:c0b80333302d1448 22428:424c2ac8e23f9411 23523:4081925033b2883c 26498:4145b56634835445 ; 12483:3ff0000000000000 12790:3ff0000000000000 13097:3ff0000000000000 13404:3ff0000000000000 13711:3ff0000000000000 14018:3ff0000000000000 14325:3ff0000000000000 14632:3ff0000000000000 15860:3ff0000000000000 16167:3ff0000000000000 16474:3ff0000000000000 17395:3ff0000000000000
+present_over_time - 246 0 19000 246 1 ; 4889:408601862cb7f4a6 7786:c085c50de3374508 9639:c08f3995516f3b1c 11397:c0889f3b64da3459 11804:c08aafe7da9dcbee 14018:c04b84aae3c9e64c 15885:c0574aea64bf0e10 16866:7ff0000000000000 17744:c079b3fd11b4ece2 17998:c081eb0399199564 20751:c054abedfdb648ec 22716:7ff0000000000000 ; 
+present_over_time - 13230 0 18414 295 13 ; 4689:4057846fd3493372 6333:405deddee9b12e2f 6807:40627e0b97fc04ab 7942:40649fc6427dd816 9597:4064e63602486069 19738:406a91912738360a 19828:406da9dd794e3c0e 20948:4071a63cc56a1c23 23918:4073c751b203b25f 26873:7ff0000000000002 28668:40747acb26939354 30024:407545afe8a96248 32904:4012530577394fc1 34286:4026abe01a2f80a0 35024:404ca1163429d9f3 ; 18414:3ff0000000000000 18709:3ff0000000000000 19004:3ff0000000000000 19299:3ff0000000000000 19594:3ff0000000000000 19889:3ff0000000000000 20184:3ff0000000000000 20479:3ff0000000000000 20774:3ff0000000000000 21069:3ff0000000000000 21364:3ff0000000000000 21659:3ff0000000000000 21954:3ff0000000000000
+present_over_time - 1282 -4511 60770 1281 2 ; 15696:c0878e9706a04cde 18635:4080052b536d568d 20627:40712f0e233ed2e7 22828:403b3e1d164cb8fa 24694:c06bd04378deb486 27030:c08e4e4562dad5d1 28147:40739b24d06aa939 30628:c064ea67c838b9d1 33072:7ff0000000000002 33865:c0653b46fea59e88 36119:c07ac5fc4949b268 37890:c0822220305617e9 39852:c0634f0eaa1241e8 50034:407b23f290e43dcd 51582:40812e667fa716d8 53045:40828b13a087c1c0 53958:408b01d4647066d1 54648:c06706af90aae19f 54813:c078056bec269d42 61865:4083e1fc203e5c82 64536:c0897a779348666b 66397:c04132749c0f6e80 66699:7ff8000000000001 67334:c082601d067d260a 70281:4086839348a31db9 ; 60770:3ff0000000000000 62051:3ff0000000000000
+present_over_time - 387 0 26790 386 6 ; 19322:bff48b3391b53cd8 39066:4167a2438e920318 41753:3f7a9bc960824100 ; 
+present_over_time - 2753 0 19741 2755 13 ; 14101:430c6bf52634003d 16733:430c6bf526340185 18859:430c6bf52634011c 20710:430c6bf5263402ca 22793:430c6bf526340007 23890:430c6bf5263402be 26108:430c6bf5263402e8 27377:7ff0000000000002 28828:430c6bf526340095 31024:430c6bf526340269 33681:430c6bf5263401c7 36016:430c6bf5263400c2 36115:430c6bf526340280 ; 19741:3ff0000000000000 22496:3ff0000000000000 25251:3ff0000000000000 28006:3ff0000000000000 30761:3ff0000000000000 33516:3ff0000000000000 36271:3ff0000000000000
+present_over_time - 1993 -9294 2804 1993 5 ; 5277:430c6bf5263400ce 7591:430c6bf52634028a 9616:430c6bf526340159 ; 
+present_over_time - 1066 -2897 45534 1133 17 ; 34919:40a96df02c6b500e 37019:4185af3f1987b6bb 39490:c0e08e4e42bbbcc7 41100:414362795319e5b6 42321:4274de13e58a78f4 43597:4219979917a79406 45202:417ef0340bce49a1 46274:4221e44ec2aae090 46479:42a7aa269f4ce791 48909:c2248329bfb7cfb4 50027:c18702cf20c74503 ; 46667:3ff0000000000000 47800:3ff0000000000000
+present_over_time - 1000 -8458 15670 1491 9 ; 14585:4069354668750d9a 16166:c07f60075904dc35 18795:404406911db49cf9 19544:c07ef484489126ec 21408:40603a8382368a7e 23966:408908c26e4f9ee8 26156:7ff8000000000001 ; 15670:3ff0000000000000 18652:3ff0000000000000
+stddev_over_time - 775 0 10272 384 11 ; 11411:c067d44e36c42cc3 12858:c089915c82647d19 13517:408ef5b97f963b0e ; 11424:0 11808:0 12960:0 13344:0 13728:0 14112:0
+stddev_over_time - 1290 -5190 19590 1289 4 ; 15770:430c6bf52634023e 16437:430c6bf5263401d8 32946:430c6bf52634001c 35490:430c6bf5263400a9 37955:430c6bf52634028a 39895:430c6bf526340095 39977:430c6bf5263400db 42161:430c6bf5263400b5 44316:430c6bf52634020e ; 
+stddev_over_time - 1635 1737 43442 814 5 ; 20146:405425b0a0f127e7 23105:7ff0000000000002 23654:405a9ae89956445e 24315:405e61c5f9f2f94d 24328:406382be4c07f5a0 26409:4064409442186548 28765:4066c33034fbde9c 30053:4015eedbd0899f00 32643:4045b7e8c7ef2e87 33933:4047a205445a322e 35451:40575c038db4486a 38161:4058330c736ff747 38253:40591694d8750fcc 40223:405b4aca0597d8e6 41961:406202e684c86cef 43649:4065ee83081bc7d8 44123:406b88efa38f0aa7 44707:4070bac4e08fb568 46737:4071cb0c8b1c928a 48988:40729d53886bb102 49989:40743ea15a17628d 50174:4076521571c06e40 ; 43442:0 44256:0 45070:0 45884:403669b26dcd0b3a 46698:4042d3a0e4e400f4
+stddev_over_time - 2809 0 21327 1401 6 ; 16289:430c6bf52634000c 16316:430c6bf526340313 17265:430c6bf526340149 17420:430c6bf526340178 18667:430c6bf526340046 19962:430c6bf52634020d 21717:430c6bf5263400e8 23573:430c6bf5263402d3 23702:430c6bf526340150 26234:430c6bf5263401a5 27408:7ff0000000000002 27807:7ff0000000000002 30778:430c6bf52634030a 33369:430c6bf526340007 35370:430c6bf526340150 37844:430c6bf526340299 40499:430c6bf526340279 41510:430c6bf526340113 49118:430c6bf5263401b8 52023:430c6bf526340285 53683:430c6bf52634008e 54288:430c6bf5263402b8 ; 21327:403c67fedf9cd834 22728:403247fe3fe3e8cc 24129:403a6205959d8457 25530:403837feadbfe1a2 26931:0 28332:0
+stddev_over_time - 3066 -1478 29756 3065 2 ; 18262:0 20328:0 22772:0 24338:0 25257:0 27647:0 29951:0 30328:0 32501:0 33330:0 35632:0 38271:0 39294:0 41477:7ff0000000000002 49596:0 50350:0 53144:0 53974:0 54839:0 55761:0 ; 29756:0 32821:0
+stddev_over_time - 1000 -6860 51285 1367 8 ; 8873:40534928edc24ac1 9198:40574412e96f33ed 9218:406079351e5caea1 10414:40624b160548e62c 11731:4068333afb551082 13301:4069bb299c1e5847 15217:40123dd4f62e60b2 15387:4046112f5d91191f 16936:405176a33a173c71 18812:405d95ada5dfc4b0 27869:3ff2c7a76cc06ecf 28865:4025279c73865f76 31493:4039d73c61cfa706 42482:4042f2404ba27f36 45348:4052363c71f70253 47027:405e368acd003aee 47915:4063821113593528 50889:40696838094e907f 52867:406e7c664135cd58 54183:406f1377bc34ab2e ; 
+stddev_over_time - 11641 -3265 11106 3206 1 ; 6688:c07d28aed10e624b 9301:c08185f79a55fd6f 10512:c085c8b0121d4109 10614:c065b7f9cc88e8a4 11081:4085654552042cdc 13602:4086103c5a9fae10 14433:c07b36bbad406a9e ; 11106:4081eafacfa2aaf4
+stddev_over_time - 1000 -6451 6457 3300 16 ; 7440:c08c4c16d63e9afd 9228:7ff8000000000001 9694:4005b39c9c570718 ; 
+stddev_over_time - 608 7363 27770 608 3 ; 24703:40797bce73893562 26588:40879646c1e9cf80 27500:40864c944b322cfc 29801:408a9b924868faa8 31053:c065433b1aaf20b0 34032:408840bac927fd16 36120:7ff8000000000001 36810:408692b6329836f7 38756:c076ecac8157e828 40832:4086cd1491ec9418 43225:4078bb624aade8eb 43744:408626d4b242b794 46257:c08375bd9b5a6ccd 47889:c08df1e0dc391e1d 48131:7ff8000000000001 49011:7ff8000000000001 ; 
+stddev_over_time - 2563 0 14522 2562 10 ; 6802:7ff8000000000001 9234:c08a64c5dc327f0b 10998:c08484828ddf6490 11195:7ff8000000000001 14031:c05eff87b8af3b23 26347:407d7335335cbd42 27938:c06911aa3e5b581d 28364:c049f5c789b12713 29082:c077fc8892146231 31292:7ff8000000000001 32818:407c421065b5f51a 33205:c0764a93bfa0bc79 35459:407e2f3fff4817d6 38039:407ee955ac72aa38 40738:c03a1505188c169c 49000:c08a89330f8ac331 51382:7ff0000000000002 51608:408f218aa8fded19 53841:c086f50d01bddf1d 55438:7ff0000000000002 56385:408e8ed810b64dfb ; 14522:0 27332:0 29894:4060f74a2771c028 32456:7ff8000000000001 35018:4079465212ab58c9 37580:0
+stddev_over_time - 1000 4636 51617 3192 14 ; 4719:407aba32908f9b20 5514:c073297d3164ab56 6371:c0843036f089dc75 16442:40795201d98bd161 19276:7ff8000000000001 26394:407ecaceca380cb1 41223:7ff0000000000002 42766:7ff8000000000001 42995:7ff8000000000001 45494:c083c4d7a6348e19 58135:407e4b8e20fcc90f 59960:408542887466b69f 60902:7ff8000000000001 79162:408c019671a8a222 81940:c08e17fb94c78887 82948:c08530545e57183a 83897:7ff8000000000001 85221:4078beea9f8a02ec 85502:408a5bc868214448 86421:7ff8000000000001 ; 86729:0 89921:0
+stddev_over_time - 1000 0 13217 2753 5 ; 17206:430c6bf526340166 17676:430c6bf526340089 ; 
+stddev_over_time - 7309 1081 43906 3651 10 ; 17148:41650e403869523b 17238:c2db17c233f0d11e 19444:41bc84d7bf0f70e8 19807:407088e4b05a6bcf 42864:41c964b6a5a6c347 43953:4262bd828ed9703f ; 47557:4252b7296130068e 51208:4252b7296130068e
+stddev_over_time - 878 -8772 15986 877 9 ; 7928:40592b85a379f5a0 8862:7ff0000000000002 10858:4062a0574397bd72 11664:40203deab67494f0 12823:4041fe032f2995ac 14575:404e3c2e85f2d7ba 16603:3ff57f18cf042eb9 19074:403eb39dd699b8cd ; 
+stddev_over_time - 7487 8547 42697 3740 18 ; 2606:407bf3ec4642a1f2 4273:408de9418b8dd43c 7019:7ff8000000000001 8658:407a458daca37c82 10116:c0896c7426c8d946 12987:c081815f969d57eb 14289:c08b481ca326f773 16037:c0703c7b2a55c14c 16604:7ff8000000000001 19396:4081bdbfe1d8eebc 22184:408cd8bf79eec2ab 23628:7ff8000000000001 25364:4081df9dc985958a 40219:7ff8000000000001 40698:407e3c8ddbbb24f5 42616:c0812183979d645e 44367:7ff0000000000002 44981:407f375659330700 ; 50177:7ff8000000000001 53917:7ff8000000000001 57657:40805e97621b73ef
+stddev_over_time - 5699 0 13792 2846 14 ; 11666:c25aa36c8a34903a 13135:c1a21ab9ad891ae5 14153:4241a9c7fc0e6024 16101:c286554177d70fa2 17761:c068401a9e5a3321 17981:4145857e9454b561 18313:c2e487671fad0be7 20688:4113f71bae8705eb 20842:3ffb152e5ff5dd1e 22703:40b186b31300d8b1 25066:42e8bc55c1f1fef0 25669:c11aefa328954e2c 25853:425cbc395b5dae9b ; 13792:424aa12932fedf17 16638:4272fb1862e424ce 19484:42d05bee52cb4057 22330:42d06c5280f1099e 25176:42d56bf684d5243d 28022:42d567d3f4a32372 30868:424cbc3b0a57e125
+stddev_over_time - 1000 2519 7530 624 2 ; 10577:4087e1b4c958ccb5 12595:408e0c0e190f9ba4 13287:407b603bfbe86b5f 15645:c07985fbefdf8626 16698:c0658ab74d62b55d 19648:7ff8000000000001 21811:c07a29bd9effbda0 22385:c06cde4e75c37e15 22941:c083f36c7764eaca 25301:403ab8cddec53dc3 27467:4081de373f91daf0 29862:4032862680d8cc3e 30978:7ff0000000000002 31016:40847c82a523d153 33767:c08734d8c67fa2a4 34001:7ff8000000000001 34014:405cb93ddd705d8f 34619:c06e36fec6f6f49c ; 
+stddev_over_time - 2564 1717 12355 2564 14 ; 14189:404d35180e3a7bea 16152:405201c81ed8dc5a 17194:405a916a4a39f5c6 18170:405b34199ace5024 18638:405edc2e8b29bef6 ; 17483:0 20047:4030c630a62c82e0 22611:0
+stddev_over_time - 1104 7441 37402 1103 8 ; 14596:430c6bf526340142 15377:430c6bf5263400da 16228:430c6bf5263402e8 18867:430c6bf5263401bf 20750:430c6bf5263401f5 23394:430c6bf526340036 23576:430c6bf526340275 25063:430c6bf5263401a6 25732:7ff0000000000002 27250:430c6bf5263401ef 27814:430c6bf526340041 29279:7ff0000000000002 31856:430c6bf5263402f5 34385:430c6bf526340247 36449:430c6bf5263402b6 39044:430c6bf5263400a8 ; 39608:0 42917:0 44020:0
+stddev_over_time - 3954 -8501 29485 3953 6 ; 18937:7ff0000000000000 20003:7ff0000000000000 23000:7ff0000000000000 23581:7ff0000000000000 24397:7ff0000000000000 27138:7ff0000000000002 29666:7ff0000000000000 30579:7ff0000000000000 30618:7ff0000000000000 32452:7ff0000000000000 33579:7ff0000000000000 35354:7ff0000000000000 37083:7ff0000000000000 40068:7ff0000000000000 42758:7ff0000000000000 43991:7ff0000000000000 45895:7ff0000000000000 47817:7ff0000000000000 49282:7ff0000000000000 51178:7ff0000000000000 54125:7ff0000000000000 ; 29485:fff8000000000000 33438:fff8000000000000 37391:fff8000000000000 41344:fff8000000000000 45297:fff8000000000000 49250:fff8000000000000
+stdvar_over_time - 7381 428 30877 3687 14 ; 15707:7ff0000000000000 36600:7ff0000000000000 37086:7ff0000000000000 39014:7ff0000000000000 40803:7ff0000000000000 41896:7ff0000000000000 42256:7ff0000000000000 43316:7ff0000000000000 45886:7ff0000000000000 48038:7ff0000000000000 50085:7ff0000000000000 50533:7ff0000000000000 52470:7ff0000000000000 55076:7ff0000000000000 56929:7ff0000000000000 57432:7ff0000000000000 ; 38251:fff8000000000000 41938:fff8000000000000 45625:fff8000000000000 49312:fff8000000000000 52999:fff8000000000000 56686:fff8000000000000 60373:fff8000000000000 64060:fff8000000000000
+stdvar_over_time - 1478 0 29500 1478 17 ; 14583:c063f83d103025f7 16368:7ff8000000000001 17774:c062eff308e24760 20366:7ff0000000000002 22239:408b38554933336a 24800:7ff8000000000001 25085:4087136a893aadc7 27543:4067d99f907214ce 28647:7ff8000000000001 29991:c088d92dbdfaf9b2 32283:4072d1579e72e7d4 32583:c06f9082c538fa6a 34625:c0817dbf769de9bb 36526:c07256ec37dbfba0 38655:7ff8000000000001 ; 29500:7ff8000000000001 30978:0 32456:0 33934:0 35412:0 36890:0 39846:7ff8000000000001
+stdvar_over_time - 3121 -2114 31223 3120 2 ; 7437:430c6bf52634025e 9068:430c6bf5263402c9 9889:430c6bf526340225 11302:430c6bf5263401a5 11940:430c6bf526340094 12358:430c6bf5263401fd 14922:430c6bf52634028b 17293:430c6bf526340176 18878:7ff0000000000002 21185:430c6bf52634012b 22264:430c6bf5263400c3 23435:430c6bf5263401aa 25893:430c6bf5263401ff 28615:430c6bf52634017e 31398:430c6bf526340248 33253:430c6bf52634013e 33463:430c6bf5263400cf 35865:430c6bf5263401b7 ; 31223:4071464000000000 34343:406a480000000000
+stdvar_over_time - 688 2260 24303 688 8 ; 19127:c086b9717b28fe05 21071:c080db964097e5dc 22112:406286410df012d1 23399:c080a51b2caec400 23796:40870dcd73780467 24636:c07421c13042d03e 25771:4081f6cd82082fd2 27441:4087b4227fd07d85 29577:4086708c267c73bc 45914:c074cbe7392e8f7d 47342:408f33ed644d05f9 49617:7ff0000000000002 52367:4089ed73b660ea05 55365:c0665383e088008b 56473:c06ff25f1db9989e 57246:c0875c109e4061fe 57315:4089b493202ed1a8 ; 24991:0 25679:0 26367:0 27055:0 28431:0
+stdvar_over_time - 944 0 16764 356 5 ; 20466:414ad7106d0f5696 22094:c026cdf98760ad69 24371:c19789daa65f62c0 26768:c07291a570967478 29286:3fe384b30e7190c2 30261:bfc5e0f505867892 31940:c14fc8ec2a8e7a77 32604:40b327f4a5fd6608 35147:40aadd3551128bbe 37104:c07d9c7b79f20c25 ; 
+stdvar_over_time - 2391 -38 6870 2391 12 ; 4111:40833136c3e4b772 5402:c078dd67205aee58 6413:c04893ce279c0982 6912:7ff8000000000001 9803:403457a3267eac5e 12622:c075817d4b63fa04 26755:c07c7b65170d4a2f 27343:c072aa4e95c4cc7e 29370:c0802f8294ccdae9 31467:7ff8000000000001 32462:4078641011bdba3e 34721:40529465bcfd3575 35053:c0753aa5614df558 35211:c05eaffb11bd81b1 35929:c07e8a5c1292ec26 36335:4085ee2f0b5e42ad 38788:406f5a291f2af001 39043:c07584291d06e7bc 40312:7ff0000000000002 41558:7ff8000000000001 42484:40808cef16e490bd ; 6870:40ddaebcc6f497ef 9261:7ff8000000000001 11652:0 14043:0 28389:40b81796b60aeb59 30780:0 33171:7ff8000000000001
+stdvar_over_time - 1000 0 14881 200 12 ; 15548:430c6bf526340013 18397:430c6bf52634027f 21283:430c6bf5263400c5 21713:430c6bf5263400d5 22982:430c6bf526340311 25480:430c6bf5263402b2 27938:430c6bf526340195 28976:430c6bf526340269 29796:430c6bf526340182 32472:430c6bf526340200 32495:430c6bf5263400fd 33023:430c6bf526340247 36005:430c6bf52634030e 37249:430c6bf52634015e 38025:430c6bf5263402c6 39353:430c6bf526340079 41874:430c6bf526340072 43209:430c6bf526340249 45844:430c6bf5263400a8 47856:430c6bf526340172 ; 15681:0 15881:0 16081:0 16281:0 16481:0
+stdvar_over_time - 1830 8903 36958 1829 5 ; 36655:7ff8000000000001 39473:7ff8000000000001 40658:7ff8000000000001 42976:7ff8000000000001 45776:7ff8000000000001 46701:7ff8000000000001 47144:7ff8000000000001 47974:7ff8000000000001 48752:7ff8000000000001 49958:7ff8000000000001 51153:7ff8000000000001 52515:7ff8000000000001 53677:7ff8000000000001 53889:7ff8000000000001 54708:7ff8000000000001 56774:7ff8000000000001 58863:7ff8000000000001 58928:7ff8000000000001 60044:7ff8000000000001 61521:7ff0000000000002 ; 
+stdvar_over_time - 1677 -7469 19277 835 3 ; 3264:c07fda513cb19f69 4783:0 5415:4079f3985c7a44d8 18538:c068d3df3de69bfb 20527:408b25f74ab8f305 20888:4089b29fb2f82d0c 23612:c0528d9468c8ae50 24249:407792d78dddda2d 26887:c0529a79cd805d81 ; 20112:0 20947:0
+stdvar_over_time - 6047 7364 13033 3020 18 ; 9864:fff0000000000000 12591:fff0000000000000 13474:fff0000000000000 ; 19073:fff8000000000000 22093:fff8000000000000 25113:fff8000000000000
+stdvar_over_time - 938 0 23039 937 6 ; 22082:4065997d691043cd 23895:40880ca6e3dc9751 24006:c07662920b64bc78 35394:c08c30cb6d19675a 36655:c084f2b7a5bf9103 38806:c0745f96b04c2d4c 39147:404e16abfcc0993a 39636:c08ce4825ea5f7f3 40372:7ff8000000000001 40445:7ff8000000000001 40514:404ad3c2fbe3b9a1 41353:c072813568b186d1 41853:407bfe7e305b17db 44406:7ff0000000000002 45155:c080715a5b77533e 47100:c06a2c7b0121bb32 ; 23976:0 24913:0
+stdvar_over_time - 1000 0 16324 440 2 ; 14432:425a087501151e86 15801:c012df0237e426aa 18283:bffe74b23a221adf 19195:40adf069c0417342 21221:403ca86e1e52b4a7 23724:c2b270571012e27b 24684:40e4a9265f7b9006 26999:4010fe3652a87300 29898:c046c845d394adc4 32162:3fb64e3ab1509b68 ; 16324:0 16764:0
+stdvar_over_time - 3686 -4424 30113 3685 14 ; 19718:4059484a129cf859 21224:405a07558122b82a 23065:4010245e916c6b60 24648:403c82f2becd5a71 25882:404abe73cd88daf7 27509:4053153a64fd3672 29025:405d84a2034faea5 39752:405e895cdf46029a 40699:4064564acbd3aa78 41249:4065e2cd71ece58d 41697:406982f72bfdeb45 52080:406f80e57a08689e 54714:4072baf6c0755db1 55007:40750d833672cb14 ; 37483:408b176414397ea9 48538:0 52223:4075934082754ccc
+stdvar_over_time - 4829 -8917 17968 1473 15 ; 20149:4083b7ec1ea3bad6 23092:4061a9f38f2e20b5 25001:c08b5279557c60a0 26946:4072aa7478741390 27951:4074fc493bccf711 28839:fe37e43c8800759c 30189:408e03cd765ac6fd 31608:c086ad7a69d8a6f5 32526:fe37e43c8800759c 34870:408d80ab910366bd 51021:405b76ce7683799e 53217:408df75d95a29374 ; 17968:410f7a78e382f116 19441:4113452b5e3b5063 20914:7ff0000000000000 22387:7ff0000000000000 23860:7ff0000000000000 25333:7ff0000000000000 26806:7ff0000000000000 28279:7ff0000000000000 29752:0
+stdvar_over_time - 15182 -1603 22079 2965 3 ; 15155:430c6bf52634002d 16187:430c6bf526340206 17265:430c6bf52634014a 19167:430c6bf52634004e 20226:430c6bf5263402a9 22267:430c6bf526340094 25187:430c6bf52634014e 25557:430c6bf526340185 45823:430c6bf526340305 48405:430c6bf526340068 49075:430c6bf5263400cf 51782:430c6bf5263400c7 52562:430c6bf526340100 54340:430c6bf526340245 56073:430c6bf5263401af 57430:430c6bf52634030b 57686:430c6bf5263400b5 60312:430c6bf5263401da 62406:430c6bf52634016a 62649:430c6bf52634027a 64441:430c6bf5263400a4 64928:430c6bf526340309 66349:430c6bf5263401f5 67574:7ff0000000000002 68176:430c6bf5263400e5 ; 22079:408aefc555555555 25044:4084a45c00000000 28009:4084a45c00000000
+stdvar_over_time - 1000 0 9839 497 18 ; 10774:41d1c55818c3be49 10909:c26e684533351926 11100:bff1d86067bea6aa 11537:42f1d6ebc44a73a0 ; 10833:0 11330:44c9b67a29f4bb24 11827:45d1bd538ff8fae6 12324:0
+stdvar_over_time - 1000 0 9176 1380 2 ; 13212:408047fd9bff7792 15244:7ff8000000000001 ; 
+stdvar_over_time - 1000 -3542 27202 1387 19 ; 11570:3ff510e9f76ef9c8 13718:400d1cc130cc47b6 15268:401d94fee470194b 16625:40450cd905c7507a 19159:4050e7827ad49c9e 19487:3ffc74aadf0846dc 25043:4012e05203045061 25620:404a41a7686ad0e9 25975:4050955078db7124 28001:4053ed96fd2e40b2 28312:405f59bc45d99268 29424:7ff0000000000002 ; 
+stdvar_over_time - 2377 -3756 2248 2376 15 ; 5118:bfbb63a9fe7fa518 7675:400f3ffc85e4cd71 10228:40d2e7934b0625ee 11551:41f1bb0de06f3d89 13327:c1ebb48373fa71f6 14907:c297c7130397bc17 16147:bff614fb0921017a 18177:404ccec80ebd084b 18950:412c96093e2633cb 18985:422650d30b5d4837 21865:4180cb69e9e72120 22470:c28a5bac382f9373 37427:41f0fd4f4162f1b0 38381:41e61b502d98e213 40031:c1f27c36ac2334a8 42832:41ea91f84b15fa5d 44485:c0403c881997b545 45746:4219ed7d1932e383 47513:40f773b129a9bbbb 48868:40af23dd8772ce7d 48932:bff3f1ce44dfb3d1 ; 2248:0 4624:0 7000:0 9376:0 11752:4521a5dca343b266 14128:0 16504:443baa67cf804640 18880:4505b61a253a5731 35512:43a19e709c475116
+stdvar_over_time - 274 0 13344 1313 4 ; 1542:404d9016e04e4b5a 3033:404fc9acae5132ae 5906:405a3dee77448350 8686:4062f0aa73be16ef 10495:406412de173b9586 11036:3ffef0cc8f665c58 11830:400dd1eca4d055be 13741:403f3f59dbfddc7a 16328:405164f3b44a9f78 16628:40589ee34f5c5a72 19496:4061dd68d8c3b061 21965:4063012fd029b332 24165:4067fed3d1790322 30495:406869df07d6b761 31417:40005e22c963b3ea ; 
+quantile_over_time 0.5 1101 -6411 31032 1100 4 ; 32248:430c6bf5263402db 34711:430c6bf52634029c 37018:430c6bf5263400ec 37387:430c6bf5263402cb ; 31032:430c6bf5263401dc
+quantile_over_time 0 1000 6918 -1155 3349 2 ; 1535:c0279ea9314831f8 2920:40833b37c83ff5be ; 
+quantile_over_time 0 1000 -7959 7879 2738 7 ; 6324:40822e688d364252 7237:408833f80b2a2a88 7891:408e1f7dbba2da5b 10247:408c287fa592bf4d ; 
+quantile_over_time 0.5 6284 0 27130 1024 17 ; 20883:c079b38bfa787eec 23070:c076aa455a77b0e1 23676:407c17941126a68b 25926:c077beb2eb7993f9 26181:4077367ae902da95 26923:8000000000000000 28148:fff0000000000000 29817:4086e440fa58fe73 32768:406b5392729af8d3 55820:4088cfce954a1929 56230:407842345cbb6d94 57704:4087cea5798778f8 57892:7ff0000000000000 ; 27130:c066aa455a77b0e1 28154:c066aa455a77b0e1 29178:c066aa455a77b0e1 30202:0 31226:0 32250:4067367ae902da95 33274:406b5392729af8d3 34298:406b5392729af8d3 35322:407db92596ffbca8 36346:406b5392729af8d3 37370:406b5392729af8d3 38394:406b5392729af8d3
+quantile_over_time 1 2368 -2546 16333 2367 8 ; 9707:7e37e43c8800759c 10913:7e37e43c8800759c 12881:7ff0000000000002 14608:7e37e43c8800759c 16569:7e37e43c8800759c 17282:7e37e43c8800759c 19766:7e37e43c8800759c 20198:7e37e43c8800759c 20207:7e37e43c8800759c 21722:7e37e43c8800759c 22036:7ff0000000000002 ; 16333:7e37e43c8800759c 18700:7e37e43c8800759c 21067:7e37e43c8800759c
+quantile_over_time 0 1376 0 17737 1375 11 ; 20102:c04c5915bc4a225f 22450:7ff8000000000001 23908:c08dd899d78b57aa 24067:40817cf2932262a2 26204:4087d3fc68117ffc 27480:40825bee0abc265b 29114:7ff8000000000001 31092:c080af93ea80535f 31470:4075dd4850555580 32914:4077b5afe418d0ca ; 20487:c04c5915bc4a225f 23237:7ff8000000000001 24612:c08dd899d78b57aa 27362:4087d3fc68117ffc 28737:40825bee0abc265b 30112:7ff8000000000001 31487:c080af93ea80535f
+quantile_over_time 0.5 1803 -4485 1245 1802 4 ; 3789:40858d805319a257 5681:4076804526356bee 7990:c0732c9a9d16d9dc 9333:406883881a2dbde0 11175:408a5702a1ffccb2 11409:407e92f1fc020898 33963:408e25a35998b905 34550:408660b6c1962166 37276:c081b9241779a3f0 37829:c08b256045b413ed 40133:7ff0000000000002 42448:407b1543e47cf5bd 59365:408c95796959e973 61585:40743a76cb6a3027 ; 1245:4076804526356bee 4849:c04bab5a3fffebb0
+quantile_over_time 0.5 7845 1152 39988 3919 9 ; 18046:c0773baa92f97dad 40707:c05f986fba1a3f16 43684:408a387222752c9c 44634:c052d1d381076d57 44740:40858ffd0aad12ce 45891:406c9742e3a3462d 47452:4085d7d9215be273 49729:c08946bdb59737f5 ; 43907:c05f986fba1a3f16 47826:406c9742e3a3462d 51745:407cb5cdc395e459 55664:c04b7724a1daac10
+quantile_over_time 0.5 3342 8188 17283 3341 3 ; 13170:405b30b13d74a5eb 14720:406090f1c04d4074 15791:4060ff85691736e1 16743:4063e3fbb2002fb9 18170:406633011bb709c2 ; 23965:405e294a5f07936a
+quantile_over_time 0.25 19317 0 12184 500 13 ; 10578:406578b132873381 12335:c06de82dbd1eb5d0 ; 12184:406578b132873381 12684:c0610ff601353b7c 13184:c0610ff601353b7c 13684:c0610ff601353b7c 14184:c0610ff601353b7c 14684:c0610ff601353b7c 15184:c0610ff601353b7c 15684:c0610ff601353b7c 16184:c0610ff601353b7c 16684:c0610ff601353b7c 17184:c0610ff601353b7c 17684:c0610ff601353b7c 18184:c0610ff601353b7c
+quantile_over_time 0.25 2303 0 4103 2302 13 ; 3929:c17127107f87927c 3988:c27c6c80841e6e5b 6646:42901e0b3cccea97 6824:c1effc54ce756c75 7982:40c4dfb56c574b27 9390:41839ad8e2b2eee7 ; 4103:c2755164acdaf2a6 8707:c1dffc4f9688115f 11009:41839ad8e2b2eee7
+quantile_over_time 0 1890 -5712 5645 1490 12 ; 6184:4053003bee193d3a 8965:4056ba8bc2e680fe 11604:4058a83f0ccb39c6 12572:405c2155f14766c1 13294:405c4f0757f73c42 13579:4063fffecbcf0846 15675:4068395e91af90ee 18008:40683f50c5bd6a69 19034:401ca8381cd5ad88 19685:400c2c8dabe1cced 21102:404224859d3da1ae 22464:4051e82d595ac58c 23617:405d84a7b03f5e9a 24580:405e35f75fe606e5 26694:4060baffd870d38d 29544:40630ad6dd34684d 31397:4065028f62e53cad 33819:4067d7cc09868bd2 ; 7135:4058a83f0ccb39c6 8625:405c2155f14766c1 10115:4068395e91af90ee 11605:4068395e91af90ee 13095:40683f50c5bd6a69 14585:400c2c8dabe1cced 16075:404224859d3da1ae 17565:4051e82d595ac58c 19055:405d84a7b03f5e9a 20545:405e35f75fe606e5 22035:4060baffd870d38d
+quantile_over_time 0.5 1000 -2821 16434 1571 6 ; 18774:40494ee308cf1418 20865:40509c1ed354d7df 22126:40585b8be38fb280 24425:405bdf1bc955fe6c 24616:401d822be4b85e3a 24884:4019e8ce2ba68024 27802:4033decb85caf7a0 27855:403ecab6b0597466 30537:4053717c035031ee ; 16434:40494ee308cf1418 19576:40585b8be38fb280 22718:401bb57d082f6f2f
+quantile_over_time 0.9 3218 3261 32229 3218 14 ; 3873:fff0000000000000 5241:fff0000000000000 6809:fff0000000000000 7786:fff0000000000000 8123:fff0000000000000 11114:fff0000000000000 12446:fff0000000000000 14818:fff0000000000000 17545:fff0000000000000 19526:fff0000000000000 20560:fff0000000000000 21994:fff0000000000000 24030:fff0000000000000 25248:fff0000000000000 26103:fff0000000000000 28892:fff0000000000000 30569:fff0000000000000 31380:fff0000000000000 32782:fff0000000000000 35311:fff0000000000000 35905:fff0000000000000 36629:fff0000000000000 37652:fff0000000000000 40384:fff0000000000000 41569:fff0000000000000 ; 32229:fff0000000000000 35447:fff0000000000000 38665:fff0000000000000 41883:fff0000000000000 45101:fff0000000000000
+quantile_over_time 0 1000 -4901 18307 2509 17 ; 6841:7ff8000000000001 7800:7ff8000000000001 9982:7ff8000000000001 11623:7ff8000000000001 13670:7ff8000000000001 13795:7ff8000000000001 15221:7ff8000000000001 17024:7ff8000000000001 18792:7ff8000000000001 ; 
+quantile_over_time 0.5 398 6011 -949 398 9 ; 2678:430c6bf5263401d0 5239:430c6bf526340150 7812:430c6bf526340261 8153:430c6bf52634004c 10877:430c6bf52634011e 12193:430c6bf52634016a 13781:7ff0000000000002 35784:430c6bf5263402e0 37081:430c6bf526340051 39640:430c6bf5263400dc 45429:430c6bf5263402f1 ; 
+quantile_over_time 0.5 6293 4391 25601 3143 4 ; 20174:4086501499dfd567 20914:c06593f7ef673356 22650:406d2fb0d1204ab8 24397:7ff8000000000001 25704:c08c17f2bdcb33f5 28569:c08deb15c9c4cc8e 29932:c084f018c52c02f0 ; 25601:4070eb169e060892 28744:406d2fb0d1204ab8 31887:c08c17f2bdcb33f5 35030:c08d018443c80042
+quantile_over_time 1 1000 0 11113 1445 15 ; 9786:40487474f2fb84f7 12064:4052ad6c7f5a9dcb 13009:40545ed85ee106cb 13115:405e2eb863e22c77 ; 12558:4052ad6c7f5a9dcb 14003:405e2eb863e22c77
+quantile_over_time 0.25 1158 7640 12405 1158 4 ; 16403:405b4d6420c65dd4 16778:40625adea16001e0 ; 
+quantile_over_time 0.9 6937 641 18582 3465 11 ; 18352:430c6bf5263400ff 20964:430c6bf5263400ee 21904:430c6bf5263401e2 23314:430c6bf5263400a0 24870:430c6bf52634021b 27655:430c6bf5263400c5 ; 22047:430c6bf5263400fe 25512:430c6bf526340204 28977:430c6bf52634020a 32442:430c6bf5263401f8
+resets - 3768 0 13718 3767 6 ; 14081:c081e14dc492a662 16656:406dd0d2f431afda 17441:4087c45d852ed036 20132:c08abab899a37f3e 23068:407d9681aa160159 25125:c072988a542672e9 26319:c067222419a4dc8f 29227:c07016e3ce63462d 29553:408354dbe25bcf93 30995:408d6aa5344ea842 31642:4073140b6340e48a 33235:c06f149ca1838161 33720:7ff0000000000002 35669:7ff0000000000002 37105:c070317724ece1af 37169:c077f7984dd786d1 40105:c08e63edb0b78dac ; 17485:0 21252:0 25019:0 28786:0 32553:3ff0000000000000
+resets - 66 5354 9160 66 20 ; 2722:404f27020204dd57 4335:405652b6cef06ae3 6948:4058a653f586ca04 9505:3ff15b213ada226f 11469:400f657d58103666 12222:7ff0000000000002 14290:403548436f5deb69 ; 9754:0
+resets - 1100 -283 48461 1100 1 ; 19679:430c6bf5263401f8 19900:430c6bf5263400ae 20606:430c6bf5263401fb 22342:430c6bf5263402d3 33243:430c6bf52634001f 34716:430c6bf526340293 36948:430c6bf526340204 39053:430c6bf526340308 39698:430c6bf5263401dd 39727:430c6bf5263400bb 41963:430c6bf526340064 43493:430c6bf5263400c4 45092:430c6bf5263402d4 46155:430c6bf526340156 46400:430c6bf5263400a4 47864:430c6bf526340215 50375:430c6bf52634007d 53196:430c6bf5263402c5 71860:430c6bf526340173 73165:430c6bf5263402fb 74394:430c6bf5263401b4 ; 48461:0
+resets - 19293 0 17826 2303 2 ; 16015:4059f9d989bbad7c 16404:405ac385337d0eeb 17439:406097ba1ff8e7fe 17907:4063c7d9cba08e22 ; 17826:0 20129:0
+resets - 3871 -481 6658 1932 1 ; 10409:430c6bf526340002 11298:430c6bf526340084 12336:7ff0000000000002 13065:430c6bf526340254 13748:430c6bf526340047 15646:430c6bf5263400d6 16838:430c6bf52634013f ; 
+resets - 1000 -3024 29819 3314 6 ; 7395:4015e954accfe5eb 8848:404b7b5ab56fa579 10855:40576f17c8fe2e76 28027:405ded38ced22e4f 29804:40196e0484580d46 32728:40354585964e28b5 34037:40513ea0ef118c90 35630:4052ca7670c9d117 37878:405e67a44b968ae2 50736:40640c471648fe7f 53399:7ff0000000000002 55831:4066a6d315bedef4 58113:406cac0bcb389c45 59584:406d85ab5e884e73 62215:406ffaef7bf00e97 62539:4073043c5787a3a4 64259:7ff0000000000002 66952:40751588588467b7 69771:4076da11321c4957 71768:40776ae4ceb42e27 72569:407a0bcacccbceac ; 29819:0 33133:0
+resets - 6087 2320 8343 3040 3 ; 6528:404e27fa6d41f32c 6745:40577e0687d1c0fa 9018:405917e5e628ca5f 9807:405b9184da3a3d3f ; 11383:0 14423:0
+resets - 595 -335 72426 595 16 ; 8773:430c6bf5263400ef 9702:430c6bf5263402e8 10817:430c6bf526340108 12028:7ff0000000000002 14608:430c6bf526340303 15052:430c6bf526340112 17525:430c6bf52634006a 38728:430c6bf5263400b7 41702:430c6bf5263400e6 43222:430c6bf526340158 45038:430c6bf526340128 45504:430c6bf526340193 48188:430c6bf5263401cd 67298:430c6bf52634006b 69108:430c6bf52634013a 70979:430c6bf52634011b 93576:430c6bf5263400ca 93709:430c6bf5263401f7 95007:430c6bf526340094 ; 
+resets - 8259 0 12409 3103 19 ; 13036:42fbfcc123f1cae0 13139:c2846b8af48355f7 ; 15512:3ff0000000000000 18615:3ff0000000000000
+resets - 3383 -526 14406 3382 17 ; 14463:414aae5c835d27cf 17294:3fe8f236c2be0a92 18262:420fe80342e5b441 19299:c1645336c6087156 21058:c2be64c888a66df2 21989:3fddf2bff97222a8 23185:c057f8b4b62c6f2c 26105:c1b0e006f38a76d7 28466:42b1f7f5192ed965 30230:428e25283d4f1973 31284:c03afe12e83158e9 34207:c20d5dd9df4832f7 35335:4248a572cbad11b7 37100:42b3d4d55561bdad 37658:41b17ec1afc099f5 ; 14406:0 17788:0 21170:3ff0000000000000 24552:3ff0000000000000 27934:0 31316:4000000000000000 34698:0 38080:3ff0000000000000
+resets - 3939 0 7228 1966 16 ; 5591:4048aa315c212b7e 6864:4050a0570282fc33 9735:4013219e119eb90a 10738:4017898a13a94066 12809:403a623762a70532 14597:404d9785f126bbbf 14949:405047ee73d96148 15319:405645dbeec4c6cf 16990:405a6f17763de587 17544:40630e2503c6580e 19823:406590c28027172b 21853:406739c404c3790f 22991:3ff9f78cad802b21 23599:403c9ba392cbca64 25954:404fb3420e81d674 28144:4058e623a8b8035c 28894:405f7a8990605772 29694:7ff0000000000002 32549:405fbe62b8fb7fe6 32755:406501af53a9b55e 34684:4068c287bb2ac46e 36306:406e8e07628104e0 37043:407103b23c37de8d ; 7228:0 9194:0 11160:0 13126:0 15092:0 17058:0 19024:0 20990:0 22956:0 24922:3ff0000000000000 26888:0 28854:0 30820:0 32786:0 34752:0 36718:0
+resets - 18586 2900 30597 2135 9 ; 16994:fff0000000000000 17305:fff0000000000000 19845:fff0000000000000 21992:fff0000000000000 22835:fff0000000000000 24768:fff0000000000000 25981:fff0000000000000 28633:fff0000000000000 31627:fff0000000000000 ; 30597:0 32732:0 34867:0 37002:0 39137:0 41272:0 43407:0 45542:0 47677:0
+resets - 1000 2060 23625 2282 5 ; 19146:7ff8000000000001 21983:40610d8c832a8559 22155:406679d8a668adc8 23403:40725bf5f14a1d60 26239:c085b210ec5f4f87 27829:fff0000000000000 51881:40886f993ed95d58 ; 25907:0 30471:0
+resets - 198 8281 7971 197 4 ; 8178:430c6bf526340183 10591:430c6bf526340040 11036:430c6bf526340104 13421:430c6bf5263400d9 13653:7ff0000000000002 16632:430c6bf526340024 17130:430c6bf526340109 18181:430c6bf526340158 25149:430c6bf5263401c2 26577:430c6bf52634024b 29089:430c6bf52634015c 31103:7ff0000000000002 31503:430c6bf52634009b 34240:430c6bf52634031b 34876:430c6bf5263401e8 36626:430c6bf52634003f 37498:430c6bf526340257 39302:430c6bf52634010b 41484:430c6bf5263401a3 44108:430c6bf52634012b 45253:430c6bf526340013 46463:430c6bf5263402dd 48356:430c6bf526340015 50812:430c6bf526340004 ; 
+resets - 8129 0 7323 1283 18 ; 823:430c6bf5263401c1 3679:430c6bf52634005e 5995:430c6bf52634016c 15445:430c6bf526340060 17784:430c6bf526340063 18079:430c6bf52634011d 18243:430c6bf5263400a5 19740:430c6bf526340009 20866:430c6bf526340113 22275:430c6bf5263401d2 23632:430c6bf5263401b6 23695:430c6bf526340176 41079:430c6bf52634016e ; 7323:3ff0000000000000 8606:3ff0000000000000 9889:0 11172:0 12455:0 13738:0 16304:0 17587:0 18870:3ff0000000000000 20153:4000000000000000 21436:4000000000000000 22719:4000000000000000 24002:4010000000000000 25285:4010000000000000 26568:4000000000000000 27851:4000000000000000 29134:4000000000000000
+resets - 1261 0 29673 1261 16 ; 14876:8000000000000000 15067:8000000000000000 17617:8000000000000000 17986:8000000000000000 20491:8000000000000000 22015:8000000000000000 24905:8000000000000000 25050:8000000000000000 25848:7ff0000000000002 25921:8000000000000000 25939:8000000000000000 25970:8000000000000000 26358:8000000000000000 28423:8000000000000000 29978:8000000000000000 46550:8000000000000000 46846:8000000000000000 ; 29673:0 30934:0 47327:0
+resets - 1000 0 43272 2270 8 ; 30386:7ff8000000000001 32417:407e25a37fb94fd4 32920:40716f489bed7a79 35132:c0748b3be9fd6a8e 35514:4080abf10cde3bff 38264:406b9f0b9fe5fa9a 39839:407c8c12a3bc9e6f 40898:4086fd02e531b32d 42890:c088ed4ebae10e8e 44048:7ff8000000000001 ; 43272:0
+resets - 1000 0 10234 3380 3 ; 6982:c17c493beac2bca0 8986:c2f457be4b9e92db 9237:c2f1d85c1a986cde 11105:419bcb06393a1764 ; 10234:0
+resets - 14671 4661 19876 121 5 ; 14660:430c6bf5263401a2 15708:430c6bf5263402bc 17278:430c6bf526340204 20062:430c6bf5263401f9 21967:430c6bf5263402af 23979:430c6bf5263400a0 26888:430c6bf5263402c3 28647:430c6bf52634008a 30205:430c6bf5263402fd 32792:430c6bf526340037 33555:430c6bf5263402d7 35376:430c6bf5263401e9 ; 19876:0 19997:0 20118:0 20239:0 20360:0
+resets - 1000 0 20087 1864 19 ; 20706:430c6bf52634003f 22164:430c6bf52634016c 22716:430c6bf526340068 23213:430c6bf5263401f2 23912:430c6bf526340134 25347:430c6bf5263402f8 26958:430c6bf52634024c 28941:430c6bf5263402d7 31786:430c6bf5263401e7 32510:430c6bf526340045 34040:430c6bf526340021 35993:430c6bf52634020c 36397:430c6bf52634021c 36745:430c6bf526340143 38223:430c6bf5263402e1 38765:430c6bf52634009a 41052:430c6bf526340138 41604:430c6bf526340270 43396:430c6bf5263402f7 43834:430c6bf52634027f ; 23815:0 25679:0 27543:0 29407:0 33135:0 34999:0 36863:3ff0000000000000 38727:0 42455:0 44319:3ff0000000000000
+changes - 1982 -1928 25322 1982 6 ; 16336:7ff0000000000000 18087:7ff0000000000000 20957:7ff0000000000000 21526:7ff0000000000000 22307:7ff0000000000000 22512:7ff0000000000000 23640:7ff0000000000000 24955:7ff0000000000000 27476:7ff0000000000000 28401:7ff0000000000000 31344:7ff0000000000000 32515:7ff0000000000000 33484:7ff0000000000000 33618:7ff0000000000000 ; 27304:0 31268:0 33250:0
+changes - 16679 -1346 12384 3946 19 ; 6113:fff0000000000000 8274:fff0000000000000 9137:fff0000000000000 11599:fff0000000000000 12723:fff0000000000000 13573:fff0000000000000 13728:fff0000000000000 ; 12384:0 16330:0 20276:0 24222:0 28168:0
+changes - 15230 -4608 13849 846 8 ; 11778:408d9b954c9c7167 12167:c07a411842f99144 13545:c08b0172b82d0a84 15612:7ff0000000000002 18356:407a012d61f811d6 18743:407f2d0e5cf3a433 20447:407d2d3e9e5f1dbd 22622:c08f29d9a0f11fe4 23832:4076a4ce35cf3bc3 25546:7ff8000000000001 26187:7ff8000000000001 26344:405cb64abac025d9 26739:3fe78cebb6ccee80 29071:4083cf4f5bd60b3d 29203:40820b6682cca2f6 31545:c08c681783a47ea5 ; 13849:4008000000000000 14695:4010000000000000 15541:4010000000000000 16387:4014000000000000 17233:4014000000000000 18079:4018000000000000 18925:4018000000000000 19771:401c000000000000
+changes - 3463 -9448 14791 1728 12 ; 5039:c08221f694017d77 6327:406af3f7e713ffaa 7082:40747dcdff516cd0 8345:40747faed6aac02b 10081:c086c7022c1fa245 11265:408bc8b802689a33 13636:c084a382a41b8150 15332:4056b158e44c42c2 ; 
+changes - 3005 4228 11203 3004 18 ; 2388:4057c836c8f03045 3275:4059a6fa9fbe8426 4202:405cd4e5472d254f 4600:4060e95a95f48090 7171:4066ddcdc6fa15a3 8584:406addabf166a819 9381:40708227270d8f91 11035:407353043c598da5 11571:4075a441f828ce2e 14040:407739d5b742a0c3 16988:4079f55f6776fc88 17049:407a2ef370704490 18250:407b593fe2822400 19000:7ff0000000000002 ; 11203:3ff0000000000000 14207:4000000000000000 17211:3ff0000000000000 20215:0 23219:4000000000000000
+changes - 3011 -5931 14593 339 18 ; 5088:c08079b19f86936c 5496:408ceff523d8fb5b 6776:c05815e930311d83 9403:4075c8f41ed027d3 10540:404cbbf914be7d7d 12474:7ff8000000000001 12950:405d856ead57e2b4 25165:7ff8000000000001 26815:404a01a6c960dbfc ; 19339:0 19678:0 20017:0 20356:0
+changes - 2831 7218 27940 2831 1 ; 2863:c076189ef755213a 5521:c0604c4418490f0a 7242:407ca112e18ca229 7864:408ebee2de4226cf 9662:c0794498148de244 11005:403b035bc8a88cf8 11300:c08d07f0cd55de44 12164:4055de2bd93bea88 14222:fff0000000000000 16464:7e37e43c8800759c 19447:c08f3fab5beaae24 22194:7ff0000000000000 22759:407047678eca0887 25037:7ff0000000000000 25855:408d7ad8a7d552c8 28548:40598e4390d413a4 31396:7e37e43c8800759c 34151:c088cd72d559c6fe 35112:fe37e43c8800759c 36893:c08e13b9cd41af32 ; 27940:0
+changes - 1000 -9817 14212 510 6 ; 5069:0 7815:0 9130:0 9353:0 11996:0 14966:0 17243:0 19917:0 21450:0 23484:0 ; 14212:0
+changes - 17762 -2504 13196 1030 19 ; 15104:7ff8000000000001 15334:408d05f834160c73 16604:408c5c0f2972ec43 17019:7ff8000000000001 ; 13196:3ff0000000000000 14226:4000000000000000 15256:4008000000000000 16286:4008000000000000 17316:4008000000000000 18346:4008000000000000 19376:4008000000000000 20406:4008000000000000 21436:4008000000000000 22466:4008000000000000 23496:4008000000000000 24526:4008000000000000 25556:4008000000000000 26586:4008000000000000 27616:4008000000000000 28646:4008000000000000 29676:4008000000000000 30706:3ff0000000000000 31736:3ff0000000000000
+changes - 2015 0 15668 1004 9 ; 18693:c05e1c62ba360061 19715:fe37e43c8800759c 20627:c054cd0245e71f2c ; 19684:0 20688:4000000000000000 21692:3ff0000000000000
+changes - 12448 9316 16344 2348 1 ; 12939:430c6bf5263401ca 13948:430c6bf5263401f3 15845:430c6bf52634002b 16355:430c6bf526340058 16605:430c6bf52634023a 16836:430c6bf526340082 ; 
+changes - 2375 -3256 71586 1184 11 ; 19190:0 20563:0 21318:0 21709:0 24280:0 44748:0 46438:0 47274:0 48408:0 50394:0 53124:0 70692:0 73688:0 75497:0 76119:0 78726:0 80388:0 80842:0 94073:0 94110:0 94210:0 ; 71586:0 72770:0 73954:0 75138:0 76322:0 77506:0 78690:0 79874:0
+changes - 14792 0 13207 288 1 ; 16969:8000000000000000 19088:8000000000000000 19932:8000000000000000 ; 
+changes - 7282 0 33884 1328 18 ; 4588:40487384bde21b21 6125:c10dd30aa3d57ca2 6222:c20238b414630ec5 8135:410a9cdcac0fbe84 11089:4143e5c1ff9684ae 11615:4225bddce51d870f 11786:42a8c9d8b7e6c2d0 12614:411db3d62ff06778 15511:c2b1d36a42e2d91e 17768:4045f5a54f2b23fe 18659:411b6eb6e00b1a50 20189:4075548faca8676f 27533:4180a31e771b9119 27590:41ebbdbcd9d77526 28901:c1a0fe5a68327231 31330:c2a8913c0192142a 31471:c0b21558f0bd011e 31656:c0dbac2ba7727e6f 32867:7ff0000000000002 34562:c247f02b1906e5c6 36774:4094a634232eac57 37673:c12ffa6afa00cca9 ; 33884:4014000000000000 35212:4010000000000000 36540:4008000000000000 37868:4014000000000000 39196:4000000000000000 40524:4000000000000000 41852:3ff0000000000000 43180:3ff0000000000000 44508:0
+changes - 1000 -1546 10776 1392 15 ; 14493:40857adef37c7e03 15580:40802de611105218 15806:7ff0000000000000 18358:c08766f20912ec3b 18951:402c317175a4c340 20668:fe37e43c8800759c 21867:fff0000000000000 22715:40674f066784267f 24514:40328faa31c78b48 27112:c08ea849e507125c 27235:c08c2fc9ee0c47b2 28327:408c00574b9140b7 30582:407324d63afd5213 32907:c069e69e9595d9ec 35791:c08ebb332ef415a9 38075:c08f3f3d4f35be24 38608:c089f67a1f78b9d0 ; 13560:0 14952:3ff0000000000000 17736:3ff0000000000000 19128:0 20520:0 21912:0 23304:0 26088:3ff0000000000000 27480:0
+changes - 1000 8799 61443 3419 4 ; 12189:430c6bf5263401ca 13709:430c6bf52634003c 15291:430c6bf52634003a 16939:430c6bf526340186 25788:430c6bf52634013a 26364:430c6bf52634023d 50538:430c6bf5263402db 61118:430c6bf526340269 62454:430c6bf526340309 65113:430c6bf5263400d5 66448:430c6bf526340078 66723:430c6bf52634028d 66837:430c6bf5263402af 68494:430c6bf5263401db 69743:430c6bf526340226 69973:430c6bf5263400ed 70223:430c6bf5263402c0 71835:430c6bf526340097 73401:430c6bf526340178 74012:430c6bf526340107 75487:430c6bf52634014a 76874:430c6bf5263402f3 78797:430c6bf52634022f ; 71700:0
+changes - 3213 3262 9616 3213 5 ; 12784:430c6bf526340075 15734:430c6bf5263401f4 16193:430c6bf526340007 19034:430c6bf526340213 20566:430c6bf5263400ab 23461:430c6bf5263401e9 24871:430c6bf52634022a 27115:430c6bf52634029d 28577:430c6bf5263400ff ; 19255:3ff0000000000000 22468:3ff0000000000000
+changes - 1857 0 17806 1856 7 ; 21773:7ff8000000000001 22333:c07a51e4231167d4 24356:4084e0ce9a1f40e6 25967:7ff0000000000002 25978:c08163b53f0f17d8 27909:4040192319d13158 30798:408e4b33240d152d 32633:c07f38232a0e7175 34169:7ff8000000000001 34359:7ff8000000000001 36895:40886b0504c86a1a 39816:c06c0cd42ed5fd53 40092:4087150a7ec51bdb ; 23374:3ff0000000000000 25230:0 27086:0 28942:0
+changes - 1102 2833 27442 1102 7 ; 14529:401aac2b1f135a13 16943:7ff0000000000002 19324:4036a0304f7575d9 21013:4046441ef8e6f334 23466:4055cfd56bd88566 25982:405bba3bb3838c36 27337:405ddd7783786142 28712:4063e497593f9c67 31430:4068018c9f9ed9a8 33216:4069013147430dc6 34155:4069d966b8f05a39 35202:4069e88ba92ee1ff 35324:406df0faf2874fa2 35748:4070323a733ffd7b 36311:40733d9eb4e939ff 36398:407553e5d69f1898 37651:4076a4d5be09a604 40432:40780065a19d4bf7 43426:407965ed34ccc782 45578:407afc8419cf9afb ; 29646:0 30748:0 31850:0
+changes - 1000 8198 7893 3686 17 ; 11284:404bafdd4b09d778 13253:4056e95454bb4442 ; 
+deriv - 1000 -1119 7385 2636 11 ; 10944:4050ed1004a72238 13915:40114bd5b5141019 16320:4045366e8d0aaa2f 16526:40036a77893618e4 16611:401d73b0217a530b 28107:4033eefaf18b3a09 31022:3ff95e72dd164109 ; 
+deriv - 15100 -845 15769 3235 16 ; 17187:c0450766291b9d40 20062:7ff8000000000001 21932:4082815b0ecf8e71 24142:406d02d8d7603416 27084:7ff8000000000001 28587:407f5772308db2d4 30812:c072b62f8f3e30c5 31693:c081339ba44384a4 33566:c08ceec9f888d96d 34545:7ff0000000000002 36459:c06bb694dfaadaee 38038:40421507984f4f70 38564:c084b19fea5843b1 ; 22239:7ff8000000000001 25474:7ff8000000000001 28709:7ff8000000000001 31944:7ff8000000000001 35179:7ff8000000000001 38414:7ff8000000000001 41649:c04464506778607c 44884:403a98b713664d35 48119:c05ecf1242499c97 51354:c094bec74e615fb5
+deriv - 3603 6408 23090 3602 20 ; 17389:430c6bf52634008c 17679:430c6bf52634025b 18955:430c6bf5263401bb 19515:430c6bf5263400dc 20840:430c6bf526340307 23702:430c6bf5263402ea 24038:430c6bf526340105 24398:430c6bf52634007d 25202:430c6bf52634025d 25735:430c6bf526340122 27705:430c6bf526340027 ; 26692:c004b267d515654e 30294:bff3889564768da8 33896:402d5e60add53eb5
+deriv - 2931 -199 3508 2930 7 ; 867:8000000000000000 1732:8000000000000000 3890:8000000000000000 ; 3508:0
+deriv - 1000 4451 24695 2007 14 ; 10855:430c6bf526340234 12900:430c6bf526340140 14087:430c6bf52634004b 14415:430c6bf5263400b0 16927:430c6bf526340006 38013:430c6bf52634019c 40809:430c6bf5263401a8 ; 
+deriv - 1875 0 17471 1740 11 ; 7227:408ebfd36b92ef22 8037:405d9f545d2f1558 9887:c07e7e9c17725ac2 11610:0 11777:c08b79d5194d885b 13918:c0884b476a4d6955 14594:408555d9c95edfd6 15745:c079c4927b1f53a3 18196:c06e9ff9dc93f1fb 20984:407c9e0a5a960ef9 21124:c06383f773893d3c 22388:4084059b607a5e33 39033:c08551dffd668d12 40208:c0856f1f5eded539 ; 22691:407483eaa077ae75
+deriv - 3111 -6496 65471 3111 5 ; 8362:430c6bf5263400e3 10150:430c6bf526340254 10403:430c6bf5263400e6 11743:430c6bf5263401d5 12638:430c6bf526340281 13935:430c6bf5263402b6 16175:430c6bf526340005 24000:430c6bf5263402c6 24270:430c6bf526340063 25583:430c6bf526340133 28312:430c6bf5263400c1 31067:430c6bf52634004d 32392:430c6bf526340183 32922:430c6bf5263401d2 33702:430c6bf526340066 36602:430c6bf5263402ce 60838:430c6bf526340239 63075:430c6bf5263400f1 70020:430c6bf5263400f1 72473:430c6bf52634031c 74750:430c6bf5263400ad ; 68582:c04111c180ec2686
+deriv - 1000 6388 24915 3025 1 ; 16053:405c8e2e4d486100 17974:4013b3f7029205ef 20784:40471f45fd8e6905 23139:4051904a7e963706 24250:405bc7f53514a87c 24755:405d4d51c01e285b 26154:406212c65e9fba92 26992:4062bd09c82a3595 28840:406301483a47226f 30395:40644efa951b7ad2 32529:40648b30c1ce4329 34740:40668bc3bc434868 37390:406bafb7aac47b98 38008:406ddedab76e2fa4 38878:40710904d1da0990 ; 
+deriv - 8773 3384 42577 923 19 ; 19206:430c6bf526340006 21508:430c6bf526340130 24225:430c6bf5263401bf 43558:430c6bf526340315 43861:430c6bf52634014b 45783:430c6bf526340171 47070:430c6bf52634012a 48607:430c6bf5263402d9 49081:430c6bf526340030 49313:430c6bf52634001e 67013:430c6bf5263402ee 69120:430c6bf52634016a 85682:430c6bf526340234 87506:430c6bf5263402cb 89485:430c6bf5263401ba 90070:430c6bf5263400d2 ; 48115:c067a80d18250d5f 49038:c067a80d18250d5f 49961:c02c80454a51b12d 50884:c026494da8553ad2 51807:c026494da8553ad2 52730:c01f858913ea098d 53653:c01f858913ea098d 54576:c01f858913ea098d 55499:c01f858913ea098d 56422:c01d36d5137884de 57345:c01d36d5137884de 58268:c02a32cbf1315190 59191:c02a32cbf1315190
+deriv - 2106 1369 26192 2105 11 ; 20794:c1b24b10d02e6e73 21843:41a31666ea52bf98 23779:416c9e78dad83da4 25753:c18664e4d4bbb23c 28655:c0ad7bffeed94393 29722:4109365fbb100343 ; 
+deriv - 1000 0 20532 2117 12 ; 17273:430c6bf5263402d9 18220:430c6bf52634021b 20044:430c6bf526340149 21666:430c6bf526340124 22454:430c6bf526340104 24743:430c6bf526340312 25859:430c6bf526340255 26121:430c6bf526340198 28046:430c6bf5263402b2 29261:430c6bf52634010b ; 22649:c014ef94dfd44e2e
+deriv - 3073 -2454 9989 1533 3 ; 5952:405859baf0e27e13 6052:405ac97d99aa0f62 7034:402227521e3b1b4e 8704:400c871620db712c 10886:4049f695cfd7147e 12498:405794a8ba0764ff 13672:405ffc7a775d224f 15880:4064316eef021274 18238:40696af9f8b86347 18256:406b8e18bfe75d6b 19789:406c8f81a80a4c3f 22482:406e4142af5bceff 22499:40704d801c6b2bb6 25146:3ff829d9539ed473 ; 11522:403ca394f919a936 13055:403ca394f919a936
+deriv - 3728 0 21929 3727 17 ; 14280:430c6bf526340041 14984:430c6bf526340187 16125:430c6bf5263402ad 22787:430c6bf526340261 25521:430c6bf5263402a9 27284:430c6bf52634010d 29961:430c6bf526340305 32623:430c6bf5263401c1 34456:430c6bf5263402c8 36655:430c6bf5263401a3 ; 25656:4009afbba88d5435 33110:c02e3308f238de26 36837:c030c031eb1c5b9b
+deriv - 1864 8373 17080 1863 11 ; 15052:c070bf8e01a704f0 17341:0 17485:c0881986fbf55ee9 19888:4071f20364fb9fdf ; 26395:c0b4eb7e100c1b47
+deriv - 3479 0 10492 3479 18 ; 2878:40d7abb91f1ad690 5279:c1ac35002ff4be7c 7493:c2172b183a7cda6e 9865:bfb8b463756a9aac 23009:4149040782f5ee13 25747:4185d1f7ee182286 26697:c25086e260b37a2d 29398:422c9a1354eaaa08 32313:42fc3f3fbe1a0a1e 32662:bfc1e4b125e1ecac 33901:c140de02a353d15c 36856:41e00c315061fb57 37920:42e637b84049f552 39681:c25592b7b558210d 41090:41757dc87303de85 ; 10492:420388ec47c32c4c 27887:c2516647b9bc559c 34845:c2ea300504d442c7 38324:42e4e18ad67f1a0d 41803:424e9fada9c880b7
+deriv - 8627 0 26125 1117 10 ; 15792:4070b2178285a034 18097:c08417cc7da996ac 19167:c08a8d524c0c32d9 22035:407aeb08a947f8bc 24326:c08d46b7130a49c4 27295:408c1f420ca1d384 29177:bfec089276057170 31010:404ce5201d598f24 32122:3fffe563b066e658 32124:7ff0000000000002 32691:c08ac416c6576305 35490:406af29dda0ea794 36479:7e37e43c8800759c ; 26125:4037b6f8cab75223 27242:4001d2d3d780e38e 28359:405caf90b992f9f5 29476:4042fe304ab12856 30593:4042fe304ab12856 31710:405e81f35f9642b0 32827:400a9da515b32fb4 33944:c06df560ebaa6a2b 35061:c06df560ebaa6a2b 36178:401e3c40b7e830c4
+deriv - 1000 5784 16441 319 18 ; 13906:430c6bf526340292 15057:430c6bf52634009c 16339:430c6bf5263400ff 18017:430c6bf526340312 18608:430c6bf52634029e 18675:430c6bf52634031f 18738:430c6bf5263401a4 19770:430c6bf526340310 22266:430c6bf52634003a 25005:430c6bf5263400ad 26817:430c6bf526340003 29330:430c6bf526340038 30909:430c6bf526340176 31969:430c6bf52634028a 32421:430c6bf526340183 34394:430c6bf52634012b 36589:430c6bf526340039 38236:430c6bf526340311 40240:430c6bf5263400f3 ; 
+deriv - 1000 1257 20503 758 15 ; 12894:0 15821:0 17087:0 18553:0 19045:0 21486:0 24174:0 26065:0 26245:0 29205:7ff0000000000002 29614:0 31459:0 31689:0 33677:0 ; 20503:0 28083:0
+deriv - 2586 0 8278 2586 8 ; 4477:40478e00e1e82e43 4488:4055157f04a436ab 6434:405acaff9f953749 7348:40639a7de916beea 10257:40666f916a936082 11889:406962b1aecc9316 12489:4010c771afdee311 14385:40480923f15bcc29 17344:4048e33b2dd3374e 18106:405415fdf61fb229 20088:4054b067b907d2aa 22341:4056de663146fa12 22833:400a6377f0a87773 23806:4046d9ea4eb20909 26199:405476280c754b68 26474:40591e1e579498a7 36068:405c27d7307aaedc 36877:40619eb16397e68c ; 8278:404b2a0400ea9db5 13450:c074b7b7c66b5753 18622:40440ed8a944b967 23794:c066670d373fa8a7 26380:402e3537c931ec05
+deriv - 13185 -3081 16946 3742 19 ; 11970:c081170727f30d60 12322:c0810d031964c076 14317:7ff8000000000001 17214:c0897bd701777239 19365:7ff8000000000001 22114:7ff0000000000002 ; 16946:7ff8000000000001 20688:7ff8000000000001 24430:7ff8000000000001
+predict_linear 3600 1000 -6703 28218 3686 2 ; 2852:40800c698ddc2543 5370:4087af037e5f6993 7582:c046573494ef6e78 10071:c080c3961cb33778 12457:c06bc8447303dd87 13588:fff0000000000000 15982:7e37e43c8800759c 17867:40387d65596bd67d 18379:c05178978836ddb7 20282:4080fa27397e3612 21949:4065a8b113ad6a23 22491:40895de7c3cf0386 23894:c080d0364eaf5dd1 26602:c07c8f3500716c97 27006:408b4ef2bee9f525 27187:7ff0000000000000 29397:c076f4e25d3105e3 31087:40883b6de0bd795b 32226:405b11bc07c1bb55 33178:7e37e43c8800759c 35050:c08234cd3a6a6962 37203:4023176a81d1c7e6 ; 
+predict_linear 0.5 1000 1917 3914 2763 18 ; 5531:c08726671497ca4a 6453:c0b2c6341e0ad226 7571:41a5ea12f346733a 9286:4285699fe6f70e7d 10192:41fe46221624e2fd 11913:c1f14219a1cd78ef 12277:c1b62298a8293097 13694:bfca455afd99e9a0 16367:bfccc7b4f153e178 17679:42f5d0d19f840100 18816:4062b6d8072a0e8b 21798:42c44d537c340c41 22310:c21b6bb42eaa888f 24169:41a142b0ec9e03c5 26063:42e92e692df6b731 27404:c1b788c31daaed4a 27822:c206ac66ea0b592c 30554:4022cb6ccc764dac 33176:4185efc52b44e057 ; 
+predict_linear -600 1219 0 31573 1219 8 ; 16019:403a44901286ed7a 18337:404389dd2186cab6 19689:4047eb6e88ead11d 22466:404a39d19811362b 25142:4053d42ae7bd173b 26569:405afa607e9b7ba9 28370:401af5156b9eee8d 28519:401e233282710a18 28766:4048ad3e3bef3755 30716:404e047610d92b1b 32406:405941421430d2d4 34299:4060ab76cf523121 35360:4062f7ed77049d25 ; 
+predict_linear 0.5 2342 -621 36760 2341 7 ; 17430:4032168a83d80882 17696:404bac77a0d22453 19118:4052b61e44000d1e 36888:4056c80743bbaa8b 38580:4060847870a3fedc 40396:406625f0b565fd2b 43357:4007073f61b3abb9 45544:404541e777ec4950 47766:404c1c11a9aa6b9c 49893:40524d1bb69e0053 50422:401fae62e5cba325 52794:4035b5b09bb473d3 53529:4045b70970e87906 54231:4045bd986bcc3d15 56353:404a01c3475c03eb 58227:404bac68855ca297 ; 50806:c0594b364ccd157e
+predict_linear 3600 3997 2843 12685 3996 9 ; 9237:c07b6ebbc178d6d4 11476:c0802cba60224e38 11934:406880cb6d48736c 14490:4084f93ea2c03fb6 16130:40812e5e8f64e93d 19103:406896aaf91a5d7d 20053:c08096d6a78db6eb 20819:3feda53bb08e14e0 ; 16681:41556d27f5514483 20677:c1103f258ea22fc4 24673:c11ec2f7f428b623
+predict_linear 0.5 2747 -2396 31148 2746 15 ; 17336:40774dd33cee7148 29445:7ff8000000000001 30147:408b2d12e88b5c51 31842:7ff8000000000001 34834:7ff8000000000001 ; 
+predict_linear 0 2516 1006 22137 2516 10 ; 20259:430c6bf5263401e9 22068:430c6bf526340076 23243:430c6bf526340286 24580:430c6bf52634029b 25267:430c6bf5263401a8 27955:430c6bf5263401dc 28035:430c6bf52634006d 30373:430c6bf52634016b 30931:430c6bf5263401e6 33443:430c6bf526340019 35778:430c6bf526340317 37485:430c6bf526340171 40383:430c6bf526340087 ; 24653:430c6bf526340505 27169:430c6bf52633fedd 29685:430c6bf52633e022 32201:430c6bf5263402e6
+predict_linear 3600 2977 0 16785 1485 18 ; 7329:c07b9bc4154c3550 8209:c08ba2b644461558 9913:408849fcdca70328 10548:c086836d4d598549 12027:407b7fafa4dce5f1 12530:7ff8000000000001 14218:408352d6eac49af9 16304:4087b07afe909a02 16522:c0672cbc686bfbd0 16848:40868c3ed8ece002 18545:408036720d978801 18940:c05f91a702c794bd 19836:40511a459822b2ca ; 16785:c123fb5d5547e718 18270:41212615cf4413b8 19755:c13195914198ecb8 21240:c12bb49c090e06bf
+predict_linear 3600 1000 5716 4927 2043 8 ; 5246:7ff8000000000001 7069:40637bdcebc1c212 ; 
+predict_linear 0 2562 0 27450 2562 12 ; 8020:404cd10696ec3bd6 10399:40580085fff5a74e 12886:4061c9eab1ce0d1c 15147:4061fab66b71a0ad 15755:40630cc4f66a07f4 16043:4068832039f65a76 17056:4069b733b7a298af 38429:4004a428edc78848 39946:4006aa2f664e677a ; 40260:40071568ef234689
+predict_linear 0.5 3767 -2987 19896 3767 11 ; 13088:404b87980cd87839 13603:405958541553732e 14150:406177626a0f48c8 16087:4066a3209580a0b9 18640:406c06033dbbdd4a 19870:406da7fa0de70178 22853:40700f5a59bac33e 23454:407307a25729a1f0 23696:4075499e0175b1be 24327:4075dc372383c23b 24432:407740b61970e91a 25621:4077ab41e1a94328 25789:4078c9e6d72f96d1 28186:4079cd878d44ad95 31081:407bcc425693829f 33092:7ff0000000000002 ; 19896:406e1731e14a5ede 23663:407590ab3a34169b
+predict_linear 0 197 0 31501 196 16 ; 20829:408f04cc161a255c 23570:408bde0af7afed8c 24969:c08021a3eb05fd9b 25407:408d17819acd315c 26438:408d42a1675221dc 27237:c0875bec7ae7e63c 28537:c06477a1b4b6151d 34982:407f155523051846 37164:c08d6c30080497f6 40121:c0508f93aa6de164 42422:c07c64557dcfc978 44639:c081cda2ab93b0fd 46878:4086c35ae7eb5865 49469:408c65eeef457e20 51566:c075d79da79c0e51 52097:406c50ff3d4e7b06 53200:4088e8d361046e27 ; 
+predict_linear 0.5 1000 9750 64366 1545 17 ; 18631:430c6bf52634019b 20366:430c6bf526340178 22837:430c6bf526340114 24885:430c6bf52634006e 49032:430c6bf52634006a 49098:430c6bf52634031c 51386:430c6bf5263400c8 54037:430c6bf5263401fb 54845:430c6bf52634004b 55484:430c6bf526340049 56950:430c6bf526340256 59899:430c6bf52634019d 60213:430c6bf52634021f 62153:430c6bf526340246 62763:7ff0000000000002 63533:430c6bf526340310 63669:430c6bf526340238 65044:430c6bf5263402f9 ; 70546:430c6bf5263401de 73636:430c6bf5263402a4
+predict_linear 3600 1000 7661 13641 434 4 ; 12208:7ff8000000000001 12804:7ff8000000000001 14711:c07c25983fc90c20 ; 
+predict_linear 0 1273 2325 15618 633 3 ; 8082:c0829c3551bfb38d 9889:c089763ddb849b91 10320:c08556ede3f3b32b 11588:7ff8000000000001 14140:c0675f124f1366df 15826:c081a6dbcd6278b8 17977:405a568e141f9418 18926:406f395c1ac4986c 20053:c08288701d885a6d 21016:c067394889aec9ad 23367:408e67d3287bba9e 26052:7ff8000000000001 26261:c06039b220a368f2 27445:40817e0ef855e3bc 29770:4080fa0e99fd7c1e 30821:c0843444bbe1d213 31199:4067909969698b85 32253:c080d5ee07817427 33689:c03bfea12d91531c 34041:4079e630944d72de 36566:406b74f9f383acee 38864:c081e47d1fe66231 38892:c0657f69ba36ecc9 ; 
+predict_linear 3600 225 9413 4201 109 12 ; 7599:c08ce13b1150a667 9917:c081f9218edaf1d8 11279:40731f279996b375 13241:40713d7a7e4d36e1 ; 
+predict_linear -600 1000 0 19755 3804 17 ; 788:7ff8000000000001 2520:c08eca62440b41d5 5342:c070eef622855dda 6730:405c5b12d2f76c16 7603:c06ce74a0d92f3e3 8033:c06a73463484c9ff 10660:c0725064ecf49f30 10741:4070cddbf1364368 13215:7ff8000000000001 15499:4062b47d1cbb04c8 16397:4069d47f5dcdcafe 18084:405521836de4cc24 20771:403680187f479dce 22726:c06564bc4c6f1470 23971:4074aaaa7af82d1c 24261:4084103acc935e15 ; 
+predict_linear 3600 2169 0 24745 1081 8 ; 8986:c08941172c8c200b 9310:c08e1d09c1bcdaa6 12121:407f463e43337af1 35168:40764e75fb77247e 36698:7ff0000000000002 36923:c084fdd4dd06cd26 57616:7ff8000000000001 57625:c0887ed4e1d70d16 59635:4083b73aa6eb836e 62129:c083d48e0f6255f6 64196:c06cfa06b8201dcc 65163:c084450db21c127f 66421:408a40d04bb8f679 67404:fe37e43c8800759c 67953:c05a0f32809e7ee0 70514:c069df2c5e4eb04b ; 
+predict_linear -600 1420 0 7247 1420 16 ; 3025:c08608b99f0355cd 4403:7ff8000000000001 4611:c06bdfcf8a43d63a 6812:7ff8000000000001 8141:407c7b8fb3019e4f 8314:7ff8000000000001 8668:c089328adf07f3b2 10164:408e592c83ecae30 11982:7ff8000000000001 13436:4085d480f4f9b0dd ; 8667:7ff8000000000001
+predict_linear 0 1000 0 31877 2220 3 ; 25414:430c6bf5263401ee 27070:430c6bf5263400b1 27851:430c6bf526340256 30538:430c6bf526340209 32983:430c6bf52634023a 35762:430c6bf526340222 36708:430c6bf52634030b 37444:430c6bf526340016 37741:430c6bf52634005a 38166:430c6bf526340053 ; 
+double_exponential_smoothing 0.5,0.9 1000 0 5244 326 20 ; 4858:c0889f797a13cf27 6674:c0527f6a5a5f1da8 8557:4087e2854caa185d 9264:c0813bb6e11e2ede 10960:40811fd9d69095c7 11577:7ff8000000000001 12900:7ff8000000000001 13907:c03efa89546ec0e7 16772:40389eb6201909a0 18087:c0312034c733fad2 19870:7ff8000000000001 20887:c0898797937acc18 21760:7ff8000000000001 22662:c08aa4648f5e26b7 25111:c0655ead5913ee44 26203:408631a2e5959cc3 26878:c08020ad7c4dbdb0 29681:4070048792241c8b 30082:c08d8cd4d95ab61b 30931:c074e604278f70e4 ; 9482:c0813bb6e11e2ede
+double_exponential_smoothing 0.5,0.1 1447 3174 37257 1447 18 ; 16021:40688ccb5eee45a4 18183:40841eed453bf0c1 19902:4089511d3d8d80a5 20598:7ff8000000000001 22638:c08452c3a45261f4 23313:c058b6952d26be72 26221:c0847024b0ffed95 27209:7ff8000000000001 27375:4084c9d7f8053e1d 28583:c085d977751544a4 30243:4089ce3011cf8966 31892:c08a7a123403c942 34512:406a3dd8ccf1784f 36525:408eef4327e487b8 39367:7ff0000000000002 41409:c0899c87aab7bc52 42587:405936831778bc62 43184:c041ac19d81dfe31 45528:407ed0c8edc82d88 46528:408c63b40b5804ed 57191:c083e68c3d72738a 57580:c05d4b24acbd4cef 59994:7ff8000000000001 60923:408c1fec3d361f64 68282:c08251a26e484479 ; 45939:405936831778bc61
+double_exponential_smoothing 0.1,0.1 3500 3409 56909 3500 17 ; 20810:40884a8a92da5de4 22249:7ff8000000000001 23055:404ef99e34200ecc 25691:4073eee469c7ce03 26092:c08998d6c41af527 28068:c06e06ca2402e6b7 30805:4074c737fd585c0b 30842:c08cd202a245c64f 30869:7ff8000000000001 31132:7ff8000000000001 33553:408793dcebad2adc 34210:c06605a3a9233b25 36068:40430c7b25e51b0c 50122:7ff8000000000001 53014:408a0b3803da3230 53349:7ff8000000000001 55542:c08eff4830b83a2c 57976:c085485211c6ef9e 59598:407ebb04e2ee8a0b 59747:4051c218f5a5f27a 61720:7ff8000000000001 63916:c08796f226e5fb55 65012:40637df204c59834 ; 56909:7ff8000000000001 63909:40978450e2dab378 67409:7ff8000000000001
+double_exponential_smoothing 0.5,0.9 18427 -5667 17149 1518 3 ; 21453:42c1db75510b7c70 22466:c0883115e61786c6 ; 17149:c0883112f30bc363 18667:c0883112f30bc363 20185:c0883112f30bc363
+double_exponential_smoothing 0.5,0.9 3495 -4421 15256 3494 8 ; 6210:406597e3c4810b63 6808:4089a42fd5617c3f 8437:408af1b14c976a9b 10565:4077a4838ff71334 13442:c075cb5e35f0ed18 14409:7ff8000000000001 16141:c07cf6f616329ccb 16504:c065a7139c12bcad 18062:40740a9dbe66ae25 18327:408f0719f1fb57bf 18575:c0876cf2aa6214a5 18938:7ff8000000000001 19670:c08773d7d7532ab8 20549:c084ef84dd957f54 21194:4061ef64d08dc61e ; 15256:7ff8000000000001 18750:4061ef64d08dc61f
+double_exponential_smoothing 0.5,0.9 2069 7573 52886 2069 9 ; 38186:430c6bf52634001b 40788:430c6bf526340189 41994:430c6bf526340251 44015:430c6bf52634007e 46412:430c6bf526340062 49070:430c6bf5263402e7 50238:430c6bf5263402ed 52083:430c6bf526340036 53284:430c6bf526340221 53757:430c6bf5263402c6 56330:430c6bf5263401df ; 61162:430c6bf526340221
+double_exponential_smoothing 0.9,0.5 3408 0 19379 3407 18 ; 15481:405264deb1e3af60 18099:405a4b0619af5cbf 19814:40629904ddf1f527 22285:4065de3e21e46fd3 23001:3fee1efe51cd9fab 25466:4012d8f2e777ee87 28012:7ff0000000000002 29980:4035519e683ccecd 32631:4045f8485fd54c38 33560:40550613d69de3c2 33673:4059ae8c146e5431 33764:3ffb542fd9be2e17 36735:4024124fbb9f691b 38211:4034881711472a82 39389:404964aa5b240bff 42078:405054d4535cda10 ; 22786:4065de3e21e46fd3 26193:4012d8f2e777ee87 33007:4045f8485fd54c38 36414:402b58af3d7e0279 39821:404867c008a9f938
+double_exponential_smoothing 0.5,0.1 19802 -4750 23332 970 11 ; 3642:4047027b2e3e3458 6338:4051f3d144a68508 6930:4053e2f585e2ceaf 9665:405b8462345e1486 10653:40636ad4a962b878 12065:4064c8ecbaecd915 13758:40672877c09f4d3c 15945:4069e6f3cbf6a553 17596:406f87d9bff56732 18783:4070df3e69d08c88 18910:4072d47bfdc94671 19109:4074e16384e5141c 20748:40756cdb79a98839 23151:4076b58cf6eeb892 24919:4079082666b23a16 25588:407a1a499e443f7c 27730:407be4f21fb3db62 28199:407dbd5b1d97f260 ; 23332:407c46afd73b39f5 24302:407df460bd53ecd0 25272:407d457043c3774e 26242:407d73aed02683d1 27212:407d86e6a3ae9cd0 28182:407d86e6a3ae9cd0 29152:407e2f1687f6755d 30122:407e2f1687f6755d 31092:407d4f8cf7a266a1 32062:407d4f8cf7a266a1 33032:407dcc2ee09d58fd
+double_exponential_smoothing 0.1,0.1 1000 592 -961 1449 13 ; 2962:430c6bf526340131 5256:430c6bf526340276 7143:430c6bf52634015f 9325:430c6bf52634010a 10165:430c6bf526340294 10222:430c6bf526340040 12096:430c6bf526340306 14463:430c6bf52634031d 16631:430c6bf52634013f ; 
+double_exponential_smoothing 0.9,0.1 1414 7876 44043 1313 16 ; 12622:7ff8000000000001 13996:7ff8000000000001 16508:7ff8000000000001 19213:7ff8000000000001 21160:7ff8000000000001 22353:7ff8000000000001 25024:7ff8000000000001 26750:7ff8000000000001 28052:7ff8000000000001 28131:7ff8000000000001 30362:7ff8000000000001 30744:7ff8000000000001 33672:7ff8000000000001 34390:7ff8000000000001 36015:7ff8000000000001 36895:7ff8000000000001 39876:7ff8000000000001 40607:7ff8000000000001 43460:7ff8000000000001 45306:7ff8000000000001 ; 
+double_exponential_smoothing 0.9,0.5 1291 7740 27490 1291 11 ; 13151:430c6bf52634002d 14527:430c6bf5263402dd 16793:430c6bf5263401ab 16919:430c6bf526340266 19208:430c6bf5263401a6 21518:430c6bf5263401e4 22497:430c6bf526340141 24963:430c6bf5263402f1 27708:430c6bf526340054 ; 
+double_exponential_smoothing 0.1,0.5 666 4856 3892 666 20 ; 181:406202a0ce296acc 1378:400e435a635a0855 2044:40241f24765632f9 4380:404d6507573b393b 5003:4053a012af46289a ; 9886:4053a012af46289b
+double_exponential_smoothing 0.1,0.5 5743 1485 21933 2868 14 ; 15586:4047fec450210765 16620:4054abc208fcc234 18727:405a356508f0e861 18983:401956ff2ebf0cca 19635:4038fb9e0dd3f140 20441:4041607e614b058b 23038:405199b3cd26e61a 24313:402308571d132e86 25460:40333c2587c9daee 26093:40347ca991099a95 ; 21933:40636f6e615cf3ee 24801:c06981f32b4fadfa 27669:c0565cb6ec37ba37 30537:403c1b6082a3ab00
+double_exponential_smoothing 0.5,0.9 3709 8081 25664 3709 2 ; 1734:42fc320d83b4314d 13184:42f3b2647c13f3c6 13798:41512851067d8ddd 15569:c0f10aee3ff7a943 15942:c1e134166828e9b9 16083:c2f9440c50149ad1 18668:c1edbaac5d3602a1 21227:bfdd617a6ab6476e 24155:41263d463e5e9777 24532:c07cd112c979dc43 24833:3fdc5e2432165b12 25918:4061102645d6df5a 27526:42ba58f25053abac 30034:4278f040a6ad8ec3 32350:40481a52867b8e91 33923:c21bef1cb99c3a72 34651:417be59e91782811 37204:40a7d6c6e8de255c 38434:c1852ab69f3ad423 39840:3ff41faca112d163 39977:c2a61706b42c5e7f 40301:42fc53611768434a ; 25664:c2e9441d8419f80c 29373:bfdd617a355b23b7
+double_exponential_smoothing 0.1,0.9 3728 -2342 7029 3728 17 ; 4864:430c6bf5263402be 7081:430c6bf526340250 9986:430c6bf5263400b8 12892:430c6bf5263402a1 ; 10757:430c6bf5263402a1
+double_exponential_smoothing 0.9,0.5 1000 2577 11922 2413 6 ; 5632:4042ee8244660225 7205:40437ffcd7f2c294 8249:4050c603bbd54edc 9650:4053ae48fd88035e 12376:40568f4b8dce88ff 14418:405722b7f01b5756 24246:405e51ae86f4082f ; 
+double_exponential_smoothing 0.9,0.1 291 0 18303 290 9 ; 15550:8000000000000000 18446:8000000000000000 20704:8000000000000000 ; 
+double_exponential_smoothing 0.1,0.9 6093 0 28580 3043 15 ; 3915:40056410d4c35630 5911:402d8b3a7e2d364a 19215:403f9658c0c9245c 19783:40524f4c19453e6c 21002:40549aa2de60f7f5 21713:405c851e5f8a8078 23808:4061d14ca9413b72 26271:4064ac0f942cf2a6 26292:4066397fa53e223a 27823:4066bc99f0103fd1 30695:4067c3965e037752 33072:40684dfa272e599c 35370:406ba51ccd5119b4 36466:406bca97d00a3b39 39323:7ff0000000000002 41292:4070b6ad96eb0b5c 43619:407336cb70f4ebd2 46487:407479271e92eab8 48084:40774c8d4c3d1b7c 48562:40788ff8fa321e99 50219:40793786d4d38de0 64916:4079f2bbf13e213c 67112:407afe4cdec64327 ; 28580:4069cb497db05357 31623:4068fec08de26eb5 34666:40684dfa272e599d 37709:406eaa7b7cb616bf 40752:406bca97d00a3b39 43795:407336cb70f4ebd2 46838:40759722acf40286 49881:4079f7f406bb947c 52924:4079c3ce796b92ed 68139:407afe4cdec64327
+double_exponential_smoothing 0.9,0.9 1000 -7453 20248 1064 5 ; 9885:4054d5eeec35e5c2 10225:405b5dd3a94e06bb 12704:405f7b0dcd9c8edd 14244:40629fe8db229bce 15847:40114c8ec6c3f0ca 17077:4044b6c6b15d63b5 19465:4054ce363497c0e2 20473:4000181a57d512ed 22967:400924ffcc6d8146 25151:4044b67efc240ffa 26051:4053bbe30d8a3b08 ; 
+double_exponential_smoothing 0.5,0.5 1000 0 27283 1018 19 ; 20582:7ff8000000000001 20873:407547fa586f1675 23702:4043bee0192fec60 24952:c06ec574011cf258 26820:7ff8000000000001 28623:c07630a8a835b71b 30280:7ff8000000000001 33193:40642fdda0c265e9 34128:4062affb7121319f 36399:7ff0000000000002 36761:c07779dcd86a9c58 39537:c07806db63287556 62939:408069c73e8e8a6e 63740:408633817412aecd 65725:c0875c92df5e0b75 ; 

src/promql/src/select.rs

@@ -0,0 +1,453 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Operators that depend on the whole set of evaluated series at each grid point: `topk`,
+//! `bottomk`, `scalar`, `absent` and the instant-result sorts.
+//!
+//! Semantics follow Prometheus (`aggregationK`, `funcScalar`, `funcAbsent`,
+//! `createLabelsForAbsentFunction`, `funcSort*`). A scalar is a grid series without labels that
+//! has a value at every point, so `vector(s)` is `s` itself and has no kernel.
+
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::samples::{SampleRef, Series, SeriesSchema};
+use datatypes::series::time::TimeAxis;
+use datatypes::series::{Label, MetricName};
+
+use crate::go_sort;
+use crate::grid_series::{GridSeriesBuilder, external};
+
+#[cfg(test)]
+mod tests;
+
+/// The labels that form an aggregation group.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Grouping {
+    /// `by(...)`: only these labels, `__name__` included when listed.
+    By(Vec<Arc<str>>),
+    /// `without(...)`: every label except these and `__name__`.
+    Without(Vec<Arc<str>>),
+}
+
+/// The order `sort_instant` arranges an instant result in.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum SortOrder {
+    /// `sort`: ascending values, NaN last.
+    Asc,
+    /// `sort_desc`: descending values, NaN last.
+    Desc,
+    /// `sort_by_label`: natural order of the listed label values, then the label sets.
+    ByLabel(Vec<Arc<str>>),
+    /// `sort_by_label_desc`.
+    ByLabelDesc(Vec<Arc<str>>),
+}
+
+/// `topk(k, ...)` (`top`) or `bottomk(k, ...)` with a constant `k`.
+///
+/// At every point each group keeps the `k` largest (or smallest) values, NaN ranking last for
+/// both; the selected samples keep their series' labels and values. Prometheus breaks ties by
+/// the order its storage returns series in, which is not a property of the series; here ties
+/// go to the series whose label set sorts first.
+pub fn topk(
+    k: f64,
+    top: bool,
+    grouping: &Grouping,
+    schema: &SeriesSchema,
+    series: &[Series],
+) -> Result<Vec<Series>> {
+    single_field(schema, "topk/bottomk")?;
+    let points = grid_points(schema, series)?;
+    // Prometheus returns nothing for k below 1, rejects NaN and values out of int64, then
+    // truncates k and caps it at the number of input series.
+    if k < 1.0 {
+        return Ok(Vec::new());
+    }
+    if k.is_nan() {
+        return Err(DataFusionError::Execution("Parameter value is NaN".into()));
+    }
+    // Prometheus' `maxInt64`, the largest float64 below 2^63.
+    if k >= 9_223_372_036_854_774_784.0 {
+        return Err(DataFusionError::Execution(format!(
+            "Scalar value {k} overflows int64"
+        )));
+    }
+    let k = k.trunc().min(series.len() as f64) as usize;
+
+    let mut order: Vec<usize> = (0..series.len()).collect();
+    order.sort_by(|&a, &b| compare_labels(&series[a].metric, &series[b].metric));
+    let mut groups: HashMap<GroupKey, Vec<usize>> = HashMap::new();
+    for index in order {
+        groups
+            .entry(group_key(&series[index].metric, grouping))
+            .or_default()
+            .push(index);
+    }
+
+    let mut selected: Vec<Vec<usize>> = vec![Vec::new(); series.len()];
+    let mut candidates: Vec<(usize, f64)> = Vec::new();
+    for members in groups.values() {
+        for point in 0..points {
+            candidates.clear();
+            for &member in members {
+                if let Some(value) = value_at(&series[member], point)? {
+                    candidates.push((member, value));
+                }
+            }
+            // Members are in label order, so a stable sort hands ties to the earlier label set.
+            candidates.sort_by(|a, b| rank(a.1, b.1, top));
+            for &(member, _) in candidates.iter().take(k) {
+                selected[member].push(point);
+            }
+        }
+    }
+
+    let output = Arc::new(schema.clone());
+    let mut builder = GridSeriesBuilder::try_new(output)?;
+    let mut result = Vec::new();
+    for (index, points) in selected.into_iter().enumerate() {
+        if points.is_empty() {
+            continue;
+        }
+        let mut sorted = points;
+        sorted.sort_unstable();
+        for point in sorted {
+            builder.push(point, &[value_at(&series[index], point)?])?;
+        }
+        if let Some(built) = builder.finish(series[index].metric.clone())? {
+            result.push(built);
+        }
+    }
+    Ok(result)
+}
+
+/// `scalar(v)`: the value of the only series present at each point, NaN otherwise.
+pub fn scalar(schema: &SeriesSchema, series: &[Series]) -> Result<Series> {
+    single_field(schema, "scalar")?;
+    let points = grid_points(schema, series)?;
+    let mut values: Vec<Option<f64>> = vec![None; points];
+    let mut counts = vec![0u8; points];
+    for item in series {
+        let TimeAxis::Grid(range) = &item.time else {
+            unreachable!("checked by grid_points");
+        };
+        for point in range.start()..range.start() + range.len() {
+            if let Some(value) = value_at(item, point)? {
+                counts[point] = counts[point].saturating_add(1);
+                values[point] = Some(value);
+            }
+        }
+    }
+    let mut builder = GridSeriesBuilder::try_new(Arc::new(schema.clone()))?;
+    for (point, (value, count)) in values.into_iter().zip(counts).enumerate() {
+        let value = if count == 1 { value } else { Some(GO_NAN) };
+        builder.push(point, &[value])?;
+    }
+    let empty = MetricName::try_new(None, Vec::new()).map_err(external)?;
+    Ok(builder
+        .finish(empty)?
+        .expect("every point of a scalar has a value"))
+}
+
+/// `absent(v)`: 1 with `labels` at every point where no series is present.
+///
+/// `absent_over_time(v[r])` is this over the result of `present_over_time(v[r])`, with `labels`
+/// from the matchers of `v`, as Prometheus derives them for both.
+pub fn absent(
+    schema: &SeriesSchema,
+    series: &[Series],
+    labels: MetricName,
+) -> Result<Option<Series>> {
+    let points = grid_points(schema, series)?;
+    let fields = schema.fields.len();
+    // Each field is absent on its own.
+    let mut present = vec![false; points * fields];
+    for item in series {
+        let TimeAxis::Grid(range) = &item.time else {
+            unreachable!("checked by grid_points");
+        };
+        for (field, samples) in item.fields.iter().enumerate() {
+            for row in 0..range.len() {
+                if !matches!(samples.sample(row), SampleRef::Missing) {
+                    present[(range.start() + row) * fields + field] = true;
+                }
+            }
+        }
+    }
+    let mut builder = GridSeriesBuilder::try_new(Arc::new(schema.clone()))?;
+    let mut row = vec![None; fields];
+    for point in 0..points {
+        for (field, value) in row.iter_mut().enumerate() {
+            *value = (!present[point * fields + field]).then_some(1.0);
+        }
+        builder.push(point, &row)?;
+    }
+    builder.finish(labels)
+}
+
+/// A label matcher of the selector `absent` is applied to.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LabelMatcher {
+    pub name: Arc<str>,
+    pub op: MatchOp,
+    pub value: Arc<str>,
+    /// Whether the matcher accepts an empty value, i.e. a missing label; the caller evaluates
+    /// regular expressions.
+    pub matches_empty: bool,
+}
+
+/// The operator of a [`LabelMatcher`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum MatchOp {
+    Equal,
+    NotEqual,
+    Regex,
+    NotRegex,
+}
+
+/// The labels of an `absent` result, as Prometheus `createLabelsForAbsentFunction` derives them:
+/// the first equality matcher of a name sets that label, any other matcher of the name removes
+/// it, and `__name__` is skipped.
+///
+/// Prometheus reads the matchers after TSDB's `PostingsForMatchers` has reordered them in place,
+/// moving the matchers that narrow the result before those that only subtract from it; that is
+/// the order users see whenever the storage holds data, and the order used here. It changes the
+/// result only when a name has both an equality and another matcher.
+pub fn absent_labels(matchers: &[LabelMatcher]) -> Result<MetricName> {
+    let must_be_set: Vec<&str> = matchers
+        .iter()
+        .filter(|matcher| !matcher.matches_empty)
+        .map(|matcher| &*matcher.name)
+        .collect();
+    let subtracting = |matcher: &LabelMatcher| {
+        !must_be_set.contains(&&*matcher.name)
+            || (matches!(matcher.op, MatchOp::NotEqual | MatchOp::NotRegex)
+                && matcher.matches_empty)
+    };
+    let ordered = matchers
+        .iter()
+        .filter(|matcher| !subtracting(matcher))
+        .chain(matchers.iter().filter(|matcher| subtracting(matcher)));
+
+    let mut labels: Vec<Label> = Vec::new();
+    let mut set: Vec<&str> = Vec::new();
+    for matcher in ordered {
+        if &*matcher.name == "__name__" {
+            continue;
+        }
+        if matcher.op == MatchOp::Equal && !set.contains(&&*matcher.name) {
+            labels.retain(|label| label.name != matcher.name);
+            labels.push(Label {
+                name: matcher.name.clone(),
+                value: matcher.value.clone(),
+            });
+            set.push(&matcher.name);
+        } else {
+            labels.retain(|label| label.name != matcher.name);
+        }
+    }
+    labels.retain(|label| !label.value.is_empty());
+    MetricName::try_new(None, labels).map_err(external)
+}
+
+/// Orders the series of an instant result. A range result is returned unchanged: Prometheus
+/// does not sort matrices.
+pub fn sort_instant(
+    order: &SortOrder,
+    schema: &SeriesSchema,
+    mut series: Vec<Series>,
+) -> Result<Vec<Series>> {
+    let points = grid_points(schema, &series)?;
+    if points != 1 {
+        return Ok(series);
+    }
+    match order {
+        SortOrder::Asc | SortOrder::Desc => {
+            single_field(schema, "sort")?;
+            let mut keyed = Vec::with_capacity(series.len());
+            for item in series {
+                let value = value_at(&item, 0)?;
+                keyed.push((value.unwrap_or(f64::NAN), item));
+            }
+            let descending = *order == SortOrder::Desc;
+            // `sort.Sort(sort.Reverse(h))` with Prometheus' heap `Less`, which holds whenever
+            // its first value is NaN.
+            go_sort::sort_by(&mut keyed, |(a, _), (b, _)| {
+                b.is_nan() || if descending { b < a } else { b > a }
+            });
+            Ok(keyed.into_iter().map(|(_, item)| item).collect())
+        }
+        SortOrder::ByLabel(labels) | SortOrder::ByLabelDesc(labels) => {
+            let descending = matches!(order, SortOrder::ByLabelDesc(_));
+            go_sort::sort_by(&mut series, |a, b| {
+                for label in labels {
+                    let (a, b) = (
+                        a.metric.get(label).unwrap_or(""),
+                        b.metric.get(label).unwrap_or(""),
+                    );
+                    if a == b {
+                        continue;
+                    }
+                    return natural_less(a, b) != descending;
+                }
+                let order = compare_labels(&a.metric, &b.metric);
+                if descending {
+                    order == Ordering::Greater
+                } else {
+                    order == Ordering::Less
+                }
+            });
+            Ok(series)
+        }
+    }
+}
+
+/// Go's `math.NaN()` bit pattern, which Prometheus returns for an undefined scalar.
+const GO_NAN: f64 = f64::from_bits(0x7FF8_0000_0000_0001);
+
+/// The order of `a` and `b` for `topk` (`top`) or `bottomk`; NaN ranks last for both.
+fn rank(a: f64, b: f64, top: bool) -> Ordering {
+    match (a.is_nan(), b.is_nan()) {
+        (true, true) => Ordering::Equal,
+        (true, false) => Ordering::Greater,
+        (false, true) => Ordering::Less,
+        _ if top => b.partial_cmp(&a).expect("not NaN"),
+        _ => a.partial_cmp(&b).expect("not NaN"),
+    }
+}
+
+/// Label pairs identifying a group; empty values are absent, as in Prometheus.
+type GroupKey = Vec<(Arc<str>, Arc<str>)>;
+
+fn group_key(metric: &MetricName, grouping: &Grouping) -> GroupKey {
+    let mut key: Vec<_> = labels_with_name(metric)
+        .into_iter()
+        .filter(|(name, value)| {
+            !value.is_empty()
+                && match grouping {
+                    Grouping::By(names) => names.contains(name),
+                    Grouping::Without(names) => &**name != "__name__" && !names.contains(name),
+                }
+        })
+        .collect();
+    key.sort();
+    key
+}
+
+/// The label pairs of `metric` with `__name__` among them, sorted by name.
+fn labels_with_name(metric: &MetricName) -> Vec<(Arc<str>, Arc<str>)> {
+    let mut labels: Vec<_> = metric
+        .tags()
+        .iter()
+        .map(|tag| (tag.name.clone(), tag.value.clone()))
+        .collect();
+    if let Some(name) = metric.name() {
+        labels.push((Arc::from("__name__"), Arc::from(name)));
+    }
+    labels.sort();
+    labels
+}
+
+/// Prometheus `labels.Compare`: label pairs in name order, then the shorter set first.
+fn compare_labels(a: &MetricName, b: &MetricName) -> Ordering {
+    labels_with_name(a).cmp(&labels_with_name(b))
+}
+
+/// `github.com/facette/natsort.Compare`, which `sort_by_label` uses: digit runs compare as
+/// integers when both parse, other runs as strings.
+fn natural_less(a: &str, b: &str) -> bool {
+    let (chunks_a, chunks_b) = (chunks(a), chunks(b));
+    for (i, chunk_a) in chunks_a.iter().enumerate() {
+        let Some(chunk_b) = chunks_b.get(i) else {
+            return false;
+        };
+        let equal = match (chunk_a.parse::<i64>(), chunk_b.parse::<i64>()) {
+            (Ok(a), Ok(b)) if a != b => return a < b,
+            (Ok(_), Ok(_)) => true,
+            _ => chunk_a == chunk_b,
+        };
+        if !equal {
+            return chunk_a < chunk_b;
+        }
+        if i == chunks_a.len() - 1 {
+            return true;
+        } else if i == chunks_b.len() - 1 {
+            return false;
+        }
+    }
+    false
+}
+
+/// Maximal runs of ASCII digits and of other characters, like the regexp `(\d+|\D+)`.
+fn chunks(s: &str) -> Vec<&str> {
+    let mut chunks = Vec::new();
+    let mut start = 0;
+    let bytes = s.as_bytes();
+    for i in 1..=bytes.len() {
+        if i == bytes.len() || bytes[i].is_ascii_digit() != bytes[start].is_ascii_digit() {
+            chunks.push(&s[start..i]);
+            start = i;
+        }
+    }
+    chunks
+}
+
+fn single_field(schema: &SeriesSchema, operator: &str) -> Result<()> {
+    if schema.fields.len() != 1 {
+        return Err(DataFusionError::NotImplemented(format!(
+            "{operator} over series with {} fields",
+            schema.fields.len()
+        )));
+    }
+    Ok(())
+}
+
+/// Checks every series against `schema` and returns the grid length.
+fn grid_points(schema: &SeriesSchema, series: &[Series]) -> Result<usize> {
+    let grid = schema.eval_grid.as_ref().ok_or_else(|| {
+        DataFusionError::Execution("select operators need an evaluation grid".into())
+    })?;
+    for item in series {
+        match &item.time {
+            TimeAxis::Grid(range)
+                if range.grid().spec() == grid.spec()
+                    && item.fields.len() == schema.fields.len() => {}
+            _ => {
+                return Err(DataFusionError::Execution(
+                    "series does not match the select operator schema".into(),
+                ));
+            }
+        }
+    }
+    Ok(grid.timestamps().len())
+}
+
+/// The first field's value of `series` at grid `point`.
+fn value_at(series: &Series, point: usize) -> Result<Option<f64>> {
+    let TimeAxis::Grid(range) = &series.time else {
+        unreachable!("checked by grid_points");
+    };
+    if !(range.start()..range.start() + range.len()).contains(&point) {
+        return Ok(None);
+    }
+    match series.fields.as_slice()[0].sample(point - range.start()) {
+        SampleRef::Missing => Ok(None),
+        SampleRef::Float(value) => Ok(Some(value)),
+        SampleRef::Histogram(_) => Err(DataFusionError::NotImplemented(
+            "select operators over histogram samples".into(),
+        )),
+    }
+}

src/promql/src/select/tests.rs

@@ -0,0 +1,345 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use datafusion::error::DataFusionError;
+use datatypes::series::samples::{FieldSpec, Series, SeriesSchema};
+use datatypes::series::time::{EvalGrid, GridSpec};
+use datatypes::series::{Label, MetricName};
+
+use super::{
+    Grouping, LabelMatcher, MatchOp, SortOrder, absent, absent_labels, natural_less, scalar,
+    sort_instant, topk,
+};
+use crate::grid_series::GridSeriesBuilder;
+use crate::grid_series::reference::{Dense, assert_series_eq};
+
+fn schema(points: u64, fields: usize) -> SeriesSchema {
+    SeriesSchema {
+        fields: (0..fields)
+            .map(|index| FieldSpec {
+                name: Arc::from(format!("f{index}")),
+            })
+            .collect::<Vec<_>>()
+            .into(),
+        eval_grid: Some(Arc::new(
+            EvalGrid::try_new(GridSpec::try_new(100_000, 10_000, points).unwrap()).unwrap(),
+        )),
+    }
+}
+
+/// Parses `name=value,...`, with `__name__` as the metric name; `-` is no labels.
+fn metric(labels: &str) -> MetricName {
+    let mut name = None;
+    let mut tags = Vec::new();
+    for pair in labels.split(',').filter(|pair| *pair != "-") {
+        let (label, value) = pair.split_once('=').unwrap();
+        if label == "__name__" {
+            name = Some(Arc::from(value));
+        } else {
+            tags.push(Label {
+                name: Arc::from(label),
+                value: Arc::from(value),
+            });
+        }
+    }
+    MetricName::try_new(name, tags).unwrap()
+}
+
+fn dense(points: usize, values: &str) -> Dense {
+    let mut dense = vec![vec![None]; points];
+    for point in values.split_whitespace() {
+        let (index, bits) = point.split_once(':').unwrap();
+        dense[index.parse::<usize>().unwrap()][0] =
+            Some(f64::from_bits(u64::from_str_radix(bits, 16).unwrap()));
+    }
+    dense
+}
+
+fn build(schema: &SeriesSchema, metric: MetricName, dense: &Dense) -> Option<Series> {
+    let mut builder = GridSeriesBuilder::try_new(Arc::new(schema.clone())).unwrap();
+    for (index, row) in dense.iter().enumerate() {
+        builder.push(index, row).unwrap();
+    }
+    builder.finish(metric).unwrap()
+}
+
+fn names(list: &str) -> Vec<Arc<str>> {
+    list.split(',')
+        .filter(|name| *name != "-")
+        .map(Arc::from)
+        .collect()
+}
+
+/// `topk`/`bottomk`, `scalar` and `absent` evaluated by the Prometheus v3.15.0 engine; see the
+/// header of `prometheus_cases.txt`.
+#[test]
+fn select_operators_match_prometheus() {
+    let text = include_str!("prometheus_cases.txt");
+    let mut checked = 0;
+    for case in text.split("end\n").filter(|case| case.contains("case ")) {
+        let lines: Vec<&str> = case.lines().filter(|line| !line.starts_with('#')).collect();
+        let spec: Vec<&str> = lines[0].split_whitespace().skip(1).collect();
+        let points: usize = lines[1].split_whitespace().nth(3).unwrap().parse().unwrap();
+        let schema = schema(points as u64, 1);
+        let mut inputs = Vec::new();
+        let mut expected: BTreeMap<String, Dense> = BTreeMap::new();
+        for line in &lines[2..] {
+            let (kind, rest) = line.split_once(' ').unwrap();
+            let (labels, values) = rest.split_once(" ;").unwrap();
+            match kind {
+                "series" => inputs.push((metric(labels), dense(points, values))),
+                "result" => {
+                    expected.insert(labels.to_string(), dense(points, values));
+                }
+                other => panic!("unexpected line {other} in {case}"),
+            }
+        }
+        let series: Vec<Series> = inputs
+            .iter()
+            .filter_map(|(metric, dense)| build(&schema, metric.clone(), dense))
+            .collect();
+
+        let actual: Vec<Series> = match spec[0] {
+            "topk" => {
+                let grouping = match spec[3] {
+                    "without" => Grouping::Without(names(spec[4])),
+                    "by" => Grouping::By(names(spec[4])),
+                    _ => Grouping::By(Vec::new()),
+                };
+                let k: f64 = spec[2].parse().unwrap();
+                topk(k, spec[1] == "topk", &grouping, &schema, &series).unwrap()
+            }
+            "scalar" => vec![scalar(&schema, &series).unwrap()],
+            "absent" => {
+                let matchers: Vec<LabelMatcher> = spec
+                    .get(1)
+                    .filter(|matchers| **matchers != "-")
+                    .map(|matchers| {
+                        matchers
+                            .split(',')
+                            .map(|matcher| {
+                                let (name, op, value) = match matcher.split_once("!=") {
+                                    Some((name, value)) => (name, MatchOp::NotEqual, value),
+                                    None => {
+                                        let (name, value) = matcher.split_once('=').unwrap();
+                                        (name, MatchOp::Equal, value)
+                                    }
+                                };
+                                let value = value.trim_matches('"');
+                                LabelMatcher {
+                                    name: Arc::from(name),
+                                    op,
+                                    value: Arc::from(value),
+                                    matches_empty: (op == MatchOp::Equal) == value.is_empty(),
+                                }
+                            })
+                            .collect()
+                    })
+                    .unwrap_or_default();
+                let selected: Vec<Series> = series
+                    .iter()
+                    .filter(|item| {
+                        matchers.iter().all(|matcher| {
+                            let value = item.metric.get(&matcher.name).unwrap_or("");
+                            (value == &*matcher.value) == (matcher.op == MatchOp::Equal)
+                        })
+                    })
+                    .cloned()
+                    .collect();
+                absent(&schema, &selected, absent_labels(&matchers).unwrap())
+                    .unwrap()
+                    .into_iter()
+                    .collect()
+            }
+            other => panic!("unknown case {other}"),
+        };
+
+        let actual: BTreeMap<String, Series> = actual
+            .into_iter()
+            .map(|series| (render(&series.metric), series))
+            .collect();
+        assert_eq!(
+            actual.keys().collect::<Vec<_>>(),
+            expected.keys().collect::<Vec<_>>(),
+            "{case}"
+        );
+        for (labels, dense) in &expected {
+            assert_series_eq(actual.get(labels), dense, &metric(labels));
+            checked += 1;
+        }
+    }
+    assert!(checked > 200, "{checked} result series checked");
+}
+
+/// The fixture's label rendering: `name=value` pairs in name order, `-` when empty.
+fn render(metric: &MetricName) -> String {
+    let mut labels: Vec<(String, String)> = metric
+        .tags()
+        .iter()
+        .map(|tag| (tag.name.to_string(), tag.value.to_string()))
+        .collect();
+    if let Some(name) = metric.name() {
+        labels.push(("__name__".to_string(), name.to_string()));
+    }
+    labels.sort();
+    if labels.is_empty() {
+        return "-".to_string();
+    }
+    labels
+        .iter()
+        .map(|(name, value)| format!("{name}={value}"))
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
+fn instant(values: &[(&str, Option<f64>)]) -> (SeriesSchema, Vec<Series>) {
+    let schema = schema(1, 1);
+    let series = values
+        .iter()
+        .map(|(labels, value)| build(&schema, metric(labels), &vec![vec![*value]]).unwrap())
+        .collect();
+    (schema, series)
+}
+
+fn rendered(series: &[Series]) -> Vec<String> {
+    series.iter().map(|series| render(&series.metric)).collect()
+}
+
+#[test]
+fn sorts_instant_results_like_prometheus() {
+    let (schema, series) = instant(&[
+        ("host=a", Some(2.0)),
+        ("host=b", Some(f64::NAN)),
+        ("host=c", Some(-1.0)),
+    ]);
+    let ascending = sort_instant(&SortOrder::Asc, &schema, series.clone()).unwrap();
+    assert_eq!(rendered(&ascending), ["host=c", "host=a", "host=b"]);
+    let descending = sort_instant(&SortOrder::Desc, &schema, series).unwrap();
+    assert_eq!(rendered(&descending), ["host=a", "host=c", "host=b"]);
+
+    // Go compares with `<`, so the zeros tie and keep their order, and `Less` holds for every
+    // NaN on its left, so NaNs come out reversed.
+    let (schema, series) = instant(&[("host=a", Some(0.0)), ("host=b", Some(-0.0))]);
+    let ascending = sort_instant(&SortOrder::Asc, &schema, series).unwrap();
+    assert_eq!(rendered(&ascending), ["host=a", "host=b"]);
+    let (schema, series) = instant(&[
+        ("host=a", Some(f64::NAN)),
+        ("host=b", Some(1.0)),
+        ("host=c", Some(f64::NAN)),
+        ("host=d", Some(0.0)),
+    ]);
+    let ascending = sort_instant(&SortOrder::Asc, &schema, series.clone()).unwrap();
+    assert_eq!(
+        rendered(&ascending),
+        ["host=d", "host=b", "host=c", "host=a"]
+    );
+    let descending = sort_instant(&SortOrder::Desc, &schema, series).unwrap();
+    assert_eq!(
+        rendered(&descending),
+        ["host=b", "host=d", "host=c", "host=a"]
+    );
+
+    let (schema, series) = instant(&[
+        ("host=x10", Some(1.0)),
+        ("host=x9", Some(1.0)),
+        ("host=x9,job=a", Some(1.0)),
+        ("host=x", Some(1.0)),
+    ]);
+    let by_host = sort_instant(&SortOrder::ByLabel(names("host")), &schema, series.clone());
+    assert_eq!(
+        rendered(&by_host.unwrap()),
+        ["host=x", "host=x9", "host=x9,job=a", "host=x10"]
+    );
+    let by_host_desc = sort_instant(&SortOrder::ByLabelDesc(names("host")), &schema, series);
+    assert_eq!(
+        rendered(&by_host_desc.unwrap()),
+        ["host=x10", "host=x9,job=a", "host=x9", "host=x"]
+    );
+}
+
+/// `natsort.Compare` holds both ways for "1" and "01"; sorting many such labels must not panic.
+#[test]
+fn sort_by_label_accepts_inconsistent_natural_order() {
+    // This input makes `slice::sort_by` panic with this comparator on Rust 1.98.
+    let hosts: Vec<String> = (0..100)
+        .map(|i| format!("host={}{}", "0".repeat(i / 3 % 3), i * 7 % 10))
+        .collect();
+    let values: Vec<(&str, Option<f64>)> = hosts
+        .iter()
+        .map(|host| (host.as_str(), Some(1.0)))
+        .collect();
+    let (schema, series) = instant(&values);
+    for order in [
+        SortOrder::ByLabel(names("host")),
+        SortOrder::ByLabelDesc(names("host")),
+    ] {
+        let sorted = sort_instant(&order, &schema, series.clone()).unwrap();
+        assert_eq!(sorted.len(), 100);
+    }
+}
+
+#[test]
+fn natural_order_follows_natsort() {
+    assert!(natural_less("a", "a1"));
+    assert!(!natural_less("a1", "a"));
+    assert!(natural_less("x9", "x10"));
+    assert!(!natural_less("10", "9"));
+    // A digit run too long for an i64 compares as a string, like Go's strconv.Atoi failing.
+    assert!(natural_less("20000000000000000000", "3"));
+}
+
+#[test]
+fn rejects_value_operators_over_several_fields() {
+    let schema = schema(1, 2);
+    assert!(matches!(
+        topk(1.0, true, &Grouping::By(Vec::new()), &schema, &[]),
+        Err(DataFusionError::NotImplemented(_))
+    ));
+    assert!(matches!(
+        scalar(&schema, &[]),
+        Err(DataFusionError::NotImplemented(_))
+    ));
+}
+
+/// Prometheus returns nothing for `k` below 1 and rejects NaN and values out of int64.
+#[test]
+fn topk_validates_k_like_prometheus() {
+    let schema = schema(1, 1);
+    let series = vec![build(&schema, metric("__name__=a"), &vec![vec![Some(1.0)]]).unwrap()];
+    // Prometheus' `maxInt64` is 9223372036854774784, one float step below 2^63.
+    for k in [f64::NAN, f64::INFINITY, 9_223_372_036_854_774_784.0] {
+        assert!(
+            topk(k, true, &Grouping::By(Vec::new()), &schema, &series).is_err(),
+            "{k}"
+        );
+    }
+    for k in [0.5, f64::NEG_INFINITY] {
+        let result = topk(k, false, &Grouping::By(Vec::new()), &schema, &series).unwrap();
+        assert!(result.is_empty(), "{k}");
+    }
+}
+
+/// Each field of `absent` is 1 where that field has no sample.
+#[test]
+fn absent_evaluates_fields_independently() {
+    let schema = schema(2, 2);
+    let input = vec![vec![Some(3.0), None], vec![None, Some(4.0)]];
+    let series = vec![build(&schema, metric("__name__=a"), &input).unwrap()];
+    let result = absent(&schema, &series, metric("-")).unwrap();
+    let expected = vec![vec![None, Some(1.0)], vec![Some(1.0), None]];
+    assert_series_eq(result.as_ref(), &expected, &metric("-"));
+}

src/promql/src/vector_match.rs

@@ -0,0 +1,798 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Vector–vector binary and set operations over evaluated series on one grid.
+//!
+//! Semantics follow Prometheus `VectorBinop`, `VectorAnd`, `VectorOr` and `VectorUnless`
+//! evaluated at every grid point. Series are processed whole, over their own grid ranges, and
+//! the cardinality rules are checked per point: series sharing a match group only conflict at
+//! points where both are present. Each field is matched on its own, as if the operands held
+//! only that field; the results of all fields with one label set form one series.
+
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use datafusion::arrow::array::Array;
+use datafusion::error::{DataFusionError, Result};
+use datatypes::series::MetricName;
+use datatypes::series::histogram::{CounterResetHint, HistogramView};
+use datatypes::series::samples::{DenseSamplesRef, SampleRef, Series, SeriesSchema};
+use datatypes::series::time::{EvalGrid, TimeAxis};
+
+use crate::grid_series::{GridSample, GridSeriesBuilder, METADATA_LABELS};
+use crate::histogram_eval::float_histogram::FloatHistogram;
+
+#[cfg(test)]
+mod tests;
+
+/// A PromQL binary operator between two instant vectors.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum BinaryOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Pow,
+    Atan2,
+    Eq,
+    Ne,
+    Gt,
+    Lt,
+    Ge,
+    Le,
+}
+
+impl BinaryOp {
+    fn is_comparison(self) -> bool {
+        matches!(
+            self,
+            Self::Eq | Self::Ne | Self::Gt | Self::Lt | Self::Ge | Self::Le
+        )
+    }
+
+    /// The value and whether a comparison holds, as Prometheus `vectorElemBinop` computes them.
+    fn apply(self, lhs: f64, rhs: f64) -> (f64, bool) {
+        match self {
+            Self::Add => (lhs + rhs, true),
+            Self::Sub => (lhs - rhs, true),
+            Self::Mul => (lhs * rhs, true),
+            Self::Div => (lhs / rhs, true),
+            Self::Mod => (lhs % rhs, true),
+            Self::Pow => (lhs.powf(rhs), true),
+            Self::Atan2 => (lhs.atan2(rhs), true),
+            Self::Eq => (lhs, lhs == rhs),
+            Self::Ne => (lhs, lhs != rhs),
+            Self::Gt => (lhs, lhs > rhs),
+            Self::Lt => (lhs, lhs < rhs),
+            Self::Ge => (lhs, lhs >= rhs),
+            Self::Le => (lhs, lhs <= rhs),
+        }
+    }
+}
+
+/// The labels two series are matched by.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum MatchingLabels {
+    /// `on(...)`: only these labels, `__name__` included when listed.
+    On(Vec<Arc<str>>),
+    /// `ignoring(...)`, and the default with no labels: every label except these and
+    /// `__name__`.
+    Ignoring(Vec<Arc<str>>),
+}
+
+/// How many series of each side may share a match group.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Cardinality {
+    OneToOne,
+    /// `group_left(...)`: the right side is the "one" side; the listed labels are copied from it.
+    ManyToOne(Vec<Arc<str>>),
+    /// `group_right(...)`: the left side is the "one" side; the listed labels are copied from it.
+    OneToMany(Vec<Arc<str>>),
+}
+
+/// A vector–vector binary operation with its modifiers.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BinaryMatching {
+    pub op: BinaryOp,
+    /// `bool`: comparisons return 1 or 0 instead of filtering.
+    pub return_bool: bool,
+    pub labels: MatchingLabels,
+    pub cardinality: Cardinality,
+}
+
+/// A PromQL set operator between two instant vectors.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SetOp {
+    And,
+    Or,
+    Unless,
+}
+
+/// The schema of `binary_vectors` output: fields paired by position, named after the left side.
+pub fn binary_output_schema(lhs: &SeriesSchema, rhs: &SeriesSchema) -> Result<Arc<SeriesSchema>> {
+    let grid = same_grid(lhs, rhs)?;
+    let fields = lhs.fields.len().min(rhs.fields.len());
+    Ok(Arc::new(SeriesSchema {
+        fields: lhs.fields[..fields].to_vec().into(),
+        eval_grid: Some(grid),
+    }))
+}
+
+/// Applies `matching` to every pair of matched series at every grid point.
+///
+/// Fields are paired by position. Arithmetic and `bool` comparisons drop `__name__`, `__type__`
+/// and `__unit__`; comparisons without `bool` keep the left value where they hold. Native
+/// histograms support `+`, `-`, `==` and `!=` with each other, `*` with a float on either side
+/// and `/` by a float; Prometheus skips any other pairing of a histogram.
+pub fn binary_vectors(
+    matching: &BinaryMatching,
+    lhs_schema: &SeriesSchema,
+    lhs: &[Series],
+    rhs_schema: &SeriesSchema,
+    rhs: &[Series],
+) -> Result<Vec<Series>> {
+    let output = binary_output_schema(lhs_schema, rhs_schema)?;
+    let grid = output
+        .eval_grid
+        .clone()
+        .expect("set by binary_output_schema");
+    let mut errors = Vec::new();
+    let mut fields = Vec::with_capacity(output.fields.len());
+    for field in 0..output.fields.len() {
+        let lhs = Operand::try_new(lhs_schema, lhs, field)?;
+        let rhs = Operand::try_new(rhs_schema, rhs, field)?;
+        fields.push(binary_field(matching, &grid, &lhs, &rhs, &mut errors)?);
+    }
+    earliest_error(errors)?;
+    merge_fields(fields, output)
+}
+
+/// Matches one field of each side, collecting the first failure of each kind as
+/// `(point, rank, message)`.
+fn binary_field(
+    matching: &BinaryMatching,
+    grid: &EvalGrid,
+    lhs: &Operand<'_>,
+    rhs: &Operand<'_>,
+    errors: &mut Vec<(usize, u8, String)>,
+) -> Result<Results> {
+    let (many, one, include, one_is_left) = match &matching.cardinality {
+        Cardinality::OneToOne => (lhs, rhs, &[][..], false),
+        Cardinality::ManyToOne(include) => (lhs, rhs, &include[..], false),
+        Cardinality::OneToMany(include) => (rhs, lhs, &include[..], true),
+    };
+    let points = grid.timestamps().len();
+    // Prometheus short-circuits a point where either side is empty, before any check.
+    let both_present: Vec<bool> = lhs
+        .presence(points)
+        .into_iter()
+        .zip(rhs.presence(points))
+        .map(|(lhs, rhs)| lhs && rhs)
+        .collect();
+
+    let one_groups = group(one, &matching.labels);
+    let mut one_duplicate: Option<(usize, &GroupKey)> = None;
+    for (key, members) in &one_groups {
+        if let Some(point) = overlap(one, members, |point| both_present[point])
+            && one_duplicate.is_none_or(|(first, _)| point < first)
+        {
+            one_duplicate = Some((point, key));
+        }
+    }
+
+    let drop_name = !matching.op.is_comparison() || matching.return_bool;
+    let mut results = Results::default();
+    let group_keys: Vec<&GroupKey> = one_groups.keys().collect();
+    let group_ids: HashMap<&GroupKey, usize> = group_keys
+        .iter()
+        .enumerate()
+        .map(|(id, key)| (*key, id))
+        .collect();
+    // One-to-one: a match group may be matched once per point; Prometheus counts a filtered
+    // comparison as a match too, but not an operation that failed.
+    let mut matched: HashSet<(usize, usize)> = HashSet::new();
+    let mut implicit_many_to_one: Option<(usize, &GroupKey)> = None;
+    for (many_index, many_series) in many.series.iter().enumerate() {
+        let key = group_key(&many_series.metric, &matching.labels);
+        let Some(candidates) = one_groups.get(&key) else {
+            continue;
+        };
+        let group_id = group_ids[&key];
+        for &one_index in candidates {
+            let metric = result_metric(
+                &many_series.metric,
+                &one.series[one_index].metric,
+                matching,
+                include,
+                drop_name,
+            )?;
+            let (start, end) = one.overlap_range(many, one_index, many_index);
+            for point in start..end {
+                if !(many.present(many_index, point) && one.present(one_index, point)) {
+                    continue;
+                }
+                let (many_value, one_value) =
+                    (many.value(many_index, point), one.value(one_index, point));
+                let (lhs_value, rhs_value) = if one_is_left {
+                    (one_value, many_value)
+                } else {
+                    (many_value, one_value)
+                };
+                let Some((result, keep)) = elem_binop(matching.op, lhs_value, rhs_value)? else {
+                    continue;
+                };
+                if matching.cardinality == Cardinality::OneToOne
+                    && !matched.insert((group_id, point))
+                    && implicit_many_to_one.is_none_or(|(first, _)| point < first)
+                {
+                    implicit_many_to_one = Some((point, group_keys[group_id]));
+                }
+                let value = if matching.return_bool {
+                    Some(GridSample::Float(if keep { 1.0 } else { 0.0 }))
+                } else {
+                    keep.then_some(result)
+                };
+                results.insert(&metric, group_id, point, value);
+            }
+        }
+    }
+    // Prometheus fails at the first failing step. Within a step it checks the one side, then
+    // matches, and only after the operator checks that result label sets are unique.
+    if let Some((point, key)) = one_duplicate {
+        let side = if one_is_left { "left" } else { "right" };
+        errors.push((
+            point,
+            0,
+            format!(
+                "found duplicate series for the match group {} on the {side} hand-side of the \
+                 operation at {} ms; many-to-many matching not allowed: matching labels must be \
+                 unique on one side",
+                render(key),
+                grid.timestamps()[point]
+            ),
+        ));
+    }
+    if let Some((point, key)) = implicit_many_to_one {
+        errors.push((
+            point,
+            1,
+            format!(
+                "multiple matches for labels {} at {} ms: many-to-one matching must be explicit \
+                 (group_left/group_right)",
+                render(key),
+                grid.timestamps()[point]
+            ),
+        ));
+    }
+    if let Some(duplicate) = results.sort_rows() {
+        let grouping = duplicate.within_group && matching.cardinality != Cardinality::OneToOne;
+        errors.push(if grouping {
+            (
+                duplicate.point,
+                1,
+                format!(
+                    "multiple matches for labels {} at {} ms: grouping labels must ensure \
+                     unique matches",
+                    render(&duplicate.key),
+                    grid.timestamps()[duplicate.point]
+                ),
+            )
+        } else {
+            (
+                duplicate.point,
+                2,
+                same_labelset(&duplicate.key, grid.timestamps()[duplicate.point]),
+            )
+        });
+    }
+    Ok(results)
+}
+
+fn earliest_error(errors: Vec<(usize, u8, String)>) -> Result<()> {
+    match errors
+        .into_iter()
+        .min_by_key(|(point, rank, _)| (*point, *rank))
+    {
+        Some((_, _, error)) => Err(DataFusionError::Execution(error)),
+        None => Ok(()),
+    }
+}
+
+/// Applies a set operator at every grid point. Series keep their labels and values; fields are
+/// paired by position.
+pub fn set_vectors(
+    op: SetOp,
+    labels: &MatchingLabels,
+    lhs_schema: &SeriesSchema,
+    lhs: &[Series],
+    rhs_schema: &SeriesSchema,
+    rhs: &[Series],
+) -> Result<Vec<Series>> {
+    let grid = same_grid(lhs_schema, rhs_schema)?;
+    if lhs_schema.fields.len() != rhs_schema.fields.len() {
+        return Err(DataFusionError::NotImplemented(
+            "set operators between vectors with different field counts".into(),
+        ));
+    }
+    let output = Arc::new(SeriesSchema {
+        fields: lhs_schema.fields.clone(),
+        eval_grid: Some(grid.clone()),
+    });
+    let mut errors = Vec::new();
+    let mut fields = Vec::with_capacity(output.fields.len());
+    for field in 0..output.fields.len() {
+        let lhs = Operand::try_new(lhs_schema, lhs, field)?;
+        let rhs = Operand::try_new(rhs_schema, rhs, field)?;
+        let mut results = set_field(op, labels, &lhs, &rhs)?;
+        if let Some(duplicate) = results.sort_rows() {
+            let timestamp = grid.timestamps()[duplicate.point];
+            errors.push((duplicate.point, 0, same_labelset(&duplicate.key, timestamp)));
+        }
+        fields.push(results);
+    }
+    earliest_error(errors)?;
+    merge_fields(fields, output)
+}
+
+fn set_field(
+    op: SetOp,
+    labels: &MatchingLabels,
+    lhs: &Operand<'_>,
+    rhs: &Operand<'_>,
+) -> Result<Results> {
+    let (kept, filter, keep_matched) = match op {
+        SetOp::And => (lhs, rhs, true),
+        SetOp::Unless => (lhs, rhs, false),
+        SetOp::Or => (rhs, lhs, false),
+    };
+    let filter_groups = group(filter, labels);
+    let mut results = Results::default();
+    if op == SetOp::Or {
+        for index in 0..lhs.series.len() {
+            for point in lhs.range(index) {
+                if let Some(value) = owned(lhs.value(index, point))? {
+                    results.insert(&lhs.series[index].metric, 0, point, Some(value));
+                }
+            }
+        }
+    }
+    for (index, series) in kept.series.iter().enumerate() {
+        let candidates = filter_groups.get(&group_key(&series.metric, labels));
+        for point in kept.range(index) {
+            if !kept.present(index, point) {
+                continue;
+            }
+            let mut matched = false;
+            for &candidate in candidates.into_iter().flatten() {
+                if filter.covers(candidate, point) && filter.present(candidate, point) {
+                    matched = true;
+                    break;
+                }
+            }
+            if matched == keep_matched {
+                results.insert(&series.metric, 0, point, owned(kept.value(index, point))?);
+            }
+        }
+    }
+    Ok(results)
+}
+
+/// Joins the per-field results into series with all fields, by label set.
+fn merge_fields(fields: Vec<Results>, schema: Arc<SeriesSchema>) -> Result<Vec<Series>> {
+    let width = schema.fields.len();
+    // Per label set: the metric and its `(point, field, value)` samples.
+    type Merged = (MetricName, Vec<(usize, usize, GridSample)>);
+    let mut merged: HashMap<GroupKey, Merged> = HashMap::new();
+    for (field, results) in fields.into_iter().enumerate() {
+        for (key, rows) in results.series {
+            let (_, samples) = merged
+                .entry(key)
+                .or_insert_with(|| (rows.metric.clone(), Vec::new()));
+            for (&point, value) in rows.points.iter().zip(rows.values) {
+                if let Some(value) = value {
+                    samples.push((point, field, value));
+                }
+            }
+        }
+    }
+    let mut builder = GridSeriesBuilder::try_new(schema)?;
+    let mut row: Vec<Option<GridSample>> = Vec::with_capacity(width);
+    let mut output = Vec::with_capacity(merged.len());
+    for (metric, mut samples) in merged.into_values() {
+        samples.sort_unstable_by_key(|(point, field, _)| (*point, *field));
+        let mut samples = samples.into_iter().peekable();
+        while let Some((point, field, value)) = samples.next() {
+            row.clear();
+            row.resize_with(width, || None);
+            row[field] = Some(value);
+            while let Some((_, field, value)) = samples.next_if(|next| next.0 == point) {
+                row[field] = Some(value);
+            }
+            builder.push_samples(point, &row)?;
+        }
+        if let Some(series) = builder.finish(metric)? {
+            output.push(series);
+        }
+    }
+    Ok(output)
+}
+
+fn same_grid(lhs: &SeriesSchema, rhs: &SeriesSchema) -> Result<Arc<EvalGrid>> {
+    match (&lhs.eval_grid, &rhs.eval_grid) {
+        (Some(lhs), Some(rhs)) if lhs.spec() == rhs.spec() => Ok(lhs.clone()),
+        _ => Err(DataFusionError::Execution(
+            "vector operands must be evaluated on the same grid".into(),
+        )),
+    }
+}
+
+/// Label pairs identifying a match group or a result; empty values are absent, as in
+/// Prometheus.
+type GroupKey = Vec<(Arc<str>, Arc<str>)>;
+
+fn group_key(metric: &MetricName, labels: &MatchingLabels) -> GroupKey {
+    let mut key: GroupKey = match labels {
+        MatchingLabels::On(names) => names
+            .iter()
+            .filter_map(|name| {
+                let value = metric.get(name)?;
+                (!value.is_empty()).then(|| (name.clone(), Arc::from(value)))
+            })
+            .collect(),
+        MatchingLabels::Ignoring(names) => metric
+            .tags()
+            .iter()
+            .filter(|tag| !tag.value.is_empty() && !names.contains(&tag.name))
+            .map(|tag| (tag.name.clone(), tag.value.clone()))
+            .collect(),
+    };
+    key.sort();
+    key.dedup();
+    key
+}
+
+fn key_of(metric: &MetricName) -> GroupKey {
+    let mut key = group_key(metric, &MatchingLabels::Ignoring(Vec::new()));
+    if let Some(name) = metric.name() {
+        key.insert(0, (Arc::from("__name__"), Arc::from(name)));
+    }
+    key
+}
+
+fn render(key: &GroupKey) -> String {
+    let labels: Vec<_> = key
+        .iter()
+        .map(|(name, value)| format!("{name}=\"{value}\""))
+        .collect();
+    format!("{{{}}}", labels.join(", "))
+}
+
+/// Groups the series of `operand` by their match group.
+fn group(operand: &Operand<'_>, labels: &MatchingLabels) -> HashMap<GroupKey, Vec<usize>> {
+    let mut groups: HashMap<GroupKey, Vec<usize>> = HashMap::new();
+    for (index, series) in operand.series.iter().enumerate() {
+        groups
+            .entry(group_key(&series.metric, labels))
+            .or_default()
+            .push(index);
+    }
+    groups
+}
+
+/// The first point where two `members` are present and `relevant` holds.
+fn overlap(
+    operand: &Operand<'_>,
+    members: &[usize],
+    relevant: impl Fn(usize) -> bool,
+) -> Option<usize> {
+    if members.len() < 2 {
+        return None;
+    }
+    // Sorting the present points keeps the cost proportional to them, not to the span.
+    let mut points = Vec::new();
+    for &member in members {
+        for point in operand.range(member) {
+            if operand.present(member, point) {
+                points.push(point);
+            }
+        }
+    }
+    points.sort_unstable();
+    for pair in points.windows(2) {
+        if pair[0] == pair[1] && relevant(pair[0]) {
+            return Some(pair[0]);
+        }
+    }
+    None
+}
+
+fn result_metric(
+    many: &MetricName,
+    one: &MetricName,
+    matching: &BinaryMatching,
+    include: &[Arc<str>],
+    drop_name: bool,
+) -> Result<MetricName> {
+    let mut metric = many.clone();
+    if drop_name {
+        metric.remove_all(&METADATA_LABELS);
+    }
+    if matching.cardinality == Cardinality::OneToOne {
+        match &matching.labels {
+            MatchingLabels::On(names) => {
+                metric.keep_only(&names.iter().map(|name| &**name).collect::<Vec<_>>())
+            }
+            MatchingLabels::Ignoring(names) => {
+                metric.remove_all(&names.iter().map(|name| &**name).collect::<Vec<_>>())
+            }
+        }
+    }
+    for name in include {
+        match one.get(name) {
+            Some(value) if !value.is_empty() => metric
+                .set(name, Arc::from(value))
+                .map_err(|error| DataFusionError::External(Box::new(error)))?,
+            _ => metric.remove(name),
+        }
+    }
+    Ok(metric)
+}
+
+/// One field of one side's series, with checked grid ranges.
+struct Operand<'a> {
+    series: &'a [Series],
+    starts: Vec<usize>,
+    field: usize,
+}
+
+impl<'a> Operand<'a> {
+    fn try_new(schema: &SeriesSchema, series: &'a [Series], field: usize) -> Result<Self> {
+        let grid = schema.eval_grid.as_ref().map(|grid| grid.spec());
+        let mut starts = Vec::with_capacity(series.len());
+        for item in series {
+            let TimeAxis::Grid(range) = &item.time else {
+                return Err(DataFusionError::Execution(
+                    "vector operand series must be on the evaluation grid".into(),
+                ));
+            };
+            if Some(range.grid().spec()) != grid
+                || item.fields.len() != schema.fields.len()
+                || item.fields.iter().any(|field| field.len() != range.len())
+            {
+                return Err(DataFusionError::Execution(
+                    "vector operand series does not match its schema".into(),
+                ));
+            }
+            starts.push(range.start());
+        }
+        Ok(Self {
+            series,
+            starts,
+            field,
+        })
+    }
+
+    fn start(&self, index: usize) -> usize {
+        self.starts[index]
+    }
+
+    fn end(&self, index: usize) -> usize {
+        self.starts[index] + self.series[index].time.len()
+    }
+
+    fn range(&self, index: usize) -> std::ops::Range<usize> {
+        self.start(index)..self.end(index)
+    }
+
+    fn covers(&self, index: usize, point: usize) -> bool {
+        self.range(index).contains(&point)
+    }
+
+    /// The shared points of `self[own]` and `other[theirs]`.
+    fn overlap_range(&self, other: &Operand<'_>, own: usize, theirs: usize) -> (usize, usize) {
+        let start = self.start(own).max(other.start(theirs));
+        let end = self.end(own).min(other.end(theirs));
+        (start, end.max(start))
+    }
+
+    fn value(&self, index: usize, point: usize) -> SampleRef<'a> {
+        let samples = &self.series[index].fields.as_slice()[self.field];
+        let row = point - self.starts[index];
+        if let Some(DenseSamplesRef::Float(values)) = samples.dense() {
+            return match values.is_valid(row) {
+                true => SampleRef::Float(values.value(row)),
+                false => SampleRef::Missing,
+            };
+        }
+        samples.sample(row)
+    }
+
+    fn present(&self, index: usize, point: usize) -> bool {
+        !matches!(self.value(index, point), SampleRef::Missing)
+    }
+
+    /// Whether any series is present at each grid point.
+    fn presence(&self, points: usize) -> Vec<bool> {
+        let mut presence = vec![false; points];
+        for index in 0..self.series.len() {
+            for point in self.range(index) {
+                if !presence[point] && self.present(index, point) {
+                    presence[point] = true;
+                }
+            }
+        }
+        presence
+    }
+}
+
+/// `sample` as an owned value; `None` when missing.
+fn owned(sample: SampleRef<'_>) -> Result<Option<GridSample>> {
+    Ok(match sample {
+        SampleRef::Missing => None,
+        SampleRef::Float(value) => Some(GridSample::Float(value)),
+        SampleRef::Histogram(view) => {
+            Some(GridSample::Histogram(FloatHistogram::try_from_view(&view)?))
+        }
+    })
+}
+
+/// Prometheus `vectorElemBinop` over present samples: the value and whether to keep it, or
+/// `None` when Prometheus reports the pair as an annotation and skips it without counting the
+/// match: an operator the sample types do not support, or histograms mixing exponential and
+/// custom buckets in an addition or subtraction.
+fn elem_binop(
+    op: BinaryOp,
+    lhs: SampleRef<'_>,
+    rhs: SampleRef<'_>,
+) -> Result<Option<(GridSample, bool)>> {
+    let histogram = |view: &HistogramView<'_>| FloatHistogram::try_from_view(view);
+    let mut result = match (lhs, rhs) {
+        (SampleRef::Float(lhs), SampleRef::Float(rhs)) => {
+            let (value, keep) = op.apply(lhs, rhs);
+            return Ok(Some((GridSample::Float(value), keep)));
+        }
+        (SampleRef::Float(factor), SampleRef::Histogram(h))
+        | (SampleRef::Histogram(h), SampleRef::Float(factor))
+            if op == BinaryOp::Mul =>
+        {
+            let mut h = histogram(&h)?;
+            h.mul(factor);
+            h
+        }
+        (SampleRef::Histogram(h), SampleRef::Float(divisor)) if op == BinaryOp::Div => {
+            let mut h = histogram(&h)?;
+            h.div(divisor);
+            h
+        }
+        (SampleRef::Histogram(lhs), SampleRef::Histogram(rhs)) => {
+            let (mut lhs, rhs) = (histogram(&lhs)?, histogram(&rhs)?);
+            match op {
+                BinaryOp::Eq | BinaryOp::Ne => {
+                    let keep = lhs.equals(&rhs) == (op == BinaryOp::Eq);
+                    return Ok(Some((GridSample::Histogram(lhs), keep)));
+                }
+                BinaryOp::Add | BinaryOp::Sub => {
+                    if lhs.uses_custom_buckets() != rhs.uses_custom_buckets() {
+                        return Ok(None);
+                    }
+                    if op == BinaryOp::Add {
+                        lhs.add(&rhs)?;
+                    } else {
+                        lhs.sub(&rhs)?;
+                        lhs.reset_hint = CounterResetHint::Gauge;
+                    }
+                    lhs
+                }
+                _ => return Ok(None),
+            }
+        }
+        _ => return Ok(None),
+    };
+    result.compact();
+    Ok(Some((GridSample::Histogram(result), true)))
+}
+
+/// The result rows of one field by result label set.
+#[derive(Default)]
+struct Results {
+    series: HashMap<GroupKey, ResultRows>,
+}
+
+/// Rows in arrival order: their points, the match group each came from, and their values;
+/// `None` is a match the operator filtered.
+struct ResultRows {
+    metric: MetricName,
+    points: Vec<usize>,
+    groups: Vec<usize>,
+    values: Vec<Option<GridSample>>,
+}
+
+/// Two rows of one result label set at one point.
+struct Duplicate {
+    point: usize,
+    key: GroupKey,
+    /// Whether two of the rows came from the same match group.
+    within_group: bool,
+}
+
+fn same_labelset(key: &GroupKey, timestamp: i64) -> String {
+    format!(
+        "vector cannot contain metrics with the same labelset {} at {timestamp} ms",
+        render(key)
+    )
+}
+
+impl Results {
+    fn insert(
+        &mut self,
+        metric: &MetricName,
+        group: usize,
+        point: usize,
+        value: Option<GridSample>,
+    ) {
+        let rows = match self.series.entry(key_of(metric)) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(ResultRows {
+                metric: metric.clone(),
+                points: Vec::new(),
+                groups: Vec::new(),
+                values: Vec::new(),
+            }),
+        };
+        rows.points.push(point);
+        rows.groups.push(group);
+        rows.values.push(value);
+    }
+
+    /// Sorts the rows of each label set by point and returns the earliest point where a label
+    /// set has two rows, preferring one within a match group at that point. Prometheus
+    /// evaluates step by step and fails at the first such step.
+    fn sort_rows(&mut self) -> Option<Duplicate> {
+        let mut first: Option<(usize, bool, &GroupKey)> = None;
+        for (key, rows) in &mut self.series {
+            if !rows.points.is_sorted() {
+                let mut order: Vec<usize> = (0..rows.points.len()).collect();
+                order.sort_by_key(|&row| rows.points[row]);
+                rows.points = order.iter().map(|&row| rows.points[row]).collect();
+                rows.groups = order.iter().map(|&row| rows.groups[row]).collect();
+                let mut values = std::mem::take(&mut rows.values);
+                rows.values = order.iter().map(|&row| values[row].take()).collect();
+            }
+            let mut start = 0;
+            while start < rows.points.len() {
+                let point = rows.points[start];
+                let end = start + rows.points[start..].partition_point(|&p| p == point);
+                if end - start > 1 {
+                    let mut groups = rows.groups[start..end].to_vec();
+                    groups.sort_unstable();
+                    let within_group = groups.windows(2).any(|pair| pair[0] == pair[1]);
+                    if first.is_none_or(|(first_point, first_within, _)| {
+                        (point, !within_group) < (first_point, !first_within)
+                    }) {
+                        first = Some((point, within_group, key));
+                    }
+                    break;
+                }
+                start = end;
+            }
+        }
+        first.map(|(point, within_group, key)| Duplicate {
+            point,
+            key: key.clone(),
+            within_group,
+        })
+    }
+}

src/promql/src/vector_match/go_math_cases.txt

@@ -0,0 +1,454 @@
+# Generated by promql-compat cmd/narthex-golden-gomath built for amd64. Each line is
+# `<function> <arg1> <arg2> <result>` as hex bit patterns.
+pow 400a0dac65acfea0 c024000000000000 3edf412c74aab896
+pow 3ff3962ba0e9e8fc 4037800000000000 405cfbee2fe16b2d
+pow 3fee07edb7998f98 c020000000000000 3ffa97c4b7fd884f
+pow 3ff872e086629504 4040400000000000 412d71775ec38f39
+pow 3ffe06094ec738a6 c043800000000000 3db808f121bf08d5
+pow 3fedea6a3becf4a3 4025c00000000000 3fdec42a28225290
+pow 3ff0a4133102ce42 c020000000000000 3fe75f2c6826ef5e
+pow 4008f744d8a1ba1c c024800000000000 3ee2025a66ba9c56
+pow 400aa970054f9908 403a000000000000 42c1ce86782821f4
+pow 400740b53391107f 403fa00000000000 42f9a8627247c370
+pow 40052dbb11735ab8 c022000000000000 3f2485da7e2f0ec2
+pow 40091b2f0a5ea9b8 402bc00000000000 415db83e4daf6ce6
+pow 400a9de4cdda680d 402a000000000000 415759ec4dcf58c0
+pow 400a323ce898cda2 4033600000000000 4201d46200cc449e
+pow 3ffe0ddcf2088230 4028000000000000 409e2574372f0ee0
+pow 400ac5b6667ccc28 4040000000000000 436b32bc8bfcd6fa
+pow 4006cc1dc34c95b5 c038000000000000 3daabda470d44b72
+pow 40018642c4d5865e 4027400000000000 40c1c5026893ba55
+pow 3fe93a1232bea904 c02a000000000000 4036040539a49c7b
+pow 4003d168e043ce30 c041300000000000 3d2022655b0ce5d5
+pow 40005dab668206aa 4041000000000000 422141c714a2c498
+pow 3ff1034c42c7be83 4032a00000000000 4009186a85b377ca
+pow 4008830dca8284bc 4043000000000000 43c4e740a9d36c1b
+pow 4008fa2f53b2a50f c043900000000000 3beaa36ff8d454b6
+pow 400a031c285b6109 4018000000000000 409276e92a9f96db
+pow 40051e781166e7ac 4031a00000000000 4179b165242f7e66
+pow 3ffa0e1b0d1aaa32 c030000000000000 3f3acc7f782b2c8d
+pow 3fec4688f56a49e1 4032000000000000 3fbb99fe029fc71c
+pow 3feb9522844f04fa c032000000000000 402cfe75c4b7af0f
+pow 4001edcd260a7944 c043700000000000 3d1abe45a4dd0281
+pow 40094052c552fae5 c008000000000000 3fa04807083568a8
+pow 3ffb4a388389d810 c03ec00000000000 3e73e1c2c3c0aa08
+pow 400a03d2c59e4001 4010000000000000 405bf4ab8bbe298e
+pow 3ffa65dbe9f87dde c031a00000000000 3f234619fe0babaf
+pow 3ff33fdec32015d3 c030000000000000 3faa93524239c2bd
+pow 400b3278b0c42c70 4043300000000000 442ad86c19a814ee
+pow 400af692ebe23188 c035000000000000 3da23c61d9123404
+pow 3ffc80df6b5eab02 4039600000000000 41419e28eeca60c1
+pow 3ff023341775792c c039000000000000 3fe9d626251c9b33
+pow 3ff4f47cf42b887a c00f000000000000 3fd67f9aa2e45526
+pow 400b7163690533db 4043000000000000 4427e16d6a327666
+pow 400a9be2805f683e 403aa00000000000 42d1eb5980c9dda9
+pow 40082a71a1ec0101 c032000000000000 3e239685b8412e38
+pow 3ff0b1bc8a7f4aaa c03d200000000000 3fd292c0ce1692fb
+pow 3ff74997d6e98667 c018000000000000 3fbaede905fd1ca5
+pow 3fe5efaefb6f268e c03e600000000000 40f7600b6eb0cffe
+pow 400a466410e309b6 c041000000000000 3c4970a21f303ad5
+pow 3fe6619daa2edd28 c03ee00000000000 40ee5efbd4a46a8a
+pow 4009d4e6232cfacf c024000000000000 3ee105a1b43b99df
+pow 400b43bf4b180210 c043200000000000 3bb436e66d8c1f53
+pow 3ff1436e67b59066 c038000000000000 3fc4a80c864f4aaf
+pow 400b37e4d90a9ee0 c033a00000000000 3dc424f2188ec353
+pow 3ff33e3fd038d1b7 c014000000000000 3fd96ed9df7e8634
+pow 40017d164a53c672 c040300000000000 3da628c91608e682
+pow 4004cdc9586fa228 4038000000000000 420109c160fe0fa1
+pow 3fffa69e29ef15f8 4027c00000000000 40a9c27f5ae74fbe
+pow 400670c786c18b6e 4008000000000000 403612485f374cc6
+pow 3ff602f6e8aba185 c031000000000000 3f7215df07de25c0
+pow 400826b3c738dbd1 4010000000000000 4054c3dc09484969
+pow 400a11647a52df78 c040a00000000000 3c642f4d74c6ae78
+pow 3ff7c2f1cd59315a 4041000000000000 4125185cdd0683a7
+pow 3ffa842a9a3d69bc 4035800000000000 40e9720694d2aeb6
+pow 3ff2767463e21fa4 403a000000000000 4044ade19a65f006
+pow 40059f4adf920266 403d200000000000 428b707c056f6d1e
+pow 3ff57e924346da27 c036000000000000 3f58c4a653983a7c
+pow 400947c61651aa57 c03e000000000000 3cd266684354f2f7
+pow 3ffb9ee6867ccf03 402c000000000000 40a04ecfc38d9f72
+pow 3ffb89c0a7c6201c c03d400000000000 3e80fe085a3b53a3
+pow 3ffaa43eb37e95ce c038000000000000 3ed45406364285b6
+pow 4005d50543d8f57a 402ec00000000000 4153470400d6e430
+pow 3ffaad952d7ccf05 0 3ff0000000000000
+pow 3ff872d7ad8bb704 c03c400000000000 3eda5b063244d842
+pow 40067d92f102c7a8 4041800000000000 43324c32e1668a87
+pow 3ff9bc073c39fed2 c036800000000000 3ef7ce8a7d41a059
+pow 3ffa8be91d646baa 403e000000000000 414e23737a41b550
+pow 4004e12365efb251 c003000000000000 3fba3a12bf8ec2a9
+pow 4001fbd3e7f28da6 c018000000000000 3f7fbdc877eb3e18
+pow 40005cd82003fb14 c014000000000000 3f9c9b7fbdd08d8b
+pow 3ff34df2c5d02b9c 4033000000000000 4041b58868bcb361
+pow 3ff454dcba9c6b0d 403ae00000000000 40838d1f2f388870
+pow 400844d2c3d9aee9 0 3ff0000000000000
+pow 4006b33a52c249e8 4023800000000000 40d9758f48bd455b
+pow 400a9d84e03b3a0b c03f000000000000 3c92e64c0e4c442e
+pow 4001507f62541347 403d000000000000 41f3be08e0db74d7
+pow 3ff1a9e38f39654c c031000000000000 3fc7d135088d1f9a
+pow 40048acdac362326 c042200000000000 3cd9a7c98cb58685
+pow 400064f6b1da9d80 4032000000000000 4118cd22ce7386e1
+pow 40055244f8d97b73 c039800000000000 3daea2fe6422f4f7
+pow 4002e0ea900135a2 4043800000000000 42f3d066935f284a
+pow 4008901b4bdcde83 c043900000000000 3bf9a10bbab0f621
+pow 40099a8037355e28 4035000000000000 4222f1ae68025437
+pow 400478dfdc46f346 4038600000000000 42007a9b60fb1eb0
+pow 3fe673c2961e58a8 c03d000000000000 40dc59841956fe50
+pow 3fef51381ebd1320 4016000000000000 3fec6bb81b6c4ae7
+pow 40089c4a06df8cd9 4041000000000000 436165fac9ec336e
+pow 4008539f7d4895b8 4040400000000000 4331b184785e78da
+pow 4007c6e14039a8dc 402c000000000000 415002548e3c23f5
+pow 40002cb1aa56ac5f 402e800000000000 40e673b17eb9b278
+pow 3ff8f84c82ceb39d 4042000000000000 416157d4f171c66a
+pow 3feb84557e93861e c020000000000000 400ac29f3ae54aa4
+pow 4002b1fd7979413e bff0000000000000 3fdb62f840bb08bf
+pow 3ff99c83142f5be4 4042300000000000 4179c7abdb0d668a
+pow 3fed092347b0299e c035000000000000 401ece4aededacef
+pow 40081cac5790c4aa 4003000000000000 402b7a88e3334d84
+pow 3ffc221c5c035e9e 4024000000000000 4071a7cad1f4cc3b
+pow 4004a4b3c0eef500 4039a00000000000 42208186b5676e6a
+pow 4005782267e89c42 c043000000000000 3c8d73f4c8e5c900
+pow 3ff6cbaa289dcae2 c03ca00000000000 3f04d8c2b263c059
+pow 3ff59c8b18109db8 4000000000000000 3ffd30e8bc3a144b
+pow 400245f7a06308bb c021400000000000 3f4a63a80b376eb9
+pow 3ffcabf0d380a14f 4041800000000000 41c5ec2cee3d9643
+pow 3fe4a4964d869b2a 4030200000000000 3f4be62c92e8a2f9
+pow 3fed24a088792d66 403e000000000000 3faef651ddf146ea
+pow 3fe4213f9df7ea4f c007000000000000 400e5421d42c16c5
+pow 3ffb841cbccd390b c01c000000000000 3f97042cf27a90de
+pow 40002a7c1c739796 403fe00000000000 41f462de69d2ec31
+pow 3fe6fc45ec9a061a 3ff0000000000000 3fe6fc45ec9a061a
+pow 3fedd1d07e6b6f09 3ff6000000000000 3fed0a718d6612fc
+pow 3ff984fb9600656b 403f000000000000 413d6e92206a7e8e
+pow 40065f4a6f5a6f3a c02fc00000000000 3e75d0afaff8cd3e
+pow 400949c51c9dadfa c02c000000000000 3e7afe4f2dd337c8
+pow 400760224b3d4d92 402a400000000000 4133beb6b7f15322
+pow 4000e2d6970eac73 c008000000000000 3fbb38e0a679e808
+pow 400593d157f00c20 c03a200000000000 3d984ee363367c98
+pow 3fea194ddab31010 4010000000000000 3fdc51737ccc4249
+pow 40057ec4150329aa 4038c00000000000 4223970aa919e088
+pow 4003ffcdcb048516 c008000000000000 3fb062c938da7d3a
+pow 40055afd8e66f3c6 c036000000000000 3dfc915744913a49
+pow 40000f416c40b6cc 403c000000000000 41b1c157d21a376b
+pow 3feb3f8cceea5613 c02e800000000000 4027357c8c908266
+pow 400504c171de92c1 4022000000000000 40b74d21167eb850
+pow 4005a9c5e90aabf8 c036a00000000000 3de660966b896ab3
+pow 3ff7282e4376aa68 c02e000000000000 3f6ffc8fbbb346c9
+pow 4005aeaabcc95aea 4020000000000000 40a6bf10f4f3a3be
+pow 3ff3480fbda3d6b0 c026000000000000 3fc0716dd4fe4c4d
+pow 4007722781ef6c14 c032400000000000 3e29cd598df6c052
+pow 40036e15f1460e3b 402e000000000000 41226ba143b4da43
+pow 3fea44bb4d761754 c018000000000000 400a24fc340c1e57
+pow 3fe80b04327a31b0 4014000000000000 3fcea5f6ac8f4fc6
+pow 3ff1b4eb6d215d24 c03e800000000000 3fa7440e41774eba
+pow 400b8819101382ed c022000000000000 3eeef884f70cc6d5
+pow 4001c53f7496c68a c040900000000000 3d8d07a6163f51e4
+pow 400bb56bd7e36672 c044000000000000 3b73d39a53245936
+pow 40006bc2b5f00e59 c004000000000000 3fc534801f13a453
+pow 3ff7c76da0d55824 401c000000000000 403003bfd81af49c
+pow 400b9498e038e6a1 c040400000000000 3c4f50e6ad1c03f2
+pow 400a06688abfcda9 c03d000000000000 3cd90de631243e3d
+pow 3fe00530dc2f4115 4037600000000000 3e796ab2edb08199
+pow 3ff3ec2b03c9a768 c043800000000000 3f29563d4a360f9f
+pow 3febe0c5626f73ec c041500000000000 405d9e6d2b51f3b5
+pow 3ff7ae8833c568ab c020000000000000 3fa63a96800c093e
+pow 3ffd41803bcd9df8 c026400000000000 3f53e3daf840b56c
+pow 40065867f08376b5 4031000000000000 4182481fd6ca7f75
+pow 4004571abce3dd01 4039c00000000000 42196485bf645b57
+pow 3fe00cbfdb75b952 c043000000000000 424c6f7d739f4de8
+pow 3fede770c2867aa3 4030e00000000000 3fd4677fa8f960d4
+pow 3ffb3212f02f51ef c03e000000000000 3e8075f2f29513f2
+pow 40086584be9e233f c041000000000000 3c83ccba85851f21
+pow 40017713b0dba75a c02e000000000000 3ee131de45e8fe84
+pow 40053ef7598d0b37 402fc00000000000 4154ac7b0ac16128
+pow 4001b6780a0ecbea c043000000000000 3d357a1cffa47d8d
+pow 400bd56d9b42bb44 c009000000000000 3f94ce2142fb7ddc
+pow 3fe78ef4e513096c 4043800000000000 3edb425ef5bb563a
+pow 3ff8923c2a92f5f7 c03aa00000000000 3ee6f8f502bb8ec0
+pow 3ff2e2b320144644 403f000000000000 4065573065ca2250
+pow 4006bf7ec762ca3a 4031000000000000 4188c48280968464
+pow 4009878766b690df c01c000000000000 3f33721bd7d2a370
+pow 4005973e6b851b67 4042300000000000 43312aa6829d3137
+pow 400220bdac22149c c042800000000000 3d342e08190e93bc
+pow 40091a4269062114 403fe00000000000 4338055288d28675
+pow 3ff2f6f1e976a626 c03a000000000000 3f88a78e6edc5884
+pow 40099969f9ad0d40 c00f000000000000 3f86971c66a7723a
+pow 3ff0bd72f6f38460 4037000000000000 4006a1d8969ea7c2
+pow 3fffa67d1383fe88 4012000000000000 403589312bfb1f1e
+pow 3ffda9cd35f357ba 4000000000000000 400b7f48f676e4e9
+pow 4007699a5442e508 c025000000000000 3eea996e20b22550
+pow 4001c91781a91090 4033000000000000 414ddb54f0a72440
+pow 3ff77d5b8d0271fd 403d200000000000 40f18e7c9c60b8b1
+pow 400063e89911353e 403f000000000000 41f0e2eddd3ecd75
+pow 3fe04f91ba0cf3b9 c023000000000000 4082d8fa881010f1
+pow 400642e33dddd08e c032000000000000 3e4575fb6ba59d2d
+pow 4001b601a478d99c 402c800000000000 40f43ba0b87fbbb6
+pow 3ff1e908e243a36a 4037000000000000 402ac4db078d1c11
+pow 400b7bd048667f33 c043500000000000 3ba2bdb39e2b3c20
+pow 4005c4f4e458d43b c010000000000000 3f92acfb52eaf7dc
+pow 4006e7e354fb8bcb c040500000000000 3cd66c65e94dc142
+pow 40054c6e4e4b0229 403e000000000000 4294d433d3186bae
+pow 3ffba9c5279f0a49 4040400000000000 41897c1b7794bfda
+pow 3ffc8ee539ffc3be c03b000000000000 3e8597efa80899bd
+pow 3ff1995020e8f41b 4041000000000000 40397e0dd4bcaa55
+pow 3fe6ba78037897e2 4040800000000000 3eea357c15ee2e99
+pow 3fec41baeac596e8 c00e000000000000 3ff982c21436bfcf
+pow 3ff9bccd14ff5a9a c035000000000000 3f08389c409ffec4
+pow 400286753dd0bf24 c035e00000000000 3e46a16f781bc185
+pow 3fe0f0fc9ebe1fe7 c038000000000000 41503abe832fecd1
+pow 40077b2870d1ace4 4027c00000000000 4115cf7a3cec11e6
+pow 400785b84a14a584 c040800000000000 3cb92a235a021939
+pow 4002b66ca829a748 4036a00000000000 41aaaa15103b1984
+pow 3ff5555447b3ebd3 c034000000000000 3f69fa9d1900d6bc
+pow 3fe15b21ca3cbd70 c027c00000000000 409656286c07537f
+pow 4000b55698365054 4041000000000000 423172773963764b
+pow 3ffe1621967d19e0 c036a00000000000 3ea4eeba99d556eb
+pow 3ff6348fa836f042 0 3ff0000000000000
+pow 3ffe33aa54ab8989 4041200000000000 41e4ffee9cc3d3a4
+pow 4009b23b20a1f783 bff0000000000000 3fd3ecd4407b4482
+pow 4006800e269e5055 4011800000000000 40570db656baa02d
+pow 3ffb81c6f7e78586 c044000000000000 3dfa8eb59b75c27c
+pow 3fefb73b7b203f82 c043d00000000000 3ff6c92f7d0f968f
+pow 40053eb33ef10d28 4018000000000000 4075ebe9e24a920f
+pow 4005d2c5cf9a61c8 c03de00000000000 3d3ada475ef7a40a
+pow 3ff704375f7f2e22 4043000000000000 412e94ebb3c5a78e
+pow 3ffed9cdcbf1b3d2 4018000000000000 4049b1ea9fea306f
+pow 3febc4351a9bb095 4020000000000000 3fd490ca7f97013f
+pow 4006f225e4383f23 c041800000000000 3c9bbf3fcea9ed6b
+pow 3fefd250f1891bfc c01c000000000000 3ff0a38541944c86
+pow 4007972bc67530a4 c03d800000000000 3d0f78fa7975ba90
+pow 40019defefa93e94 c043800000000000 3d27f89bc7e7f3bb
+pow 3fe16d584c711b23 c037800000000000 41384eadcc44e08a
+pow 40097c1e34651845 401c000000000000 40aa02728ade7bce
+pow 3ffed598a65d9793 403fe00000000000 41d1fbe2b7687039
+pow 3ff883d735845f2e 4032000000000000 40a0eb91caa6a5d7
+pow 3ffb5fb0dcdddfbe c035000000000000 3eea8d97b6b1e6d9
+pow 3fec1f7ca44f407a 4035000000000000 3fb0ff58697036aa
+pow 40032ef9bbb35fc7 c03f400000000000 3d77bc24a1b5ceca
+pow 400a0d6de672d89b 4043000000000000 43fa7ca78810bf46
+pow 3ffa486adb7d538d c018800000000000 3fa87db78afe4844
+pow 400993a345f593bc c03d000000000000 3ce4bc27b82af45a
+pow 3feebedd9eec5aed 4010000000000000 3feb450a74ca564b
+pow 3ffe9feab90569b9 c026000000000000 3f49f0d815b6dc3b
+pow 3ffb84bed6568d42 c03e400000000000 3e742cac1cb8971c
+pow 3ff76b77bb83d091 4035000000000000 40a74efe29c22840
+pow 4007dca6e0b6a3dc 4026c00000000000 410e9317a45790b4
+pow 40014f9d3bb2983d 403d000000000000 41f3a0e7b249299b
+pow 4007079c9644c154 c043400000000000 3c434ec7f2c53da4
+pow 3fff17e74cb85b49 4042000000000000 4216bde00f768a7c
+pow 40041f7e7551d98f 4009000000000000 4031dc32e3226edb
+pow 400a4f3bee30ca69 4040000000000000 435f222d4ebdc2be
+pow 3fea8ad3499c0f02 401c800000000000 3fd0e30467067fd9
+pow 3ff0195173f33312 c018000000000000 3feed6a5dc978f98
+pow 3ffffc004e6ce1a9 c001000000000000 3fcd5fe530852c9f
+pow 3ff32207ee858ef3 c026000000000000 3fc1e73d51921868
+pow 3ff8d3ae8d1b88df c036400000000000 3f0dcce1e07e4bce
+pow 3fe97148b043cc58 4043000000000000 3f25884b8b0cd5ef
+pow 4009e3e850cb906a 4042a00000000000 43e1510aa07ac5a4
+pow 400552cad5dc2a2a c02e000000000000 3e9b8f61df85c56b
+pow 3ff481e7b21c6d73 c036400000000000 3f705e3dafea3d9a
+pow 3fec67dc97cba712 4036000000000000 3fb29d7519a1f523
+pow 3ff302e50ed72740 4043800000000000 408a0a32e90b39fe
+pow 3fe4e510905a7580 c043800000000000 416f9bbc2b225787
+pow 400506b368e43e84 c03c600000000000 3d75bc5c79f9e7f4
+pow 3ffc728726615421 c010000000000000 3fb99e4c0ed05ce8
+pow 3ff1c797057a9474 c027400000000000 3fd2c7ed9fed1457
+pow 40007718356a6a5a 4000000000000000 4010f1a6e3140494
+pow 400877ce363eedae c043700000000000 3c03b7f029f86fc6
+pow 4003e7379d3490c4 bff0000000000000 3fd9b979e9bae704
+pow 400102734d418c0a c03ea00000000000 3dd97c2d9dd97ec7
+pow 4008d71f66330da6 403a000000000000 4296a0447ccb5739
+pow 3ffd7628555205ca c00a000000000000 3fc199aaae7c5e6a
+pow 40018c820d334483 4014000000000000 4049655d4b0e1180
+pow 3ff99998d3ca1d3c 402a800000000000 407fa824a41792c8
+pow 3ff01ce9e704a42c 3ff0000000000000 3ff01ce9e704a42c
+pow 4009fd8bd627c247 4030600000000000 41ac8fb1396dc3f9
+pow 4003b5a7abd8e8a7 402e000000000000 4126d2921e768bd2
+pow 3feb32cd0b023cec 4032c00000000000 3fa849f66ce609f9
+pow 40023510419e9587 4018000000000000 40615f22bde63d43
+pow 3fe6d9c8bbd8a0da c023400000000000 403990d00dc15834
+pow 3ffe79a29f82a213 402a000000000000 40b0f6712177c161
+pow 3ff71d0d96bd4416 c018000000000000 3fbc2b302a0ee3c7
+pow 40058dd0b468798b c034000000000000 3e25259850d9ea81
+pow 400680785f740c5c c025000000000000 3ef42c1deb81e8a6
+pow 3ffe09373047f62a c028000000000000 3f411b80c4e7beda
+pow 3fe23fd49432da46 4040500000000000 3e47b11b72cd9587
+pow 40026addf17ade7a c032000000000000 3e94560ee38b2665
+pow 3fe69581d7f00000 403e600000000000 3efa82100f0d5c5d
+pow 3fe1d55e3c9ab235 c02a000000000000 409f3d4ef3f0f73e
+pow 3fe46d5b2d1d817b 4037c00000000000 3ef896af443345c3
+pow 3ff3974b71528983 402e000000000000 4034d8e1cd244ae3
+pow 4000ce6161bedb01 403be00000000000 41cce0a87df0cfbf
+pow 4007adec9bc5fd79 c036000000000000 3dc78ce4ce0637ae
+pow 4003db15ab45e142 bfe8000000000000 3fe02ec7c137e54a
+pow 3fe58c2177a67cbd c031000000000000 4089fbaf5a099096
+pow 3fe4f70b7e225610 402fc00000000000 3f53e6f74ee7ea02
+pow 3ffae1ae11153842 402a000000000000 408a8ee6ea5f047a
+pow 3fedab6fbd847cb2 c012000000000000 3ff67c16607b9ba6
+pow 3ffe5df7636848f6 403b000000000000 417f1e9a7791c0ff
+pow 3ff742c66686e528 c03e200000000000 3eeaad9644ed364b
+pow 3fea5976d63ddd96 402a000000000000 3fb47ad0e17039f8
+pow 3ff92b8f357d8a63 4040300000000000 4141e5b0a28f88de
+pow 400b8a62553df9a9 4008000000000000 404466426e518eab
+pow 400a0cdab9a7b22e 4041c00000000000 43b61386be200ba3
+pow 400bab9d38325091 0 3ff0000000000000
+pow 3fe396e59a7b0dc5 c033c00000000000 40cf9f8e97be42dc
+pow 400b077c9eb437d2 4040000000000000 437275ea9a127241
+pow 4000b801e996d2a9 c030c00000000000 3ed23a630aecdece
+pow 3ffe95677596c798 403b000000000000 4182d9c53c07691e
+pow 4006c92da0b85a57 c037200000000000 3dc0e8afb3292137
+pow 3ffb2c7db04325aa 4043000000000000 41c06bc94ad19d7a
+pow 3ff4dec24baed72c c032c00000000000 3f7c16413672346f
+pow 4002822ed418d454 4031000000000000 4137c9150e406c94
+pow 3ff683f1cdcae07c 4038200000000000 40ada5778fc88b39
+atan2 c00ff87edec2ae32 3fd1db6f30a60f8a bff80477eccabd75
+atan2 beec4b782fe9e979 400c43f89909ea12 bed0043e9ab9725a
+atan2 3ea7b4ea46328332 bf3fcee56f6f8415 40091f00240311bc
+atan2 3fcefa1ce4cc0250 40ae4df3524f54bd 3f105ae5b881edf4
+atan2 3f1fb4bfae4c22c9 c061d2af36bc5f8d 400921fae269ff94
+atan2 c0b37433ddd34a8d bf99f2a988148dca bff92200aa176c35
+atan2 4046aa58ac8ccd1a bf020457c1d33b90 3ff921fc1fc364d1
+atan2 bfd1b20964c5a662 3fdf7a96ef763228 bfe0633d407f36d7
+atan2 3f2514ca7596d981 3f32144932764bc7 3fe0e41628055b41
+atan2 bfd3d5e75e802930 c0111a28a880310c c0088dc87ff945d2
+atan2 40af9751b31890be bf8660a7d6bd49f4 3ff921fe299dfab3
+atan2 3ffa5ed46db398c6 403c66a77973a46e 3fadadc8168c1c56
+atan2 c037b27b1ea6ed1d bff1808a7f58f336 bff9deec22949a9c
+atan2 3f2dc953e77a0025 c0b3866c3cc7bd9d 400921fb4e2a0429
+atan2 beb75d1f1008e0dd 40070b41c7304062 bea038d72936a857
+atan2 bf3558cdd0fdce00 c04a16c4b8c6ab05 c00921f80e64b4f3
+atan2 bfdefc7f3e5d2b7a 400bb86ab7a3f496 bfc1c52071150099
+atan2 3f3e38728139d4f4 bfb3f413966f3888 400915dd901d2480
+atan2 4012ab84546097f0 400d950b50ccefbc 3fecd365b908e281
+atan2 bfd4bbd2b3d39cd1 3ffe86ad35f0a6ea bfc58789124cfb30
+atan2 4092523c4c071136 bec5862da8877576 3ff921fb54da8d91
+atan2 bf9346847329e464 40462e1478a20eba bf3bcf3b2f036eaa
+atan2 400f473a7b746a12 bf40068c4ed35e0f 3ff9227e7e00299d
+atan2 bf96a27124afc684 bf3ea386c0d92113 bff97899e2a6aa46
+atan2 3ed3b11a586371f5 3f19ce96d33596b8 3fa8661ae5a5778f
+atan2 c004c7be3e7f3671 bf7060fd06c19ea4 bff928498c7932d6
+atan2 4002cc1460ebedaf c0002195af90f045 40023d7858979902
+atan2 bf3ac7bbf00dfabb bed27ace8cd713c6 bff94e24b02e6256
+atan2 bfc32fadbe7ab49c 407ca1cbdb9c5800 bf357170679e5300
+atan2 c0426099182c1661 3e8ef06a7c528c6a bff921fb5295301a
+atan2 c069473aeb75f9d6 4001a3f0ab4d5d4a bff8f5523a4d05de
+atan2 c04400ca65c223a6 40037aef20a12dfa bff828fb117f091d
+atan2 bf83930ecce8f737 402f8bde8ca32ff8 bf43db1db1e7b33b
+atan2 bf733ba3652a1424 bf3ad423d0b83833 bffa862f037bd346
+atan2 3eca5a49921759eb 3fffe9546af2fedc 3eba6d023535f2e6
+atan2 beccba8878f33acd c0761d0d6c04707b c00921fb52f79844
+atan2 3ecabdebb85c2e88 c0054cf048c086fc 400921fab3916a90
+atan2 c0548b3f447abc08 3fc954c203e279e8 bff9181e1bd4818e
+atan2 bf714a2105cff93a 3fa9581ec667ae80 bfb5c702e4611517
+atan2 c045eee3febe7ec8 4001a7fc2d49c3dd bff854135186f1db
+atan2 400bbb508c812f9b bf42c05de0a81761 3ff922a86df4de5e
+atan2 c064911ff5960af0 40813755a08dc0a7 bfd2930892b44860
+atan2 4044b311765a2b00 c0aea039962a1516 40090c5ab552971c
+atan2 3eceb73489911e58 3fdf9e7ed08e7d28 3edf15ec7ce10d76
+atan2 3fdb09ea18774cf0 400185f5cdac2498 3fc863878bc34ad1
+atan2 bf30f509d2310479 bf67fa9512332baa c0086d6a3432de99
+atan2 3f14a51d994fc687 c0aab7465a5c2617 400921fb512cdeca
+atan2 c04227ebb0192cc8 c0ad95312d400f47 c0090e57c79155d8
+atan2 bfde83a4d00e2c4e bec86ca4ddaf4ce5 bff92201bb8a00fe
+atan2 c071cae0939e8c93 bfddcc0a28f904e6 bff928ae37ab57c8
+atan2 4060613858c54c39 3f9592118273210a 3ff92152c3f4b489
+atan2 bfe16105046da2d8 c052a9552be9e139 c0091314e2e31d73
+atan2 c017e2d3c26501d1 bee6c5e9c3de0b2d bff921fd3c690316
+atan2 bf959f1999557c9f 4078659b68ea5487 bf0c5c11b2e77f99
+atan2 4030e7f2cf5b6e54 c0a386f78b717c59 4009142131f7d0a3
+atan2 3fa42f48d6b5c61a 3eb2ef23bfaebcc9 3ff921dd4fcf920e
+atan2 beb83e79f014bb7a bf08a0e1641497e0 c008e30020fc19be
+atan2 3efbdaf509ea5fc9 c01447920fb6b05f 400921f89500535d
+atan2 bf941db3186d5194 3fdc7a719e9c171c bfa696c541c54d56
+atan2 3ed0c2f0e87ca035 bed1ce7d76f681e8 40031762b7b97157
+atan2 3f0752899c0b5180 3ed19260b888bde4 3ff7a15c4552ed92
+atan2 3f709af0645fbb09 bed48a96f98758df 3ff926ee0f39303c
+atan2 406a3d5a9a7397b5 bf99946e51fbd562 3ff922781c3db645
+atan2 3fc9e0433ec2aa10 3f8c80259b708507 3ff80875db5cb645
+atan2 bf03bb67cbfce408 c04476259d342bca c00921fad8d45d6e
+atan2 c03fcbd6bd11c631 bed30d72d1be9b44 bff921fb7a9d9578
+atan2 c03eca4f3dd0c814 3fd5e82694a9c666 bff8f472d3c688b5
+atan2 409ece312a823f92 bfddc29cd8654a14 3ff922f2a49f0fb5
+atan2 bf9249b22f474cb2 3f706df6841c57b5 bff5990d72fc4d0a
+atan2 3fdf18420a431f9c becafb84eeb52fd8 3ff92202456b71dd
+atan2 c0a33e4361739c1e 3ec6c2fe52119ebb bff921fb53f87967
+atan2 c08db2e82eb693b5 3f5f6482ea884e15 bff921f93710f4dc
+atan2 3fd60ff8458cb224 3f860ef4d3a340c0 3ff8a20bdd187edf
+atan2 bef57b057e04ae06 3fdc7c383cba60a0 bf08218a6a3071a9
+atan2 c039bce4fc364bd1 3fe5c742dca5e3c0 bff8b5b2ce888cf6
+atan2 403ed2aad2e0ce79 bf2c1f2c0ab9b90c 3ff92202a0ca6c16
+atan2 bf09f3c2bccc9395 bf73649f3a2ef430 c0090c922d1d0980
+atan2 bf06e173c11fadb1 c0349b15aa7988ad c00921fa38010634
+atan2 40a89b7b4e2a7802 3eea755a511f6d57 3ff921fb5330eb3a
+atan2 3efafaa1016d8725 c048f0f62ae45f52 400921fb0f098ff7
+atan2 bfee1e528b6f96bc bfda7d0497f5bdae bfffc2e5a4764d4b
+atan2 bfa2b5ef4560a037 bfdef6ca04473c34 c0088794d56b3a0c
+atan2 bed3a75bf40d7cce bf71a429d57e7e43 c0091fc0ebddd3ed
+atan2 c093ec2ef9f1934d 3ee21f5595cc4fdf bff921fb527270ac
+atan2 3eb8429bc4d2e2a2 3eb497ea0981d6f6 3febbe30c0d8d843
+atan2 c003501efdb5fa96 bf74ce637420d700 bff92a99ac1b85c9
+atan2 bf266006ee56952b c022b86f4b11f649 c00921f1c47339dd
+atan2 40713ade34e29b4c bf8e9cea4618f6d4 3ff922342f3a0590
+atan2 40ab4164158d1790 c0283e6d82c4eb86 3ff93036baa773ad
+atan2 c0ae918ebb8261cd 3f62cf9d3cb31d9f bff921fab6bb47d8
+atan2 bf71e55eb580a383 bfe217064beacb65 c009122753ee75d5
+atan2 bf2c18626c2e113a 403ae7938be1a547 bee0b5447d767626
+atan2 4042393568ca319f 3fdd62b810e50770 3ff8ee624e0968d9
+atan2 c0041c90374ef479 bf6b6f5f202c17ce bff9277035b31df0
+atan2 3fd69debab44c990 bf35dcc3fa0ec5b3 3ff925d92aeafd00
+atan2 3ebb2e21de778371 bfc4d1302f6e36e2 400921f61b440a68
+atan2 4032af7ab931ae99 c00d86794bed292f 3ffc40b8f40791dd
+atan2 3f3b4109f76f8a19 c05643b3d8303c4e 400921f8e1862e23
+atan2 bf2af9a46b6ac62f 40754bb5ebc26a50 bea4445f9aca0695
+atan2 bef7b1f383e1a78c bec2108128e42ce6 bffaa723f43fd520
+atan2 bed493bc49535656 3f93d244dbfa099d bf309c2b0132050c
+atan2 40a3e681784a78bf bf0582ac030c3b8e 3ff921fb5897059b
+atan2 3ff4e2f28156d441 bed00cf19422d9f1 3ff921fe672cc11e
+atan2 bfaf8016cda9f3e8 c010c6383c4dd837 c00903f007039918
+atan2 3ef7452b8569761f 40096cb1c4b83644 3edd49d68b5487a7
+atan2 3ed23466d801d20a 3fc786393f3bbcd8 3ef8c38549325c6c
+atan2 401070662f27b7ea 4043be564a01c3fd 3fba8c71fff2d2d6
+atan2 40ade0cac2f7aef4 3f524f146a72de9a 3ff921fb05d45fcc
+atan2 3f32b78f7de4ccdd 3ec88908fe8731ec 3ff8f80930c64ec7
+atan2 3f4317712a4f60ae bf31d0cb3534eaf8 40000f0ffaefddd6
+atan2 3f9e8d386d7fc394 4010065fdb903a54 3f7e80ec50fa1d2e
+atan2 3eedaf005b9d682b 40005d63fed543e9 3edd059a6930c008
+atan2 3ee73bd33996435b bf84271c41af1c7a 40091fad0e4c7aa1
+atan2 c07a39f8536a49dd bfd2d721ac560cc8 bff924daf147ba3f
+atan2 c075d272fa6c4cfb c0562de3f7578452 bffd1d2ca667c474
+atan2 c006f8fd2b171dc8 bf6fe433e182c399 bff92788e1dffb2e
+atan2 3fc5271d727f4c40 409d9ffd353951ca 3f16d93f1f48d0ad
+atan2 3fa42d2f09196ed2 bf86e5a6da082d27 3ffd8e4d5d02498b
+atan2 3f9e679a5880a070 406afaf606ddc228 3f2207ded564bcb3
+atan2 40b0fdb62000291e 40127fed22b93ad3 3ff91da0685dd7df
+atan2 c0ab40b4a3aae4eb 3fa58bd47560ecc4 bff921eeadf10258
+atan2 bee2c085c3977190 405f3864c04a4adf be733869d5427c33
+atan2 403636a0e206e8dd 3f639a56de860303 3ff9218a5f24505b
+atan2 3f25836db7801f96 bfd38ae32537dc46 400920e182f758bd
+atan2 3f7236829af3cb7b c0823968f25a8624 400921f754e71c67
+atan2 c06d9d31631f665e 40aae0b9ec643d47 bfb199dd57fdcf5e
+atan2 40053013f5f5de8a bf2a04391d6b5104 3ff92249ea2c5198
+atan2 3ebaa459698d8721 c0b33d29077108be 400921fb54391907
+atan2 c034de7ca1ae9ab2 4041a390184f64c7 bfe1181c8ccde40a
+atan2 3f32f83685a9e9a4 c0a4944bd7218119 400921fb45849024
+atan2 c00343c90fc6f664 3fd77e3d1a7387a6 bff6b6600d49bd00
+atan2 40b14eddd2afc328 404021a1d63597d2 3ff9042866917680
+atan2 4018ad7df90a92ee c0b0cf44478747eb 40091f0badab7c93
+atan2 bf32cb524b0caccf 3f5a3f02daa1ee43 bfc6ac9b2a94a447
+atan2 bf3bfee48b43aac3 40a0b343d22e3030 be8ad2613a3a6f10
+atan2 c020cf749ca0152d bfc98da268e43f54 bff9833fc82f78d3
+atan2 3ecbcdff31ed93a5 bf5da5328bb5bdc5 40091e3ae89fd0fe
+atan2 3ea59bc36cf7e0ff bf575a7d6609089a 4009210e75453f19
+atan2 404a48a54b1a737d 4045c2299b90a95e 3fec235ae381d087
+atan2 3f090cb681dee58e 3f90765f6715f40d 3f68589343b7fad5
+atan2 bf3963e026b24953 3ea79712554eafb8 bff91a8c85d1c167
+atan2 3fc52c3cc5c99b68 bf73ebd19146511f 3ff99a615c33b65b
+atan2 3f2d79316f3d6e7b 3eb1fb2635c883da 3ff90e759d9e6c9f
+atan2 3febcbc22b056cdc 3ff34553c6f70ff4 3fe3fe6d77b515ae
+atan2 c09b77fd60a37b41 c01207bcc4c93a9e bff92c7be6fe5157
+atan2 bf5bcd3df7c2f52e 3f303a74528cea19 bff6d071f7bda487
+atan2 c0a4808584d72d25 bfd219022337d6ae bff9226c51719574
+atan2 bff97ba79a34552a 3fa8ded4987de905 bff8a518f5be5ed0
+atan2 c0124f6be852fbb6 3fee2baf782ba6e4 bff5e1f87008becc
+atan2 3efb89bc864b26d6 40125be274f2e484 3ed7ffebd0b200d5
+atan2 7ff0000000000000 fff0000000000000 4002d97c7f3321d2
+atan2 fff0000000000000 fff0000000000000 c002d97c7f3321d2

src/query/src/options.rs

@@ -110,6 +110,9 @@ pub struct QueryOptions {
     /// - `fair`: Fair divides memory available after unspillable reservations
     ///   evenly among spillable reservations and may trigger earlier spills.
     pub experimental_memory_pool_policy: QueryMemoryPoolPolicy,
+    /// Enables the experimental native PromQL execution path for compatible
+    /// instant queries over shared Metric raw series. Default: `false`.
+    pub experimental_native_promql: bool,
 }
 
 #[allow(clippy::derivable_impls)]
@@ -125,6 +128,7 @@ impl Default for QueryOptions {
             experimental_spill_max_temp_directory_size: ReadableSize::gb(1),
             experimental_spill_compression: QuerySpillCompression::Uncompressed,
             experimental_memory_pool_policy: QueryMemoryPoolPolicy::Greedy,
+            experimental_native_promql: false,
         }
     }
 }

tests-integration/tests/http.rs

@@ -3512,6 +3512,7 @@ experimental_spill_mode = "default"
 experimental_spill_max_temp_directory_size = "1GiB"
 experimental_spill_compression = "uncompressed"
 experimental_memory_pool_policy = "greedy"
+experimental_native_promql = false
 
 [memory]
 enable_heap_profiling = true

tests/compatibility/wire/raw_series_ordering/README.md

@@ -0,0 +1,19 @@
+# Raw-series ordering schema metadata compatibility
+
+`v1_metadata.json` is a hand-authored, frozen set of Arrow schema metadata maps
+for the v1 raw-series frame. It records the established layout/content/labels/
+time metadata and the new optional ordering entry. The Rust unit test parses
+these literal maps through `raw_series_frame_ordering`; the fixture is not
+produced by the schema builder.
+
+Run the focused check:
+
+```shell
+cargo nextest run -p common-query -E 'test(raw_series_ordering_metadata_fixture)'
+```
+
+The fixture proves that absent ordering metadata defaults to `Contiguous`, the
+two known values decode, and an unknown value is rejected. It does not prove
+interoperability with an old binary, nor does it test an end-to-end client or
+service. Separate pack/IPC tests check the declared ordering schema and batch
+schema agreement for both orderings, including empty streams.

tests/compatibility/wire/raw_series_ordering/v1_metadata.json

@@ -0,0 +1,45 @@
+[
+  {
+    "name": "missing_defaults_to_contiguous",
+    "metadata": {
+      "greptime.series.layout": "v1",
+      "greptime.series.content": "raw",
+      "greptime.series.labels": "explicit",
+      "greptime.series.time": "timestamps"
+    },
+    "ordering": "contiguous"
+  },
+  {
+    "name": "known_contiguous",
+    "metadata": {
+      "greptime.series.layout": "v1",
+      "greptime.series.content": "raw",
+      "greptime.series.labels": "explicit",
+      "greptime.series.time": "timestamps",
+      "greptime.series.ordering": "contiguous"
+    },
+    "ordering": "contiguous"
+  },
+  {
+    "name": "known_read_key_then_time",
+    "metadata": {
+      "greptime.series.layout": "v1",
+      "greptime.series.content": "raw",
+      "greptime.series.labels": "explicit",
+      "greptime.series.time": "timestamps",
+      "greptime.series.ordering": "read_key_then_time"
+    },
+    "ordering": "read_key_then_time"
+  },
+  {
+    "name": "unknown_ordering_rejected",
+    "metadata": {
+      "greptime.series.layout": "v1",
+      "greptime.series.content": "raw",
+      "greptime.series.labels": "explicit",
+      "greptime.series.time": "timestamps",
+      "greptime.series.ordering": "future_value"
+    },
+    "ordering": null
+  }
+]