From 504db74a2e3ec099cb22891e72e0834f19bf9a4c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 11:54:56 -0800 Subject: [PATCH 1/4] chore(quest): claim quest/m1/audio-jitter-target/grading.md Quest-Claim: 758433f7b4eba31e From 21316db972e1eda41aca333aad0abd2c2630ced6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 12:25:27 -0800 Subject: [PATCH 2/4] test(audio-quality): grade lag and the player's own trims, add congestion rows Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 4 +- test/audio-quality/README.md | 72 +- test/audio-quality/clients/js/grade.ts | 3 +- .../clients/js/ptt-analyze.test.ts | 2 +- test/audio-quality/clients/js/ptt-analyze.ts | 2 +- .../clients/js/src/analyze.test.ts | 38 +- test/audio-quality/clients/js/src/analyze.ts | 81 +- test/audio-quality/clients/js/src/run.test.ts | 24 +- test/audio-quality/clients/js/src/schema.ts | 25 +- test/audio-quality/congestion.toml | 22 + test/audio-quality/run.sh | 12 +- .../audio-quality/traces/relay-mic-stall.json | 3280 +++++++++++++++++ test/justfile | 4 +- 13 files changed, 3435 insertions(+), 134 deletions(-) create mode 100644 test/audio-quality/congestion.toml create mode 100644 test/audio-quality/traces/relay-mic-stall.json diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 8537c9e2e1d..d8ed5cbd0cc 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -18,7 +18,7 @@ name: Nightly # the wheel builds in a manylinux container, the Kotlin/Swift/Go/Dart packages # link the FFI on every platform) and nothing notices until the tag is pushed. # -# `audio-quality` is here because of what it measures. It plays thirty-six rows of +# `audio-quality` is here because of what it measures. It plays twenty-eight rows of # audio in real time, a minute each, which no merge gate should carry, and every # number it grades is a timing one that moves with whatever else the runner is # doing. A per-PR arm would fail on unrelated load often enough to be ignored; @@ -456,7 +456,7 @@ jobs: runs-on: ubuntu-24.04-arm # Hosted `main` jobs write the Rust cache; see .github/actions/rust-cache. environment: ${{ github.ref == 'refs/heads/main' && 'cache-write' || '' }} - # Twenty-four rows at a minute each, plus the relay, CLI, and shaper built from source. + # Twenty-eight rows at a minute each, plus the relay, CLI, and shaper built from source. timeout-minutes: 90 steps: - name: Checkout diff --git a/test/audio-quality/README.md b/test/audio-quality/README.md index 2f321d831fc..31e2595447e 100644 --- a/test/audio-quality/README.md +++ b/test/audio-quality/README.md @@ -1,8 +1,9 @@ # Audio quality Plays a tone in headless Chromium and in the native `moq play` over a seeded, impaired UDP path and -grades what the listener would have heard: how often the ring ran dry, how much audio a re-anchor -threw away, how much of the run was silent, and where the playout delay settled. A regression in +grades what the listener would have heard: how often the ring ran dry, how much audio the player +threw away, how much of the run was silent, how far audio trailed the clock video plays from, and +where the playout delay settled. A regression in any of them fails a row against [`budgets.json`](budgets.json) instead of arriving as a bug report, and a divergence between the two players shows up as one failing where the other passes. @@ -18,8 +19,8 @@ just test audio-quality --profiles bursty --capture --out ~/runs/burst # keep ar just test audio-quality --replays # the replays only, in seconds ``` -The matrix is runtime x codec x profile: 12 browser rows and 12 [native rows](#native-rows), about 30 -minutes, plus 5 [replay rows](#traces) of recorded arrivals. `--profiles`, `--runtimes`, and `--codecs` take comma-separated +The matrix is runtime x codec x profile: 14 browser rows and 14 [native rows](#native-rows), about 35 +minutes, plus 6 [replay rows](#traces) of recorded arrivals. `--profiles`, `--runtimes`, and `--codecs` take comma-separated lists; `--seed` replays a given impairment. The table prints either way, and only `--enforce` (which the nightly job passes) turns a breach into a failed run. @@ -38,16 +39,25 @@ the nightly job passes) turns a breach into a failed run. | `wide` | 40 ms one way, 40 ms Gaussian sigma, in order | auto | | `bursty` | batches of seven datagrams, released within 160 ms | auto | | `step` | 5 ms one way, stepping to 60 ms at 30 s | auto | +| `congestion` | 1 Mbit/s down behind a 1 s queue, collapsing to 16 kbit/s from 25 s to 26.5 s | auto | | `fixed-250` | through the shaper, untreated | a fixed 250 ms | `fixed-250` is the control: every other row adapts, so without it the whole matrix could pass while a fixed preset regressed, and a fixed preset is what many viewers land on. Loss, reorder, and rate -limits stay off: the buffer's job is absorbing arrival spread, and congestion response would make a -failure hard to attribute. The `mild` and `wide` profiles preserve datagram order and share one path across the page's sessions. +limits stay off but for `congestion`: the buffer's job is absorbing arrival spread, and congestion +response would make a failure hard to attribute. The `mild` and `wide` profiles preserve datagram order and share one path across the page's sessions. `bursty` and `step` use the shaper's named profiles on that same shared path. The step is timed from shaper startup, before the page connects; the driver gives up on a row with no audio 20 s in, so the measured window starts before the step, and `--duration` must exceed 30 s so playback spans it. +`congestion` ([`congestion.toml`](congestion.toml)) is a queue that fills until it drops, as a +congested link's does, rather than random loss. The tone needs about 140 kbit/s, so for a second and +a half the queue holds its full second of wait and drops the rest, longer than any row's target. +When the rate returns, the transport delivers the backlog, the queue's and every retransmit. The +row grades the audio the player trimmed and reports how long audio took to return to the clock +(`recover_ms`). Like the step, the change is timed from shaper startup, and `--duration` must +exceed 30 s. + The AAC arm keeps ffmpeg's default PES packing, whose multi-frame bursts are the flush-span shape the reporter measured on the public relay (#3477). The source is a sine tone rather than a film, so a quiet quantum at the output is always a gap or a stall and never the soundtrack. @@ -163,8 +173,7 @@ separated presses have an identifiable onset. `summary.json` matches inputs, outputs, writes, and arrivals by media timestamp, so a late arrival is still attributed to its utterance. The command checks pipeline completeness and reports latency, -underruns, and stalls without gating them; the [audio grading](../../quest/m1/audio-jitter-target/grading.md) -judges those. It refuses missing encoder inputs, +underruns, and stalls without gating them, since zero underruns is not a goal. It refuses missing encoder inputs, a head that never reaches the listener or never decodes, submitted frames that never encode or reach the container, written frames that never reach the listener, reopened capture, a new encoder (a probe or a rebuilt codec) or subscription, a mute that disables or drops the rendition, and separated @@ -192,8 +201,8 @@ alongside the audio quality rows. ## Traces -The shaper's profiles are synthetic. [`traces/`](traces) holds real arrivals, each graded as a -`replay` row whose profile is the file's name: +The shaper's profiles are synthetic. [`traces/`](traces) holds real arrivals, and one derived from +them, each graded as a `replay` row whose profile is the file's name: | Trace | Recorded from | | --- | --- | @@ -202,6 +211,7 @@ The shaper's profiles are synthetic. [`traces/`](traces) holds real arrivals, ea | `relay-mic` | `` through the public relay: a real microphone with `--mic-broadcast` (the checked-in one is Chrome on a MacBook Air, its built-in microphone), otherwise headless Chromium's fake capture device | | `bursty-aac` | a nightly `bursty` AAC row's capture, from when the publisher sent each frame as its own group: each flush delivered newest first, which kept the player re-stalling until the estimator measured reordered frames | | `relay-mic-rtt40` | a page playing a real microphone (Chrome on a MacBook Air) through the public relay with 40 ms of added round trip: the steady-state re-stalls time stretch must remove | +| `relay-mic-stall` | `relay-mic` with nothing arriving from 15 s to 16.5 s, then the held frames trickling in oldest first at twice real time until they meet live arrivals at 18 s: the stall a congested path causes, longer than the target, with its backlog arriving late | A trace is a [`Trace`](clients/js/src/schema.ts): the catalog's audio rendition, the smallest PROBE round trip the session saw, how long it observed, and every frame's `[at, timestamp, group, duration]`, @@ -227,8 +237,7 @@ its budgets are exactly what it measured. The ring time-stretches live playback as the page's does, but the replay's audio is a constant, so every seam admits at the shortest pitch period, 2.5 ms. Accelerate therefore moves less per stretch than it would from speech; only fast accelerate, which takes every whole period that fits, moves its -most. `skip_aheads` also reads a sustained accelerate as a skip; `player_skips` counts only the ring's -own re-anchors. +most. ```bash just test audio-quality-record # the three recorded lanes, 35 s each, needs the network @@ -250,7 +259,8 @@ Recording is by hand: the public relay and a browser publisher are not something should depend on. Re-measure the replay budgets after re-recording. The recorder asks the relay for ten seconds of backlog so a late group is kept, which makes a trace's tune-in heavier than a player's; the warmup excludes it from the grade. `bursty-aac` is not recorded here: it is a nightly -capture converted by the recipe [above](#diagnosing-live-rows). +capture converted by the recipe [above](#diagnosing-live-rows), and `relay-mic-stall` is `relay-mic` +with the rewrite its `source` names, so re-recording `relay-mic` redoes it. ## The metric contract @@ -290,24 +300,15 @@ player's own count, which its stats panel shows, is read alongside: re-stalled to refill, plus each quantum it filled only part-way. The tap files the quanta after a run-dry as stalled time, so `underruns` leaves those out and this counts them. Unset natively. - `player_skips`: `audio.out.stats.skips`, each jump that dropped buffered audio rather than playing - it faster. `skip_aheads` below infers the same events from the playhead, and also reads a time - stretch that sustains 40 ms of acceleration as one, so this is the exact count. Natively, each - trim of the ring, and each run of consecutive frames `moq play` skipped at the stretch's fast - threshold or a full ring refused. + it faster. Speeding up is not a skip. Natively, each trim of the ring, and each run of + consecutive frames `moq play` skipped at the stretch's fast threshold or a full ring refused. - `underruns`: quanta the ring filled only partly, or not at all, while playing. - `short_quanta`: the underruns that were partly filled: the ring ran dry part-way through. - `underrun_episodes`: maximal runs of consecutive underruns, one audible gap each. - `underrun_ms`: the missing audio, summed, and the longest episode as `max`. -- `skip_aheads`: re-anchors that discarded buffered audio, seen as a forward step of more than 40 ms - in the lag between the viewer clock and the playhead (judged on the median of four samples either - side, after removing the media clock's drift). A time stretch that accelerates onto a lower target - by more than 40 ms across those nine samples counts too, though it re-anchors nothing: `moq play` - accelerates about 8%, so shedding more than about 40 ms reads as one skip or more. -- `discarded_ms`: the media those skip-aheads jumped over. Audio dropped before it reached the ring - moves no playhead, so it is not counted. - `trimmed_ms`: `audio.out.stats.trimmed`, the media those `player_skips` dropped unplayed, including the zeros filling a network gap; neither player counts its opening silence, declared - silence, or comfort noise. Unlike `discarded_ms`, it never counts an accelerate. Media the + silence, or comfort noise. It never counts an accelerate. Media the subscription skipped before decoding, a group past its age budget, is a gap in the timeline, not a trim, in either player. - `accelerated_ms`: `audio.out.stats.accelerated`, the media the time stretch removed by @@ -319,8 +320,13 @@ player's own count, which its stats panel shows, is read alongside: - `av_lag_ms`: how far the audio playhead trails the shared clock video plays from (`sync.now()`), sampled while playing. Audio and video keep separate clocks that align once the delay covers the arrivals, so this is the latency audio adds beyond the target: positive is audio late, negative - early. Its replay ceilings hold audio from settling later to buy fewer underruns. Natively, the - presentation clock `moq play` paces video from (`sync::Consumer::position`). + early. Its `p50` is where audio rests, so latency spent to buy fewer underruns shows there; its + `p95` includes audio trailing through a stall. Natively, the presentation clock `moq play` paces + video from (`sync::Consumer::position`). +- `recover_ms`: the longest audio spent off its resting point, from the ring stalling, or audio + trailing the shared clock by more than one 20 ms bucket past the window's `av_lag_ms` p50, to + audio back within it. Reported, not budgeted: it is how long a stall costs, which a player may + trade against the audio it keeps. - `converge_ms`: from first audio to the last time the target moved more than one 20 ms bucket from its final value. - `render_load`: Chromium's render capacity, the share of each quantum's budget the graph used. @@ -368,6 +374,13 @@ replays run under `--enforce` in `just ci` on every diff that touches the player fails when it moves in either direction: a change that moves one updates `budgets.json` to what it now measures in the same PR, so run `just test audio-quality --replays --enforce` before pushing one. +The grade follows the player's model: audio rests on the shared clock, trails it through a stall, +and catches up after. So every row budgets the steady-state lag (`av_lag_ms` p50) and the audio the +player dropped (`trimmed_ms`, `player_skips`), while lag through a stall (`av_lag_ms` p95) and +underruns are ceilings with measured headroom, never zero. When a change moves a replay row, a +steady-state lag that rises or audio the player trimmed is a regression to fix rather than budget; +a p95 lag that rises through a stall, or an underrun count that moves, is re-measured in. + ## Layout ```text @@ -375,6 +388,7 @@ run.sh builds, starts the relay and publishers, runs each row be ../lib/pulse.py the native rows' private PulseAudio null sink record.sh records traces/, by hand relay.toml anonymous relay, self-signed cert +congestion.toml the congestion profile's shaper treatment budgets.json a ceiling per metric per row traces/ recorded arrivals, one replay profile each clients/js/ @@ -394,8 +408,8 @@ clients/js/ ## Attribution The harness is the reporter's, from #3477: fperex built it on their fork `fperex/moq` (branches -`debug/rt-audio` and `debug-findings-solution`), with the black-box probe, the analyzer's skip-ahead -rule, the Playwright matrix over `moq-shaper`, the budget file graded under `--enforce`, and the +`debug/rt-audio` and `debug-findings-solution`), with the black-box probe, the analyzer's per-minute +normalisation, the Playwright matrix over `moq-shaper`, the budget file graded under `--enforce`, and the nightly job. The harness and opt-in shaper features preserve that author's credit. The player and estimator changes remain separate: the underrun count comes from a tap on the output, read alongside the player's own counter, and the profiles now include the fork's batch, step, and order-preserving jitter treatments. diff --git a/test/audio-quality/clients/js/grade.ts b/test/audio-quality/clients/js/grade.ts index 60ff373fb1d..47bdb02fc1a 100644 --- a/test/audio-quality/clients/js/grade.ts +++ b/test/audio-quality/clients/js/grade.ts @@ -74,14 +74,13 @@ const COLUMNS: [string, string][] = [ ["short/min", "short_quanta_per_min"], ["episodes/min", "underrun_episodes_per_min"], ["gap ms/min", "underrun_ms_per_min"], - ["skip-aheads/min", "skip_aheads_per_min"], - ["discarded ms/min", "discarded_ms_per_min"], ["trimmed ms/min", "trimmed_ms_per_min"], ["accelerated ms/min", "accelerated_ms_per_min"], ["stalled", "stalled_share"], ["silence", "silence_share"], ["A/V lag p50", "av_lag_ms_p50"], ["A/V lag p95", "av_lag_ms_p95"], + ["recover ms", "recover_ms_max"], ["target p95", "target_ms_p95"], ["converge ms", "converge_ms_last"], ]; diff --git a/test/audio-quality/clients/js/ptt-analyze.test.ts b/test/audio-quality/clients/js/ptt-analyze.test.ts index d30e700b77f..6291b469052 100644 --- a/test/audio-quality/clients/js/ptt-analyze.test.ts +++ b/test/audio-quality/clients/js/ptt-analyze.test.ts @@ -196,7 +196,7 @@ test("a mute that disables the rendition fails the run", async () => { }); // The silence between presses is declared, so playback crosses it without counting it. Underruns -// and stalls the player does count are reported, not failed: the audio grading judges them. +// and stalls the player does count are reported, not failed: zero underruns is not a goal. test("an underrun or stall across the presses is reported and passes", async () => { const result = trace(); result.playback = { underruns: 3, stalls: 2 }; diff --git a/test/audio-quality/clients/js/ptt-analyze.ts b/test/audio-quality/clients/js/ptt-analyze.ts index 910f604656e..ec84bc00cfc 100644 --- a/test/audio-quality/clients/js/ptt-analyze.ts +++ b/test/audio-quality/clients/js/ptt-analyze.ts @@ -206,7 +206,7 @@ console.log( JSON.stringify({ latency, path, delay, unencoded, unsent, unreceived, playback, native: summary.native }, null, 2), ); -// Latency, underruns, and stalls are reported, never gated: the audio grading quest judges them. +// Latency, underruns, and stalls are reported, never gated: zero underruns is not a goal. const failures: string[] = []; if (presses.some((press, i) => (i === 0 || i >= 8) && press.audible === null)) { failures.push("a separated utterance never reached the output"); diff --git a/test/audio-quality/clients/js/src/analyze.test.ts b/test/audio-quality/clients/js/src/analyze.test.ts index 05b3683eb87..9dd3c279d28 100644 --- a/test/audio-quality/clients/js/src/analyze.test.ts +++ b/test/audio-quality/clients/js/src/analyze.test.ts @@ -1,5 +1,5 @@ import { describe, expect, test } from "bun:test"; -import { analyze, type Input, percentile, SKIP_MS, skipAheads } from "./analyze.ts"; +import { analyze, type Input, longestAway, percentile } from "./analyze.ts"; import type { Sample, Shaper } from "./schema.ts"; const row = { runtime: "chromium", codec: "opus", rate: 48000, profile: "mild" } as const; @@ -33,21 +33,12 @@ const input = (samples: Sample[], extra: Partial = {}): Input => ({ ...extra, }); -describe("skipAheads", () => { - test("the quantization band is not a skip", () => { - const lags = Array.from({ length: 40 }, (_, i) => 200 + (i % 2 === 0 ? 25 : -25)); - expect(skipAheads(lags).count).toBe(0); - }); - - test("a step in the lag is one skip, of the step's size", () => { - const lags = Array.from({ length: 40 }, (_, i) => (i < 20 ? 300 : 200)); - expect(skipAheads(lags)).toEqual({ count: 1, ms: 100 }); - }); - - test("a step at the threshold is not one", () => { - const lags = Array.from({ length: 40 }, (_, i) => (i < 20 ? 200 + SKIP_MS : 200)); - expect(skipAheads(lags).count).toBe(0); - }); +test("the longest time away runs from the first away sample to the next one back", () => { + const at = (away: boolean[]) => away.map((a, i) => ({ at: i * 250, away: a })); + expect(longestAway(at([false, true, true, false, true, false]))).toBe(500); + // Still away at the end: it lasts to the last sample. + expect(longestAway(at([false, false, true, true, true]))).toBe(500); + expect(longestAway(at([false, false]))).toBe(0); }); test("percentile is nearest rank", () => { @@ -62,7 +53,6 @@ describe("analyze", () => { expect(summary.voids).toEqual([]); expect(summary.metrics).toMatchObject({ underruns_total: 0, - skip_aheads_total: 0, stalled_share: 0, silence_share: 0, target_ms_p95: 120, @@ -135,9 +125,17 @@ describe("analyze", () => { expect(analyze(input(samples)).metrics.underruns_total).toBe(0); }); - test("a re-anchor that discards audio is a skip-ahead", () => { - const samples = clean().map((s, i) => (i >= 80 ? { ...s, timestamp: s.at - 100 } : s)); - expect(analyze(input(samples)).metrics).toMatchObject({ skip_aheads_total: 1, discarded_ms_total: 100 }); + test("recovery is the longest audio spent stalled or trailing its resting lag", () => { + // At rest 20 ms ahead of the clock; samples 80 to 83 stall, and audio then trails until 91. + const samples = clean().map((s, i) => { + const timestamp = s.timestamp ?? 0; + if (i >= 80 && i < 84) return { ...s, stalled: true, clock: timestamp + 500 }; + const lag = i >= 84 && i < 92 ? 300 - (i - 84) * 30 : -20; + return { ...s, clock: timestamp + lag }; + }); + // 300 down to 90 ms trail by more than a bucket past rest; 92 is back. + expect(analyze(input(samples)).metrics).toMatchObject({ av_lag_ms_p50: -20, recover_ms_max: 12 * 250 }); + expect(analyze(input(clean())).metrics.recover_ms_max).toBeNull(); }); test("a shaper that failed or never carried the page voids the row", () => { diff --git a/test/audio-quality/clients/js/src/analyze.ts b/test/audio-quality/clients/js/src/analyze.ts index a527cf99511..e5ede40c75f 100644 --- a/test/audio-quality/clients/js/src/analyze.ts +++ b/test/audio-quality/clients/js/src/analyze.ts @@ -5,7 +5,7 @@ * `../analyze.ts` is the command that feeds it a run directory. * * Adapted from `debug-findings/analysis/analyze.mjs` on the reporter's fork (`fperex/moq`, branch - * `debug/rt-audio`), whose skip-ahead rule and per-minute normalisation this keeps. The event stream + * `debug/rt-audio`), whose per-minute normalisation this keeps. The event stream * it read came from probes patched into the player; this reads public signals and the output tap. * * @module @@ -48,12 +48,6 @@ export type Input = { */ export const STALL_SLACK_MS = 60; -/** A step in the de-trended playhead lag larger than this is a skip-ahead. See {@link skipAheads}. */ -export const SKIP_MS = 40; - -/** Samples either side of a candidate skip reduced to a median before it is judged. */ -export const SKIP_WINDOW = 4; - const median = (values: number[]): number | undefined => { if (values.length === 0) return undefined; const sorted = [...values].sort((a, b) => a - b); @@ -83,32 +77,22 @@ export function slope(xs: number[], ys: number[]): number | null { } /** - * Forward steps in the lag between the viewer clock and the playhead, and the media they skipped. - * - * `lags` is the de-trended `at - timestamp` per sample, undefined where there was no playhead or the - * ring was stalled. The playhead a page reads is quantized (it moves 240 to 296 ms per 250 ms sample - * on a clean path), so one sample's excess is noise: a skip is a step between the medians either side - * of a sample, larger than {@link SKIP_MS}, which is more than that band and more than one estimator - * bucket plus a render quantum. + * The longest run of samples spent away from rest, in ms: from the first away sample to the next + * one back. A run still open at the end lasts to the last sample. */ -export function skipAheads(lags: (Ms | undefined)[]): { count: number; ms: Ms } { - let count = 0; - let ms = 0; - const defined = (slice: (Ms | undefined)[]) => slice.filter((l): l is Ms => l !== undefined); - for (let i = SKIP_WINDOW; i < lags.length - SKIP_WINDOW; i++) { - if (lags[i] === undefined) continue; - const before = median(defined(lags.slice(i - SKIP_WINDOW, i))); - const after = median(defined(lags.slice(i + 1, i + 1 + SKIP_WINDOW))); - if (before === undefined || after === undefined) continue; - const jumped = before - after; - if (jumped > SKIP_MS) { - count++; - ms += jumped; - // One step is one skip, and the trailing window straddles it for several samples. - i += SKIP_WINDOW; +export function longestAway(samples: { at: Ms; away: boolean }[]): Ms { + let longest = 0; + let since: Ms | undefined; + for (const { at, away } of samples) { + if (away) since ??= at; + else if (since !== undefined) { + longest = Math.max(longest, at - since); + since = undefined; } } - return { count, ms }; + const end = samples.at(-1)?.at; + if (since !== undefined && end !== undefined) longest = Math.max(longest, end - since); + return longest; } /** @@ -213,12 +197,11 @@ export function analyze(input: Input): Summary { const accelerated = rise((s) => s.accelerated); // ── the playhead ──────────────────────────────────────────────────────── - // The lag drifts when the media timeline does not run at wall rate, a property of the source - // rather than the player. Fitted and removed first, or it reads as a skip every few seconds. - // A least-squares fit would read a skip itself as drift and hide part of it, so the rate is the - // median slope across spans of two skip windows, which a step contaminates only a few of. + // The media clock's rate against the viewer's, a property of the source rather than the player. + // A least-squares fit would read a skip as drift, so the rate is the median slope across spans of + // eight samples, which a step contaminates only a few of. const playing = window.filter((s) => s.timestamp !== undefined && !s.stalled); - const reach = 2 * SKIP_WINDOW; + const reach = 8; const mediaRate = median( playing.slice(reach).map((s, i) => { @@ -226,13 +209,24 @@ export function analyze(input: Input): Summary { return (s.at - (s.timestamp as Ms) - (from.at - (from.timestamp as Ms))) / (s.at - from.at); }), ) ?? null; - const base = playing[0]?.at ?? 0; - const lags = window.map((s) => - s.timestamp === undefined || s.stalled ? undefined : s.at - s.timestamp - (mediaRate ?? 0) * (s.at - base), - ); - const skips = skipAheads(lags); // Both on the media clock, read at one instant, so no reduction to the viewer's is needed. - const behind = playing.flatMap((s) => (s.clock === undefined ? [] : [s.clock - (s.timestamp as Ms)])); + const lagOf = (s: Sample) => (s.clock === undefined || s.timestamp === undefined ? undefined : s.clock - s.timestamp); + const behind = playing.flatMap((s) => { + const lag = lagOf(s); + return lag === undefined ? [] : [lag]; + }); + // Rest is the window's median lag, not zero: a player may settle a little either side of the clock, + // and how far is `av_lag_ms_p50`'s to grade. A stalled ring is off the clock however far it ran. + const rest = percentile(behind, 50); + const recover = + rest === null + ? null + : longestAway( + window.map((s) => { + const lag = s.stalled ? undefined : lagOf(s); + return { at: s.at, away: s.stalled === true || (lag !== undefined && lag > rest + BUCKET_MS) }; + }), + ); const stalledShare = window.length > 0 ? window.filter((s) => s.stalled).length / window.length : null; // ── the target ────────────────────────────────────────────────────────── @@ -267,10 +261,6 @@ export function analyze(input: Input): Summary { player_underruns_per_min: playerUnderruns === null ? null : perMin(playerUnderruns), player_skips_total: playerSkips, player_skips_per_min: playerSkips === null ? null : perMin(playerSkips), - skip_aheads_total: skips.count, - skip_aheads_per_min: perMin(skips.count), - discarded_ms_total: round(skips.ms), - discarded_ms_per_min: perMin(skips.ms), trimmed_ms_total: round(trimmed), trimmed_ms_per_min: trimmed === null ? null : perMin(trimmed), accelerated_ms_total: round(accelerated), @@ -279,6 +269,7 @@ export function analyze(input: Input): Summary { silence_share: round(silence, 3), av_lag_ms_p50: round(percentile(behind, 50)), av_lag_ms_p95: round(percentile(behind, 95)), + recover_ms_max: round(recover), target_ms_p50: round(percentile(targets, 50)), target_ms_p95: round(percentile(targets, 95)), target_ms_max: round(percentile(targets, 100)), diff --git a/test/audio-quality/clients/js/src/run.test.ts b/test/audio-quality/clients/js/src/run.test.ts index 473d503f392..b41a222ef41 100644 --- a/test/audio-quality/clients/js/src/run.test.ts +++ b/test/audio-quality/clients/js/src/run.test.ts @@ -3,15 +3,17 @@ import { fileURLToPath } from "node:url"; const script = fileURLToPath(new URL("../../../run.sh", import.meta.url)); -test("a step row must play beyond the profile change", () => { - for (const duration of ["20", "30"]) { - const result = Bun.spawnSync(["bash", script, "--profiles", "step", "--duration", duration, "--list"]); - expect(result.exitCode).toBe(2); - expect(result.stderr.toString()).toContain("must exceed the step at 30s"); +test("a row whose path changes must play beyond the change", () => { + for (const profile of ["step", "congestion"]) { + for (const duration of ["20", "30"]) { + const result = Bun.spawnSync(["bash", script, "--profiles", profile, "--duration", duration, "--list"]); + expect(result.exitCode).toBe(2); + expect(result.stderr.toString()).toContain(`must exceed ${profile}'s change`); + } + const result = Bun.spawnSync(["bash", script, "--profiles", profile, "--duration", "31", "--list"]); + expect(result.exitCode).toBe(0); + expect(result.stdout.toString()).toContain(`chromium-opus-48000-${profile}`); } - const result = Bun.spawnSync(["bash", script, "--profiles", "step", "--duration", "31", "--list"]); - expect(result.exitCode).toBe(0); - expect(result.stdout.toString()).toContain("chromium-opus-48000-step"); }); test("short steady rows remain supported", () => { @@ -19,7 +21,7 @@ test("short steady rows remain supported", () => { expect(result.exitCode).toBe(0); }); -test("the nightly matrix includes both new profiles", () => { +test("the nightly matrix includes every profile whose path changes", () => { const result = Bun.spawnSync(["bash", script, "--list"]); expect(result.exitCode).toBe(0); const rows = result.stdout @@ -27,8 +29,8 @@ test("the nightly matrix includes both new profiles", () => { .trim() .split("\n") .filter((row) => row.startsWith("chromium-")); - expect(rows).toHaveLength(12); - for (const profile of ["bursty", "step"]) { + expect(rows).toHaveLength(14); + for (const profile of ["bursty", "step", "congestion"]) { expect(rows.filter((row) => row.endsWith(`-${profile}`))).toHaveLength(2); } }); diff --git a/test/audio-quality/clients/js/src/schema.ts b/test/audio-quality/clients/js/src/schema.ts index 6bfad590044..a28b3af79ef 100644 --- a/test/audio-quality/clients/js/src/schema.ts +++ b/test/audio-quality/clients/js/src/schema.ts @@ -109,28 +109,14 @@ export const METRICS = { clock: "render", aggregations: ["total", "per_min"], description: - "The player's own count of skips: each jump that dropped buffered audio rather than playing it faster. `skip_aheads` infers them from the playhead, which reads a sustained time stretch as one too.", - }, - skip_aheads: { - unit: "count", - clock: "viewer", - aggregations: ["total", "per_min"], - description: - "Re-anchors that discarded buffered audio: a forward step in the lag between the viewer clock and the playhead.", - }, - discarded_ms: { - unit: "ms", - clock: "media", - aggregations: ["total", "per_min"], - description: - "Media time the skip-aheads jumped over without playing. Audio dropped before it reached the ring moves no playhead and is not counted.", + "The player's own count of skips: each jump that dropped buffered audio rather than playing it faster.", }, trimmed_ms: { unit: "ms", clock: "media", aggregations: ["total", "per_min"], description: - "The player's own count of media its skips dropped unplayed. Unlike `discarded_ms`, a time stretch's accelerate is not in it.", + "The player's own count of media its skips dropped unplayed: the audio a listener lost. A time stretch's accelerate is not in it.", }, accelerated_ms: { unit: "ms", @@ -159,6 +145,13 @@ export const METRICS = { description: "How far the audio playhead trails the shared clock video plays from (`sync.now()`), sampled while playing: latency audio adds beyond the resolved target. Negative is audio ahead.", }, + recover_ms: { + unit: "ms", + clock: "viewer", + aggregations: ["max"], + description: + "The longest audio spent off its resting point: from the ring stalling, or audio trailing the shared clock by more than one bucket past the window's median lag, to audio back within it.", + }, target_ms: { unit: "ms", clock: "viewer", diff --git a/test/audio-quality/congestion.toml b/test/audio-quality/congestion.toml new file mode 100644 index 00000000000..c60c42aec0b --- /dev/null +++ b/test/audio-quality/congestion.toml @@ -0,0 +1,22 @@ +# A downlink that congests mid-run: 1 Mbit/s behind a one second queue, collapsing to 16 kbit/s at +# 25 s for a second and a half, then back. +# +# The tone needs about 140 kbit/s, so for that spell the queue fills to its second of wait and drops +# the rest. The stall outlasts any row's target, and once the rate returns the transport delivers +# the backlog: the queue's and every retransmit. Times are from shaper startup, like `step`. +name = "congestion" +seed = 8 +shared = true + +[down.rate] +bits_per_second = 1000000 +burst = 1500 +queue = "1s" + +[[down.steps]] +at = "25s" +bits_per_second = 16000 + +[[down.steps]] +at = "26500ms" +bits_per_second = 1000000 diff --git a/test/audio-quality/run.sh b/test/audio-quality/run.sh index f1cfd36deed..6fd28fcc849 100755 --- a/test/audio-quality/run.sh +++ b/test/audio-quality/run.sh @@ -21,7 +21,7 @@ source "$AQ_DIR/../lib/harness.sh" # Captured before the parse consumes it, so the rerun command carries every flag. RERUN="$(harness_env AQ_PROFILE RELAY_BIN)just test audio-quality$(harness_argv "$@")" -ALL_PROFILES=(near-zero mild wide bursty step fixed-250) +ALL_PROFILES=(near-zero mild wide bursty step congestion fixed-250) ALL_RUNTIMES=(chromium native) ALL_CODECS=(opus aac) @@ -141,8 +141,8 @@ valid() { } for p in "${PROFILES[@]}"; do valid "$p" profile "${ALL_PROFILES[@]}" "${ALL_TRACES[@]}" - if [[ "$p" == step ]] && ((DURATION <= 30)); then - echo "error: --duration must exceed the step at 30s" >&2 + if [[ "$p" == step || "$p" == congestion ]] && ((DURATION <= 30)); then + echo "error: --duration must exceed $p's change, which ends by 30s" >&2 exit 2 fi done @@ -170,14 +170,16 @@ delay_of() { esac } -# The path treatment, as moq-shaper flags. Loss, reorder, and rate limits stay off: the buffer's job -# is absorbing arrival spread, and congestion response would make a failure hard to attribute. +# The path treatment, as moq-shaper flags. Loss, reorder, and rate limits stay off but for +# `congestion`: the buffer's job is absorbing arrival spread, and congestion response would make a +# failure hard to attribute, so one profile holds the stall a congested queue causes on its own. shaper_of() { case "$1" in near-zero | fixed-250) ;; mild) echo "--delay 5ms --jitter 5ms --jitter-model gaussian --shared" ;; wide) echo "--delay 40ms --jitter 40ms --jitter-model gaussian --shared" ;; bursty | step) echo "--profile $1" ;; + congestion) echo "--profile $AQ_DIR/congestion.toml" ;; esac } diff --git a/test/audio-quality/traces/relay-mic-stall.json b/test/audio-quality/traces/relay-mic-stall.json new file mode 100644 index 00000000000..50f90a86020 --- /dev/null +++ b/test/audio-quality/traces/relay-mic-stall.json @@ -0,0 +1,3280 @@ +{ + "version": 3, + "source": "relay-mic.json with its arrivals from 15 s rewritten: nothing arrives for 1.5 s, then the held frames arrive oldest first at twice real time until they meet live arrivals 18 s in", + "description": "A path that stalls for longer than the target and then trickles the backlog in late: the audio a player keeps and how long it takes to return to the clock.", + "transport": "webtransport", + "rtt": 2, + "config": { + "codec": "opus", + "container": { + "kind": "legacy" + }, + "description": "4f707573486561640102380180bb0000000000", + "sampleRate": 48000, + "numberOfChannels": 2, + "bitrate": 64000, + "warmup": 80, + "hls": { + "track": "audio.hls", + "duration": 4000 + } + }, + "duration": 35000, + "arrivals": [ + [0,1455218.333,30647,20], + [1.02,1455238.333,30647,20], + [1.03,1455258.333,30647,20], + [1.05,1455278.333,30647,20], + [4.73,1470358.333,30650,20], + [5.09,1470338.333,30649,20], + [5.53,1470398.333,30652,20], + [5.66,1470378.333,30651,20], + [5.83,1470418.333,30653,20], + [6.04,1470438.333,30654,20], + [6.22,1470478.333,30656,20], + [6.39,1470458.333,30655,20], + [6.52,1470498.333,30657,20], + [6.64,1470518.333,30658,20], + [7.33,1470558.333,30660,20], + [7.44,1470538.333,30659,20], + [7.55,1470578.333,30661,20], + [7.56,1470598.332,30661,20], + [7.77,1470618.333,30662,20], + [7.86,1470638.333,30663,20], + [7.96,1470658.333,30664,20], + [8.37,1470678.333,30665,20], + [8.48,1470698.333,30666,20], + [8.59,1470718.333,30667,20], + [9.83,1470758.333,30669,20], + [9.92,1470738.333,30668,20], + [10.02,1470778.333,30670,20], + [10.09,1470798.333,30671,20], + [10.95,1470818.333,30672,20], + [11.53,1470838.333,30673,20], + [11.55,1470858.332,30673,20], + [11.61,1470878.333,30674,20], + [11.72,1470898.333,30675,20], + [11.83,1470918.333,30676,20], + [11.96,1470938.333,30677,20], + [12.08,1470958.333,30678,20], + [14.25,1471018.333,30681,20], + [14.41,1470998.333,30680,20], + [14.5,1470978.333,30679,20], + [14.6,1471038.333,30682,20], + [14.88,1471058.333,30683,20], + [17.08,1471078.333,30684,20], + [19.13,1471098.333,30685,20], + [19.77,1471118.333,30686,20], + [20,1471218.333,30691,20], + [20.17,1471138.333,30687,20], + [20.28,1471158.333,30688,20], + [20.41,1471198.333,30690,20], + [20.52,1471178.333,30689,20], + [20.66,1471238.333,30692,20], + [21.08,1471278.333,30694,20], + [21.19,1471258.333,30693,20], + [21.38,1471298.333,30695,20], + [21.51,1471318.333,30696,20], + [21.63,1471338.333,30697,20], + [21.75,1471358.333,30698,20], + [21.75,1471378.332,30698,20], + [21.85,1471418.333,30700,20], + [21.99,1471398.333,30699,20], + [22.18,1471438.333,30701,20], + [22.3,1471458.333,30702,20], + [22.42,1471478.333,30703,20], + [22.59,1471518.333,30705,20], + [22.75,1471558.333,30707,20], + [23.02,1471538.333,30706,20], + [23.03,1471498.333,30704,20], + [23.06,1471578.333,30708,20], + [23.19,1471618.333,30710,20], + [23.75,1471598.333,30709,20], + [23.85,1471638.333,30711,20], + [23.96,1471658.333,30712,20], + [24.14,1471678.333,30713,20], + [24.24,1471698.333,30714,20], + [24.34,1471718.333,30715,20], + [24.48,1471758.333,30717,20], + [24.59,1471738.333,30716,20], + [24.66,1471778.333,30718,20], + [24.77,1471818.333,30720,20], + [24.85,1471798.333,30719,20], + [24.94,1471838.333,30721,20], + [25.01,1471858.333,30722,20], + [25.09,1471878.333,30723,20], + [25.19,1471898.333,30724,20], + [25.28,1471918.333,30725,20], + [25.37,1471938.333,30726,20], + [25.5,1471958.333,30727,20], + [25.69,1471978.333,30728,20], + [25.77,1471998.333,30729,20], + [25.88,1472018.333,30730,20], + [25.99,1472038.333,30731,20], + [26.16,1472058.333,30732,20], + [26.71,1472078.333,30733,20], + [27,1472098.333,30734,20], + [27.87,1472118.333,30735,20], + [28.45,1472158.333,30737,20], + [28.59,1472138.333,30736,20], + [28.83,1472198.333,30739,20], + [28.9,1472258.333,30742,20], + [28.96,1472218.333,30740,20], + [29.03,1472238.333,30741,20], + [29.06,1472178.333,30738,20], + [29.94,1472278.333,30743,20], + [30.13,1472318.333,30745,20], + [30.22,1472298.333,30744,20], + [30.34,1472358.333,30747,20], + [30.46,1472338.333,30746,20], + [30.56,1472378.333,30748,20], + [30.56,1472398.332,30748,20], + [30.78,1472418.332,30749,20], + [30.85,1472438.333,30750,20], + [30.96,1472458.333,30751,20], + [31.22,1472478.333,30752,20], + [31.31,1472498.333,30753,20], + [31.41,1472518.333,30754,20], + [31.62,1472538.333,30755,20], + [31.78,1472558.333,30756,20], + [31.91,1472578.333,30757,20], + [32.14,1472598.333,30758,20], + [32.44,1472638.333,30760,20], + [32.52,1472618.333,30759,20], + [32.59,1472658.333,30761,20], + [32.73,1472678.333,30762,20], + [33.05,1472698.333,30763,20], + [33.19,1472738.333,30765,20], + [33.24,1472718.333,30764,20], + [33.4,1472758.333,30766,20], + [33.46,1472778.333,30767,20], + [35.33,1472798.333,30768,20], + [35.53,1472818.333,30769,20], + [35.78,1472838.333,30770,20], + [35.78,1472858.333,30771,20], + [35.88,1472878.333,30772,20], + [36,1472918.333,30774,20], + [36.11,1472898.333,30773,20], + [36.27,1472938.333,30775,20], + [36.37,1472958.333,30776,20], + [36.46,1472978.333,30777,20], + [36.55,1472998.333,30778,20], + [37.66,1473018.333,30779,20], + [37.81,1473098.333,30783,20], + [37.91,1473058.333,30781,20], + [38,1473038.333,30780,20], + [38.11,1473078.333,30782,20], + [38.21,1473118.333,30784,20], + [38.31,1473138.333,30785,20], + [38.55,1473158.333,30786,20], + [38.63,1473178.333,30787,20], + [38.72,1473218.333,30789,20], + [38.8,1473198.333,30788,20], + [38.96,1473238.333,30790,20], + [39.04,1473258.333,30791,20], + [39.12,1473278.333,30792,20], + [39.21,1473318.333,30794,20], + [39.28,1473298.333,30793,20], + [39.36,1473338.333,30795,20], + [39.44,1473358.333,30796,20], + [39.57,1473378.333,30797,20], + [39.77,1473438.333,30800,20], + [39.81,1473398.333,30798,20], + [39.93,1473418.333,30799,20], + [40.04,1473478.333,30802,20], + [40.16,1473458.333,30801,20], + [40.24,1473498.333,30803,20], + [40.43,1473518.333,30804,20], + [40.58,1473558.333,30806,20], + [40.63,1473538.333,30805,20], + [40.8,1473578.333,30807,20], + [40.9,1473598.333,30808,20], + [41,1473618.333,30809,20], + [41.11,1473638.333,30810,20], + [41.61,1473678.333,30812,20], + [41.65,1473658.333,30811,20], + [41.76,1473698.333,30813,20], + [42.14,1473718.333,30814,20], + [42.3,1473738.333,30815,20], + [42.95,1473758.333,30816,20], + [43.06,1473798.333,30818,20], + [43.13,1473778.333,30817,20], + [43.24,1473838.333,30820,20], + [43.36,1473818.333,30819,20], + [43.92,1473858.333,30821,20], + [44,1473878.333,30822,20], + [44.09,1473898.333,30823,20], + [44.19,1473918.333,30824,20], + [44.3,1473938.333,30825,20], + [44.59,1473978.333,30827,20], + [44.67,1473958.333,30826,20], + [44.97,1473998.333,30828,20], + [45.08,1474018.333,30829,20], + [45.49,1474038.333,30830,20], + [45.58,1474058.333,30831,20], + [46.04,1474098.333,30833,20], + [46.16,1474118.333,30834,20], + [46.23,1474078.333,30832,20], + [46.28,1474138.333,30835,20], + [46.38,1474158.333,30836,20], + [46.49,1474178.333,30837,20], + [46.65,1474198.333,30838,20], + [46.72,1474218.333,30839,20], + [46.79,1474238.333,30840,20], + [47.13,1474298.333,30843,20], + [47.22,1474278.333,30842,20], + [47.31,1474258.333,30841,20], + [47.97,1474318.333,30844,20], + [48.8,1474398.333,30848,20], + [48.88,1474338.333,30845,20], + [48.94,1474418.333,30849,20], + [48.95,1474438.332,30849,20], + [49.01,1474378.333,30847,20], + [49.03,1474358.333,30846,20], + [49.11,1474458.332,30850,20], + [49.96,1474478.332,30851,20], + [50.14,1474498.332,30852,20], + [50.34,1474518.332,30853,20], + [50.4,1474538.333,30854,20], + [50.9,1474618.333,30858,20], + [50.97,1474598.333,30857,20], + [51.03,1474578.333,30856,20], + [51.06,1474558.333,30855,20], + [53.17,1474718.333,30863,20], + [53.24,1474658.333,30860,20], + [53.34,1474638.333,30859,20], + [53.4,1474698.333,30862,20], + [53.46,1474678.333,30861,20], + [53.53,1474738.333,30864,20], + [53.59,1474758.333,30865,20], + [53.76,1474778.333,30866,20], + [54.25,1474878.333,30871,20], + [54.34,1474838.333,30869,20], + [54.44,1474858.333,30870,20], + [54.53,1474898.333,30872,20], + [54.62,1474798.333,30867,20], + [54.71,1474818.333,30868,20], + [55.02,1474918.333,30873,20], + [55.1,1474978.333,30876,20], + [55.24,1474958.333,30875,20], + [55.33,1474938.333,30874,20], + [55.43,1474998.333,30877,20], + [55.67,1475038.333,30879,20], + [55.75,1475058.333,30880,20], + [55.81,1475018.333,30878,20], + [56.02,1475078.333,30881,20], + [56.22,1475098.333,30882,20], + [56.33,1475118.333,30883,20], + [56.38,1475138.333,30884,20], + [56.49,1475158.333,30885,20], + [56.91,1475198.333,30887,20], + [57,1475178.333,30886,20], + [57.07,1475218.333,30888,20], + [57.21,1475238.333,30889,20], + [57.29,1475258.333,30890,20], + [57.54,1475298.333,30892,20], + [57.63,1475318.333,30893,20], + [57.67,1475278.333,30891,20], + [57.77,1475338.333,30894,20], + [57.87,1475358.333,30895,20], + [57.94,1475378.333,30896,20], + [58.13,1475418.333,30898,20], + [58.25,1475398.333,30897,20], + [58.34,1475438.333,30899,20], + [58.47,1475458.333,30900,20], + [58.63,1475478.333,30901,20], + [58.87,1475498.333,30902,20], + [59.03,1475538.333,30904,20], + [59.13,1475518.333,30903,20], + [59.21,1475558.333,30905,20], + [59.28,1475578.333,30906,20], + [59.57,1475598.333,30907,20], + [59.78,1475618.333,30908,20], + [59.94,1475658.333,30910,20], + [60.01,1475638.333,30909,20], + [60.09,1475678.333,30911,20], + [60.2,1475698.333,30912,20], + [61.37,1475738.333,30914,20], + [61.44,1475718.333,30913,20], + [61.49,1475758.333,30915,20], + [61.58,1475778.333,30916,20], + [61.74,1475818.333,30918,20], + [61.83,1475838.333,30919,20], + [61.88,1475798.333,30917,20], + [61.97,1475858.333,30920,20], + [62.12,1475878.333,30921,20], + [62.32,1475898.333,30922,20], + [62.37,1475938.333,30924,20], + [62.62,1475978.333,30926,20], + [62.72,1475998.333,30927,20], + [62.8,1475918.333,30923,20], + [62.84,1475958.333,30925,20], + [63.11,1476058.333,30930,20], + [63.16,1476038.333,30929,20], + [63.25,1476018.333,30928,20], + [63.34,1476078.333,30931,20], + [63.41,1476098.333,30932,20], + [63.66,1476138.333,30934,20], + [63.78,1476118.333,30933,20], + [63.93,1476178.333,30936,20], + [63.97,1476158.333,30935,20], + [64.21,1476218.333,30938,20], + [64.28,1476198.333,30937,20], + [64.69,1476238.333,30939,20], + [64.77,1476258.333,30940,20], + [64.87,1476278.333,30941,20], + [64.97,1476298.333,30942,20], + [65.06,1476318.333,30943,20], + [65.15,1476338.333,30944,20], + [65.23,1476358.333,30945,20], + [65.33,1476378.333,30946,20], + [65.62,1476398.333,30947,20], + [66.03,1476458.333,30950,20], + [66.1,1476418.333,30948,20], + [66.16,1476438.333,30949,20], + [66.25,1476498.333,30952,20], + [66.34,1476478.333,30951,20], + [66.49,1476518.333,30953,20], + [66.59,1476538.333,30954,20], + [67.53,1476598.333,30957,20], + [67.59,1476558.333,30955,20], + [67.66,1476618.333,30958,20], + [67.73,1476578.333,30956,20], + [67.8,1476638.333,30959,20], + [67.95,1476658.333,30960,20], + [68.05,1476678.333,30961,20], + [68.16,1476698.333,30962,20], + [68.91,1476738.333,30964,20], + [68.94,1476718.333,30963,20], + [69.13,1476758.333,30965,20], + [69.64,1476798.333,30967,20], + [70.38,1476778.333,30966,20], + [70.49,1476818.333,30968,20], + [70.57,1476838.333,30969,20], + [70.66,1476878.333,30971,20], + [70.73,1476858.333,30970,20], + [70.82,1476898.333,30972,20], + [70.96,1476918.333,30973,20], + [71.06,1476938.333,30974,20], + [71.15,1476958.333,30975,20], + [71.37,1476978.333,30976,20], + [71.44,1476998.333,30977,20], + [71.5,1477018.333,30978,20], + [71.56,1477038.333,30979,20], + [71.69,1477058.333,30980,20], + [71.77,1477078.333,30981,20], + [71.84,1477098.333,30982,20], + [71.91,1477138.333,30984,20], + [72,1477118.333,30983,20], + [72.06,1477158.333,30985,20], + [72.19,1477178.333,30986,20], + [72.27,1477198.333,30987,20], + [73.06,1477298.333,30992,20], + [73.14,1477278.333,30991,20], + [73.22,1477258.333,30990,20], + [73.29,1477238.333,30989,20], + [73.32,1477218.333,30988,20], + [73.4,1477318.333,30993,20], + [73.58,1477338.333,30994,20], + [73.68,1477358.333,30995,20], + [73.77,1477378.333,30996,20], + [73.84,1477398.333,30997,20], + [73.94,1477418.333,30998,20], + [74.13,1477438.333,30999,20], + [74.22,1477478.333,31001,20], + [74.3,1477458.333,31000,20], + [74.38,1477498.333,31002,20], + [74.61,1477518.333,31003,20], + [75.78,1477558.333,31005,20], + [75.92,1477538.333,31004,20], + [76.72,1477638.333,31009,20], + [76.82,1477598.333,31007,20], + [76.88,1477618.333,31008,20], + [76.93,1477578.333,31006,20], + [77.06,1477698.333,31012,20], + [77.43,1477738.333,31014,20], + [77.48,1477718.333,31013,20], + [77.71,1477758.333,31015,20], + [77.8,1477678.333,31011,20], + [77.86,1477658.333,31010,20], + [77.93,1477778.333,31016,20], + [78,1477798.333,31017,20], + [78.21,1477818.333,31018,20], + [78.35,1477838.333,31019,20], + [78.53,1477858.333,31020,20], + [79.03,1477898.333,31022,20], + [79.15,1477878.333,31021,20], + [79.25,1477958.333,31025,20], + [79.29,1477918.333,31023,20], + [79.39,1477938.333,31024,20], + [79.55,1477978.333,31026,20], + [79.65,1477998.333,31027,20], + [79.72,1478018.333,31028,20], + [80.22,1478038.333,31029,20], + [80.32,1478058.333,31030,20], + [80.39,1478078.333,31031,20], + [80.47,1478098.333,31032,20], + [80.59,1478118.333,31033,20], + [80.69,1478178.333,31036,20], + [80.77,1478158.333,31035,20], + [80.96,1478138.333,31034,20], + [81.03,1478198.333,31037,20], + [81.12,1478218.333,31038,20], + [81.28,1478238.333,31039,20], + [81.38,1478258.333,31040,20], + [81.85,1478298.333,31042,20], + [81.91,1478318.333,31043,20], + [81.95,1478278.333,31041,20], + [82.06,1478338.333,31044,20], + [82.15,1478358.333,31045,20], + [82.27,1478378.333,31046,20], + [82.39,1478398.333,31047,20], + [82.47,1478418.333,31048,20], + [82.72,1478438.333,31049,20], + [82.93,1478478.333,31051,20], + [82.97,1478458.333,31050,20], + [83.13,1478498.333,31052,20], + [83.28,1478518.333,31053,20], + [83.28,1478538.332,31053,20], + [83.42,1478558.332,31054,20], + [83.6,1478578.332,31055,20], + [83.71,1478598.332,31056,20], + [84.08,1478618.332,31057,20], + [84.23,1478638.332,31058,20], + [84.31,1478658.332,31059,20], + [84.62,1478678.332,31060,20], + [84.81,1478698.332,31061,20], + [84.84,1478718.332,31062,20], + [84.91,1478738.333,31063,20], + [85.01,1478758.333,31064,20], + [85.15,1478778.333,31065,20], + [85.22,1478798.333,31066,20], + [85.6,1478818.333,31067,20], + [85.64,1478838.333,31068,20], + [85.78,1478858.333,31069,20], + [85.85,1478878.333,31070,20], + [87.15,1478898.333,31071,20], + [87.22,1478918.333,31072,20], + [87.3,1478938.333,31073,20], + [87.38,1478958.333,31074,20], + [87.77,1479018.333,31077,20], + [87.86,1478998.333,31076,20], + [87.93,1478978.333,31075,20], + [88,1479038.333,31078,20], + [88.06,1479058.333,31079,20], + [88.16,1479078.333,31080,20], + [88.4,1479098.333,31081,20], + [89.79,1479238.333,31088,20], + [89.84,1479118.333,31082,20], + [89.91,1479218.333,31087,20], + [89.96,1479158.333,31084,20], + [90.02,1479138.333,31083,20], + [90.06,1479178.333,31085,20], + [90.2,1479198.333,31086,20], + [90.35,1479258.333,31089,20], + [90.85,1479318.333,31092,20], + [90.91,1479278.333,31090,20], + [90.95,1479298.333,31091,20], + [91.01,1479338.333,31093,20], + [91.09,1479358.333,31094,20], + [91.19,1479378.333,31095,20], + [91.27,1479398.333,31096,20], + [91.41,1479418.333,31097,20], + [91.53,1479438.333,31098,20], + [91.67,1479458.333,31099,20], + [92.01,1479478.333,31100,20], + [92.07,1479498.333,31101,20], + [92.62,1479558.333,31104,20], + [92.71,1479538.333,31103,20], + [92.8,1479518.333,31102,20], + [92.87,1479578.333,31105,20], + [92.97,1479598.333,31106,20], + [93.03,1479618.333,31107,20], + [93.12,1479638.333,31108,20], + [93.19,1479658.333,31109,20], + [93.25,1479678.333,31110,20], + [93.64,1479698.333,31111,20], + [93.73,1479718.333,31112,20], + [93.81,1479738.333,31113,20], + [94.88,1479778.333,31115,20], + [94.94,1479758.333,31114,20], + [95.31,1479818.333,31117,20], + [95.38,1479858.333,31119,20], + [95.43,1479798.333,31116,20], + [95.47,1479878.333,31120,20], + [95.5,1479838.333,31118,20], + [95.66,1479898.333,31121,20], + [95.75,1479918.333,31122,20], + [95.94,1479938.333,31123,20], + [96.07,1479978.333,31125,20], + [96.11,1479958.333,31124,20], + [96.18,1479998.333,31126,20], + [96.46,1480038.333,31128,20], + [96.53,1480018.333,31127,20], + [96.78,1480078.333,31130,20], + [96.88,1480058.333,31129,20], + [96.97,1480098.333,31131,20], + [97.04,1480118.333,31132,20], + [97.18,1480138.333,31133,20], + [97.35,1480158.333,31134,20], + [97.47,1480178.333,31135,20], + [97.59,1480198.333,31136,20], + [97.65,1480218.333,31137,20], + [97.82,1480238.333,31138,20], + [98,1480258.333,31139,20], + [98.19,1480298.333,31141,20], + [98.21,1480278.333,31140,20], + [98.37,1480318.333,31142,20], + [98.59,1480338.333,31143,20], + [98.68,1480358.333,31144,20], + [99.52,1480378.333,31145,20], + [99.84,1480418.333,31147,20], + [100.42,1480478.333,31150,20], + [100.56,1480458.333,31149,20], + [101.1,1480438.333,31148,20], + [101.21,1480538.333,31153,20], + [101.53,1480518.333,31152,20], + [101.54,1480578.333,31155,20], + [101.58,1480558.333,31154,20], + [101.63,1480498.333,31151,20], + [101.66,1480398.333,31146,20], + [101.99,1480658.333,31159,20], + [102.03,1480598.333,31156,20], + [102.15,1480638.333,31158,20], + [102.28,1480618.333,31157,20], + [102.52,1480678.333,31160,20], + [102.59,1480698.333,31161,20], + [102.65,1480718.333,31162,20], + [102.75,1480778.333,31165,20], + [102.84,1480758.333,31164,20], + [102.93,1480738.333,31163,20], + [103.02,1480818.333,31167,20], + [103.13,1480798.333,31166,20], + [103.2,1480838.333,31168,20], + [103.28,1480858.333,31169,20], + [103.38,1480878.333,31170,20], + [103.44,1480898.333,31171,20], + [103.53,1480918.333,31172,20], + [103.63,1480938.333,31173,20], + [104.28,1480978.333,31175,20], + [104.33,1480958.333,31174,20], + [104.44,1480998.333,31176,20], + [104.5,1481018.333,31177,20], + [105.1,1481058.333,31179,20], + [105.21,1481078.333,31180,20], + [105.31,1481098.333,31181,20], + [105.35,1481038.333,31178,20], + [105.44,1481118.333,31182,20], + [105.53,1481138.333,31183,20], + [105.59,1481158.333,31184,20], + [105.69,1481178.333,31185,20], + [105.94,1481198.333,31186,20], + [106.06,1481218.333,31187,20], + [106.37,1481238.333,31188,20], + [106.56,1481258.333,31189,20], + [106.66,1481278.333,31190,20], + [107.92,1481358.333,31194,20], + [107.97,1481378.333,31195,20], + [108.03,1481398.333,31196,20], + [108.16,1481418.333,31197,20], + [108.22,1481298.333,31191,20], + [108.27,1481458.333,31199,20], + [108.72,1481478.333,31200,20], + [108.81,1481438.333,31198,20], + [109.13,1481518.333,31202,20], + [109.19,1481338.333,31193,20], + [109.22,1481318.333,31192,20], + [109.28,1481538.333,31203,20], + [109.35,1481558.333,31204,20], + [109.38,1481498.333,31201,20], + [109.41,1481578.333,31205,20], + [109.77,1481598.333,31206,20], + [110.34,1481678.333,31210,20], + [110.69,1481698.333,31211,20], + [110.75,1481618.333,31207,20], + [110.81,1481718.333,31212,20], + [110.9,1481638.333,31208,20], + [110.96,1481658.333,31209,20], + [111.02,1481738.333,31213,20], + [111.15,1481758.333,31214,20], + [111.22,1481798.333,31216,20], + [111.28,1481778.333,31215,20], + [111.47,1481818.333,31217,20], + [111.82,1481838.333,31218,20], + [111.99,1481918.333,31222,20], + [112.1,1481858.333,31219,20], + [112.15,1481878.333,31220,20], + [112.19,1481898.333,31221,20], + [112.28,1481958.333,31224,20], + [112.3,1481938.333,31223,20], + [112.37,1481978.333,31225,20], + [112.44,1481998.333,31226,20], + [112.5,1482018.333,31227,20], + [112.71,1482038.333,31228,20], + [112.97,1482058.333,31229,20], + [113.96,1482078.333,31230,20], + [114.03,1482098.333,31231,20], + [114.1,1482118.333,31232,20], + [114.31,1482138.333,31233,20], + [114.38,1482158.333,31234,20], + [114.43,1482178.333,31235,20], + [114.49,1482198.333,31236,20], + [114.55,1482218.333,31237,20], + [116.13,1482238.333,31238,20], + [116.24,1482258.333,31239,20], + [116.31,1482278.333,31240,20], + [116.41,1482298.333,31241,20], + [116.47,1482318.333,31242,20], + [116.78,1482338.333,31243,20], + [116.9,1482358.333,31244,20], + [117.05,1482378.333,31245,20], + [120.35,1482438.333,31248,20], + [120.41,1482418.333,31247,20], + [120.44,1482398.333,31246,20], + [120.56,1482458.333,31249,20], + [121,1482478.333,31250,20], + [121.01,1482518.333,31252,20], + [121.09,1482498.333,31251,20], + [121.12,1482578.333,31255,20], + [121.22,1482618.333,31257,20], + [121.22,1482598.333,31256,20], + [121.28,1482538.333,31253,20], + [121.29,1482558.333,31254,20], + [121.37,1482638.333,31258,20], + [121.38,1482658.333,31259,20], + [121.44,1482698.333,31261,20], + [121.44,1482678.333,31260,20], + [121.53,1482718.333,31262,20], + [121.53,1482738.333,31263,20], + [121.62,1482758.333,31264,20], + [121.62,1482778.333,31265,20], + [121.69,1482798.333,31266,20], + [121.69,1482818.333,31267,20], + [121.73,1482838.333,31268,20], + [121.73,1482858.333,31269,20], + [121.81,1482878.333,31270,20], + [121.89,1482898.333,31271,20], + [121.96,1482938.333,31273,20], + [122.03,1482918.333,31272,20], + [122.09,1482958.333,31274,20], + [122.18,1482978.333,31275,20], + [122.25,1482998.333,31276,20], + [122.41,1483018.333,31277,20], + [122.47,1483038.333,31278,20], + [122.53,1483058.333,31279,20], + [122.6,1483078.333,31280,20], + [122.75,1483098.333,31281,20], + [122.8,1483118.333,31282,20], + [123.27,1483138.333,31283,20], + [123.38,1483178.333,31285,20], + [123.41,1483158.333,31284,20], + [123.51,1483198.333,31286,20], + [123.65,1483218.333,31287,20], + [123.91,1483238.333,31288,20], + [123.94,1483258.333,31289,20], + [125.03,1483378.333,31295,20], + [125.07,1483358.333,31294,20], + [125.25,1483398.333,31296,20], + [125.32,1483338.333,31293,20], + [125.37,1483318.333,31292,20], + [125.41,1483278.333,31290,20], + [125.44,1483418.333,31297,20], + [125.49,1483438.333,31298,20], + [125.52,1483298.333,31291,20], + [125.57,1483458.333,31299,20], + [125.71,1483478.333,31300,20], + [125.76,1483518.333,31302,20], + [125.82,1483498.333,31301,20], + [126.94,1483558.333,31304,20], + [127.02,1483578.333,31305,20], + [127.13,1483538.333,31303,20], + [127.23,1483598.333,31306,20], + [128.52,1483638.333,31308,20], + [128.57,1483618.333,31307,20], + [128.62,1483658.333,31309,20], + [128.74,1483758.333,31314,20], + [128.74,1483778.333,31315,20], + [128.8,1483678.333,31310,20], + [128.87,1483798.333,31316,20], + [128.94,1483698.333,31311,20], + [129,1483718.333,31312,20], + [129.06,1483738.333,31313,20], + [129.32,1483818.333,31317,20], + [129.38,1483838.333,31318,20], + [129.44,1483858.333,31319,20], + [129.56,1483878.333,31320,20], + [129.63,1483898.333,31321,20], + [129.69,1483918.333,31322,20], + [129.77,1483938.333,31323,20], + [129.84,1483958.333,31324,20], + [130.13,1483978.333,31325,20], + [130.19,1483998.333,31326,20], + [130.25,1484018.333,31327,20], + [130.31,1484038.333,31328,20], + [130.38,1484058.333,31329,20], + [130.75,1484098.333,31331,20], + [130.78,1484078.333,31330,20], + [131.47,1484118.333,31332,20], + [131.54,1484138.333,31333,20], + [131.85,1484198.333,31336,20], + [131.91,1484178.333,31335,20], + [131.97,1484158.333,31334,20], + [132.02,1484218.333,31337,20], + [132.28,1484258.333,31339,20], + [132.34,1484278.333,31340,20], + [132.37,1484238.333,31338,20], + [132.59,1484298.333,31341,20], + [132.62,1484318.333,31342,20], + [132.69,1484338.333,31343,20], + [133.13,1484358.333,31344,20], + [133.31,1484398.333,31346,20], + [133.38,1484378.333,31345,20], + [133.48,1484418.333,31347,20], + [133.52,1484438.333,31348,20], + [133.58,1484458.333,31349,20], + [133.66,1484478.333,31350,20], + [133.76,1484498.333,31351,20], + [134.24,1484518.333,31352,20], + [135.92,1484538.333,31353,20], + [135.99,1484558.333,31354,20], + [136.06,1484578.333,31355,20], + [136.17,1484598.333,31356,20], + [136.25,1484618.333,31357,20], + [136.38,1484638.333,31358,20], + [136.47,1484678.333,31360,20], + [136.61,1484658.333,31359,20], + [136.67,1484698.333,31361,20], + [136.75,1484718.333,31362,20], + [136.82,1484738.333,31363,20], + [136.91,1484758.333,31364,20], + [137.23,1484778.333,31365,20], + [137.27,1484798.333,31366,20], + [137.41,1484818.333,31367,20], + [137.68,1484858.333,31369,20], + [137.71,1484838.333,31368,20], + [138.83,1484878.333,31370,20], + [138.94,1484898.333,31371,20], + [139.18,1484918.333,31372,20], + [139.3,1484938.333,31373,20], + [139.66,1484978.333,31375,20], + [139.69,1484958.333,31374,20], + [140.06,1485058.333,31379,20], + [140.12,1485038.333,31378,20], + [140.16,1485018.333,31377,20], + [140.2,1484998.333,31376,20], + [140.27,1485078.333,31380,20], + [140.46,1485118.333,31382,20], + [140.49,1485098.333,31381,20], + [140.61,1485138.333,31383,20], + [140.85,1485178.333,31385,20], + [140.88,1485158.333,31384,20], + [140.95,1485198.333,31386,20], + [141.43,1485238.333,31388,20], + [141.52,1485218.333,31387,20], + [141.61,1485258.333,31389,20], + [141.69,1485278.333,31390,20], + [141.97,1485298.333,31391,20], + [142.18,1485338.333,31393,20], + [142.29,1485318.333,31392,20], + [142.8,1485378.333,31395,20], + [142.86,1485358.333,31394,20], + [143.06,1485398.333,31396,20], + [143.13,1485418.333,31397,20], + [143.43,1485438.333,31398,20], + [143.56,1485478.333,31400,20], + [144.2,1485538.333,31403,20], + [144.25,1485518.333,31402,20], + [144.28,1485558.333,31404,20], + [144.33,1485498.333,31401,20], + [144.41,1485578.333,31405,20], + [144.43,1485458.333,31399,20], + [144.74,1485618.333,31407,20], + [144.81,1485598.333,31406,20], + [144.84,1485638.333,31408,20], + [144.91,1485658.333,31409,20], + [145.04,1485678.333,31410,20], + [145.18,1485698.333,31411,20], + [145.38,1485738.333,31413,20], + [145.42,1485718.333,31412,20], + [145.66,1485778.333,31415,20], + [145.69,1485758.333,31414,20], + [145.76,1485798.333,31416,20], + [146.65,1485818.333,31417,20], + [146.69,1485838.333,31418,20], + [146.94,1485858.333,31419,20], + [147,1485878.333,31420,20], + [147.06,1485918.333,31422,20], + [147.09,1485898.333,31421,20], + [147.61,1485958.333,31424,20], + [147.66,1485938.333,31423,20], + [147.94,1486018.333,31427,20], + [147.98,1485998.333,31426,20], + [148.03,1485978.333,31425,20], + [148.22,1486038.333,31428,20], + [148.38,1486058.333,31429,20], + [148.71,1486098.333,31431,20], + [148.77,1486078.333,31430,20], + [148.81,1486118.333,31432,20], + [148.94,1486158.333,31434,20], + [149.05,1486138.333,31433,20], + [149.19,1486198.333,31436,20], + [149.25,1486218.333,31437,20], + [149.28,1486178.333,31435,20], + [149.6,1486258.333,31439,20], + [149.63,1486238.333,31438,20], + [149.93,1486278.333,31440,20], + [150.24,1486338.333,31443,20], + [150.63,1486358.333,31444,20], + [150.87,1486398.333,31446,20], + [150.93,1486378.333,31445,20], + [150.98,1486318.333,31442,20], + [151.03,1486298.333,31441,20], + [151.1,1486418.333,31447,20], + [151.27,1486438.333,31448,20], + [153.02,1486498.333,31451,20], + [153.1,1486478.333,31450,20], + [153.19,1486518.333,31452,20], + [153.26,1486458.333,31449,20], + [153.37,1486538.333,31453,20], + [153.5,1486598.333,31456,20], + [153.56,1486558.333,31454,20], + [153.61,1486578.333,31455,20], + [153.7,1486618.333,31457,20], + [153.94,1486638.333,31458,20], + [153.99,1486658.333,31459,20], + [154.12,1486678.333,31460,20], + [154.18,1486698.333,31461,20], + [154.28,1486718.333,31462,20], + [154.28,1486738.332,31462,20], + [154.66,1486758.332,31463,20], + [155.03,1486778.332,31464,20], + [155.16,1486818.332,31466,20], + [155.22,1486838.332,31467,20], + [155.25,1486798.332,31465,20], + [155.33,1486858.332,31468,20], + [155.68,1486878.332,31469,20], + [155.78,1486918.332,31471,20], + [155.85,1486898.332,31470,20], + [155.95,1486938.332,31472,20], + [156.04,1486958.332,31473,20], + [156.55,1487018.332,31476,20], + [156.63,1486978.332,31474,20], + [156.72,1486998.332,31475,20], + [157.82,1487038.332,31477,20], + [158.62,1487118.333,31481,20], + [158.66,1487058.332,31478,20], + [158.74,1487078.332,31479,20], + [158.81,1487098.332,31480,20], + [158.99,1487138.333,31482,20], + [159.03,1487158.333,31483,20], + [159.15,1487198.333,31485,20], + [159.27,1487178.333,31484,20], + [159.35,1487238.333,31487,20], + [159.38,1487218.333,31486,20], + [159.78,1487298.333,31490,20], + [159.84,1487278.333,31489,20], + [159.9,1487258.333,31488,20], + [160.18,1487358.333,31493,20], + [160.25,1487338.333,31492,20], + [160.28,1487318.333,31491,20], + [160.52,1487418.333,31496,20], + [160.58,1487398.333,31495,20], + [160.63,1487378.333,31494,20], + [160.68,1487438.333,31497,20], + [161.04,1487478.333,31499,20], + [161.1,1487458.333,31498,20], + [161.18,1487498.333,31500,20], + [161.81,1487538.333,31502,20], + [161.87,1487558.333,31503,20], + [161.91,1487598.333,31505,20], + [161.96,1487578.333,31504,20], + [162.05,1487518.333,31501,20], + [163.15,1487618.333,31506,20], + [163.25,1487638.333,31507,20], + [163.31,1487658.333,31508,20], + [163.37,1487678.333,31509,20], + [163.43,1487698.333,31510,20], + [163.49,1487718.333,31511,20], + [163.63,1487738.333,31512,20], + [163.69,1487758.333,31513,20], + [163.74,1487778.333,31514,20], + [163.83,1487798.333,31515,20], + [163.88,1487818.333,31516,20], + [163.95,1487838.333,31517,20], + [164,1487858.333,31518,20], + [164.15,1487878.333,31519,20], + [164.44,1487898.333,31520,20], + [164.47,1487918.333,31521,20], + [164.53,1487938.333,31522,20], + [165.23,1488018.333,31526,20], + [165.28,1487978.333,31524,20], + [165.32,1487998.333,31525,20], + [165.35,1488038.333,31527,20], + [165.38,1487958.333,31523,20], + [165.47,1488058.333,31528,20], + [165.87,1488078.333,31529,20], + [166.04,1488118.333,31531,20], + [166.08,1488098.333,31530,20], + [166.13,1488138.333,31532,20], + [166.31,1488158.333,31533,20], + [166.37,1488178.333,31534,20], + [166.62,1488198.333,31535,20], + [167.21,1488218.333,31536,20], + [167.41,1488238.333,31537,20], + [167.66,1488258.333,31538,20], + [167.75,1488298.333,31540,20], + [167.77,1488278.333,31539,20], + [168,1488338.333,31542,20], + [168.03,1488318.333,31541,20], + [168.36,1488378.333,31544,20], + [168.4,1488358.333,31543,20], + [168.53,1488398.333,31545,20], + [168.69,1488418.333,31546,20], + [168.85,1488438.333,31547,20], + [168.88,1488458.333,31548,20], + [168.98,1488478.333,31549,20], + [169.16,1488498.333,31550,20], + [169.31,1488518.333,31551,20], + [169.6,1488558.333,31553,20], + [169.63,1488538.333,31552,20], + [169.74,1488578.333,31554,20], + [170.05,1488618.333,31556,20], + [170.08,1488598.333,31555,20], + [170.43,1488638.333,31557,20], + [170.63,1488678.333,31559,20], + [170.77,1488658.333,31558,20], + [170.81,1488698.333,31560,20], + [171.03,1488718.333,31561,20], + [171.27,1488758.333,31563,20], + [171.3,1488738.333,31562,20], + [171.5,1488778.333,31564,20], + [171.73,1488798.333,31565,20], + [172.05,1488818.333,31566,20], + [172.09,1488838.333,31567,20], + [172.32,1488858.333,31568,20], + [172.42,1488898.333,31570,20], + [172.44,1488878.333,31569,20], + [173.07,1488918.333,31571,20], + [173.31,1488938.333,31572,20], + [173.38,1488958.333,31573,20], + [173.49,1488978.333,31574,20], + [173.67,1488998.333,31575,20], + [173.74,1489018.333,31576,20], + [173.91,1489038.333,31577,20], + [174.69,1489118.333,31581,20], + [174.75,1489098.333,31580,20], + [174.78,1489058.333,31578,20], + [174.84,1489138.333,31582,20], + [174.95,1489078.333,31579,20], + [175.03,1489158.333,31583,20], + [175.13,1489178.333,31584,20], + [175.41,1489198.333,31585,20], + [175.8,1489238.333,31587,20], + [175.88,1489218.333,31586,20], + [176,1489258.333,31588,20], + [176.12,1489278.333,31589,20], + [176.4,1489298.333,31590,20], + [176.46,1489318.333,31591,20], + [176.5,1489338.333,31592,20], + [176.63,1489358.333,31593,20], + [176.84,1489378.333,31594,20], + [177.08,1489418.333,31596,20], + [177.15,1489438.333,31597,20], + [177.22,1489458.333,31598,20], + [177.25,1489398.333,31595,20], + [177.39,1489478.333,31599,20], + [178.17,1489498.333,31600,20], + [178.25,1489518.333,31601,20], + [178.35,1489558.333,31603,20], + [178.38,1489538.333,31602,20], + [178.46,1489578.333,31604,20], + [178.64,1489598.333,31605,20], + [178.8,1489618.333,31606,20], + [178.85,1489638.333,31607,20], + [179.69,1489678.333,31609,20], + [179.74,1489658.333,31608,20], + [180.13,1489718.333,31611,20], + [180.21,1489698.333,31610,20], + [180.3,1489738.333,31612,20], + [180.35,1489758.333,31613,20], + [180.43,1489778.333,31614,20], + [180.75,1489818.333,31616,20], + [180.8,1489798.333,31615,20], + [182.62,1489838.333,31617,20], + [182.73,1489858.333,31618,20], + [182.81,1489878.333,31619,20], + [182.88,1489898.333,31620,20], + [183,1489918.333,31621,20], + [183.07,1489938.333,31622,20], + [183.16,1489958.333,31623,20], + [183.29,1489978.333,31624,20], + [183.37,1489998.333,31625,20], + [183.43,1490018.333,31626,20], + [184.49,1490038.333,31627,20], + [184.58,1490058.333,31628,20], + [184.66,1490078.333,31629,20], + [184.8,1490098.333,31630,20], + [184.87,1490138.333,31632,20], + [184.9,1490118.333,31631,20], + [185.02,1490158.333,31633,20], + [187.12,1490178.333,31634,20], + [189.97,1490198.333,31635,20], + [190.06,1490218.333,31636,20], + [190.13,1490238.333,31637,20], + [190.22,1490258.333,31638,20], + [191.72,1490478.333,31649,20], + [191.78,1490438.333,31647,20], + [191.88,1490498.333,31650,20], + [191.95,1490518.333,31651,20], + [192.03,1490418.333,31646,20], + [192.06,1490298.333,31640,20], + [192.14,1490378.333,31644,20], + [192.21,1490358.333,31643,20], + [192.27,1490318.333,31641,20], + [192.33,1490338.333,31642,20], + [192.38,1490278.333,31639,20], + [192.5,1490458.333,31648,20], + [192.63,1490398.333,31645,20], + [192.78,1490538.333,31652,20], + [193.1,1490558.333,31653,20], + [193.19,1490578.333,31654,20], + [193.26,1490598.333,31655,20], + [193.33,1490618.333,31656,20], + [193.47,1490638.333,31657,20], + [193.55,1490658.333,31658,20], + [193.61,1490678.333,31659,20], + [193.68,1490698.333,31660,20], + [193.74,1490718.333,31661,20], + [193.8,1490738.333,31662,20], + [193.88,1490758.333,31663,20], + [193.97,1490778.333,31664,20], + [194.08,1490798.333,31665,20], + [194.28,1490818.333,31666,20], + [194.28,1490838.333,31667,20], + [194.38,1490858.333,31668,20], + [194.46,1490878.333,31669,20], + [194.55,1490898.333,31670,20], + [195.43,1490918.333,31671,20], + [195.52,1490938.333,31672,20], + [195.59,1490958.333,31673,20], + [195.65,1490978.333,31674,20], + [195.72,1490998.333,31675,20], + [195.78,1491018.333,31676,20], + [195.94,1491058.333,31678,20], + [196,1491038.333,31677,20], + [196.15,1491078.333,31679,20], + [196.21,1491098.333,31680,20], + [196.6,1491138.333,31682,20], + [196.69,1491118.333,31681,20], + [196.77,1491158.333,31683,20], + [196.83,1491178.333,31684,20], + [196.97,1491198.333,31685,20], + [197.03,1491218.333,31686,20], + [197.13,1491238.333,31687,20], + [197.41,1491258.333,31688,20], + [197.52,1491278.333,31689,20], + [197.77,1491298.333,31690,20], + [198.08,1491318.333,31691,20], + [198.44,1491358.333,31693,20], + [198.53,1491338.333,31692,20], + [198.6,1491378.333,31694,20], + [198.67,1491398.333,31695,20], + [198.73,1491418.333,31696,20], + [198.91,1491438.333,31697,20], + [199.03,1491458.333,31698,20], + [199.48,1491498.333,31700,20], + [199.54,1491478.333,31699,20], + [199.6,1491518.333,31701,20], + [199.66,1491538.333,31702,20], + [199.8,1491558.333,31703,20], + [199.93,1491578.333,31704,20], + [200.19,1491598.333,31705,20], + [200.26,1491618.333,31706,20], + [200.35,1491638.333,31707,20], + [200.76,1491678.333,31709,20], + [200.78,1491658.333,31708,20], + [200.85,1491698.333,31710,20], + [200.93,1491718.333,31711,20], + [201.41,1491758.333,31713,20], + [201.45,1491738.333,31712,20], + [201.65,1491778.333,31714,20], + [201.92,1491818.333,31716,20], + [201.94,1491798.333,31715,20], + [202.06,1491838.333,31717,20], + [202.13,1491858.333,31718,20], + [202.22,1491878.333,31719,20], + [202.68,1491898.333,31720,20], + [202.79,1491938.333,31722,20], + [202.83,1491918.333,31721,20], + [202.93,1491958.333,31723,20], + [203.06,1491978.333,31724,20], + [203.28,1491998.333,31725,20], + [203.4,1492018.333,31726,20], + [203.53,1492038.333,31727,20], + [204.69,1492078.333,31729,20], + [204.81,1492058.333,31728,20], + [204.91,1492098.333,31730,20], + [204.97,1492118.333,31731,20], + [205.3,1492158.333,31733,20], + [205.41,1492138.333,31732,20], + [205.46,1492178.333,31734,20], + [205.59,1492198.333,31735,20], + [205.94,1492238.333,31737,20], + [206,1492218.333,31736,20], + [206.13,1492278.333,31739,20], + [206.18,1492258.333,31738,20], + [206.55,1492298.333,31740,20], + [206.8,1492338.333,31742,20], + [206.84,1492318.333,31741,20], + [207.24,1492398.333,31745,20], + [207.39,1492438.333,31747,20], + [207.7,1492378.333,31744,20], + [207.76,1492358.333,31743,20], + [207.84,1492458.333,31748,20], + [207.9,1492478.333,31749,20], + [207.97,1492418.333,31746,20], + [208.03,1492498.333,31750,20], + [208.08,1492518.333,31751,20], + [208.25,1492538.333,31752,20], + [208.66,1492558.333,31753,20], + [208.69,1492578.333,31754,20], + [208.84,1492618.333,31756,20], + [208.91,1492598.333,31755,20], + [209.56,1492638.333,31757,20], + [209.62,1492658.333,31758,20], + [209.66,1492678.333,31759,20], + [209.72,1492698.333,31760,20], + [209.87,1492718.333,31761,20], + [210.15,1492758.333,31763,20], + [210.18,1492738.333,31762,20], + [210.47,1492798.333,31765,20], + [210.5,1492778.333,31764,20], + [210.77,1492818.333,31766,20], + [210.8,1492838.333,31767,20], + [210.87,1492858.333,31768,20], + [211.24,1492898.333,31770,20], + [211.27,1492878.333,31769,20], + [211.9,1492938.333,31772,20], + [211.94,1492978.333,31774,20], + [212.44,1493038.333,31777,20], + [212.9,1493058.333,31778,20], + [212.99,1493078.333,31779,20], + [213.06,1493118.333,31781,20], + [213.27,1493158.333,31783,20], + [213.35,1493138.333,31782,20], + [213.97,1492918.333,31771,20], + [214.41,1492958.333,31773,20], + [214.47,1492998.333,31775,20], + [214.53,1493018.333,31776,20], + [215.46,1493098.333,31780,20], + [216.64,1493278.333,31789,20], + [216.73,1493318.333,31791,20], + [216.77,1493298.333,31790,20], + [216.81,1493258.333,31788,20], + [216.86,1493178.333,31784,20], + [216.91,1493238.333,31787,20], + [216.96,1493458.333,31798,20], + [217.01,1493418.333,31796,20], + [217.06,1493398.333,31795,20], + [217.14,1493218.333,31786,20], + [217.2,1493358.333,31793,20], + [217.26,1493378.333,31794,20], + [217.33,1493338.333,31792,20], + [217.68,1493518.333,31801,20], + [217.72,1493498.333,31800,20], + [217.75,1493438.333,31797,20], + [217.8,1493478.333,31799,20], + [217.83,1493198.333,31785,20], + [217.97,1493618.333,31806,20], + [218.03,1493638.333,31807,20], + [218.09,1493558.333,31803,20], + [218.16,1493578.333,31804,20], + [218.22,1493658.333,31808,20], + [218.27,1493598.333,31805,20], + [218.33,1493538.333,31802,20], + [218.38,1493718.333,31811,20], + [218.44,1493678.333,31809,20], + [218.49,1493698.333,31810,20], + [218.55,1493738.333,31812,20], + [218.62,1493778.333,31814,20], + [218.69,1493758.333,31813,20], + [218.91,1493798.333,31815,20], + [218.98,1493838.333,31817,20], + [219.06,1493858.333,31818,20], + [219.23,1493818.333,31816,20], + [219.29,1493878.333,31819,20], + [219.35,1493898.333,31820,20], + [219.43,1493918.333,31821,20], + [220.23,1493938.333,31822,20], + [220.31,1493958.333,31823,20], + [220.35,1493978.333,31824,20], + [220.43,1493998.333,31825,20], + [220.51,1494018.333,31826,20], + [220.69,1494038.333,31827,20], + [221.06,1494078.333,31829,20], + [221.12,1494058.333,31828,20], + [221.27,1494118.333,31831,20], + [221.3,1494098.333,31830,20], + [221.44,1494138.333,31832,20], + [221.61,1494158.333,31833,20], + [223.77,1494178.333,31834,20], + [223.88,1494238.333,31837,20], + [223.92,1494198.333,31835,20], + [223.98,1494218.333,31836,20], + [224.12,1494258.333,31838,20], + [224.25,1494298.333,31840,20], + [224.31,1494318.333,31841,20], + [224.35,1494278.333,31839,20], + [224.57,1494358.333,31843,20], + [224.65,1494338.333,31842,20], + [224.69,1494378.333,31844,20], + [224.85,1494398.333,31845,20], + [225.19,1494438.333,31847,20], + [225.24,1494418.333,31846,20], + [225.27,1494458.333,31848,20], + [225.41,1494498.333,31850,20], + [225.44,1494478.333,31849,20], + [225.81,1494538.333,31852,20], + [225.87,1494518.333,31851,20], + [225.9,1494558.333,31853,20], + [226.07,1494578.333,31854,20], + [226.13,1494598.333,31855,20], + [226.33,1494618.333,31856,20], + [226.64,1494658.333,31858,20], + [226.66,1494638.333,31857,20], + [226.96,1494698.333,31860,20], + [227,1494678.333,31859,20], + [227.28,1494738.333,31862,20], + [227.34,1494758.333,31863,20], + [227.37,1494718.333,31861,20], + [227.58,1494778.333,31864,20], + [227.63,1494798.333,31865,20], + [228.04,1494858.333,31868,20], + [228.1,1494818.333,31866,20], + [228.16,1494838.333,31867,20], + [228.4,1494878.333,31869,20], + [228.43,1494898.333,31870,20], + [228.74,1494938.333,31872,20], + [228.78,1494918.333,31871,20], + [228.88,1494978.333,31874,20], + [228.92,1494958.333,31873,20], + [229.01,1494998.333,31875,20], + [229.66,1495038.333,31877,20], + [229.72,1495018.333,31876,20], + [229.78,1495058.333,31878,20], + [229.88,1495078.333,31879,20], + [230.03,1495098.333,31880,20], + [230.22,1495118.333,31881,20], + [230.41,1495138.333,31882,20], + [230.49,1495158.333,31883,20], + [230.72,1495178.333,31884,20], + [230.94,1495198.333,31885,20], + [231.05,1495218.333,31886,20], + [231.25,1495238.333,31887,20], + [231.37,1495258.333,31888,20], + [231.63,1495278.333,31889,20], + [231.72,1495298.333,31890,20], + [231.84,1495318.333,31891,20], + [233.02,1495358.333,31893,20], + [233.08,1495338.333,31892,20], + [233.12,1495378.333,31894,20], + [233.19,1495398.333,31895,20], + [233.26,1495418.333,31896,20], + [233.31,1495438.333,31897,20], + [233.53,1495458.333,31898,20], + [233.6,1495478.333,31899,20], + [233.85,1495498.333,31900,20], + [233.98,1495518.333,31901,20], + [234.22,1495538.333,31902,20], + [234.37,1495558.333,31903,20], + [234.45,1495578.333,31904,20], + [234.65,1495598.333,31905,20], + [234.9,1495618.333,31906,20], + [235.08,1495638.333,31907,20], + [235.18,1495658.333,31908,20], + [235.46,1495678.333,31909,20], + [235.75,1495698.333,31910,20], + [235.83,1495718.333,31911,20], + [236.05,1495738.333,31912,20], + [236.08,1495758.333,31913,20], + [236.27,1495778.333,31914,20], + [236.53,1495798.333,31915,20], + [236.81,1495838.333,31917,20], + [236.87,1495818.333,31916,20], + [236.91,1495858.333,31918,20], + [236.97,1495878.333,31919,20], + [237.19,1495898.333,31920,20], + [237.31,1495918.333,31921,20], + [237.41,1495938.333,31922,20], + [237.53,1495958.333,31923,20], + [237.78,1495978.333,31924,20], + [237.9,1495998.333,31925,20], + [238.2,1496038.333,31927,20], + [238.22,1496018.333,31926,20], + [238.28,1496058.333,31928,20], + [241.17,1496078.333,31929,20], + [241.22,1496138.333,31932,20], + [241.26,1496118.333,31931,20], + [241.3,1496098.333,31930,20], + [241.38,1496158.333,31933,20], + [241.83,1496298.333,31940,20], + [241.88,1496318.333,31941,20], + [241.92,1496198.333,31935,20], + [241.97,1496258.333,31938,20], + [242,1496278.333,31939,20], + [242.04,1496218.333,31936,20], + [242.15,1496458.333,31948,20], + [242.19,1496358.333,31943,20], + [242.22,1496178.333,31934,20], + [242.27,1496398.333,31945,20], + [242.31,1496378.333,31944,20], + [242.35,1496238.333,31937,20], + [242.41,1496338.333,31942,20], + [242.46,1496438.333,31947,20], + [242.51,1496418.333,31946,20], + [242.74,1496478.333,31949,20], + [242.81,1496498.333,31950,20], + [242.87,1496518.333,31951,20], + [242.92,1496538.333,31952,20], + [243,1496558.333,31953,20], + [243.14,1496578.333,31954,20], + [243.14,1496598.333,31955,20], + [243.81,1496618.333,31956,20], + [243.89,1496638.333,31957,20], + [244.18,1496658.333,31958,20], + [244.44,1496678.333,31959,20], + [244.49,1496718.333,31961,20], + [244.51,1496698.333,31960,20], + [244.57,1496738.333,31962,20], + [244.79,1496778.333,31964,20], + [244.84,1496758.333,31963,20], + [244.98,1496798.333,31965,20], + [245.15,1496818.333,31966,20], + [245.24,1496838.333,31967,20], + [245.72,1496858.333,31968,20], + [246.47,1496878.333,31969,20], + [246.77,1496918.333,31971,20], + [246.78,1496898.333,31970,20], + [246.84,1496938.333,31972,20], + [246.91,1496958.333,31973,20], + [246.98,1496978.333,31974,20], + [248.03,1496998.333,31975,20], + [248.13,1497018.333,31976,20], + [248.22,1497038.333,31977,20], + [248.28,1497058.333,31978,20], + [248.34,1497078.333,31979,20], + [248.41,1497098.333,31980,20], + [248.46,1497118.333,31981,20], + [248.52,1497138.333,31982,20], + [248.59,1497178.333,31984,20], + [248.65,1497158.333,31983,20], + [248.75,1497198.333,31985,20], + [248.84,1497218.333,31986,20], + [249.54,1497258.333,31988,20], + [249.6,1497238.333,31987,20], + [249.66,1497278.333,31989,20], + [249.72,1497298.333,31990,20], + [249.76,1497318.333,31991,20], + [249.85,1497338.333,31992,20], + [250.08,1497378.333,31994,20], + [250.1,1497358.333,31993,20], + [250.23,1497398.333,31995,20], + [250.47,1497418.333,31996,20], + [250.65,1497438.333,31997,20], + [250.74,1497458.333,31998,20], + [250.84,1497478.333,31999,20], + [251.06,1497498.333,32000,20], + [251.13,1497518.333,32001,20], + [251.24,1497538.333,32002,20], + [251.49,1497558.333,32003,20], + [251.63,1497578.333,32004,20], + [254.22,1497658.333,32008,20], + [254.28,1497638.333,32007,20], + [254.32,1497738.333,32012,20], + [254.37,1497778.333,32014,20], + [254.41,1497758.333,32013,20], + [254.5,1497718.333,32011,20], + [254.53,1497618.333,32006,20], + [254.58,1497698.333,32010,20], + [254.62,1497678.333,32009,20], + [254.66,1497598.333,32005,20], + [254.88,1497818.333,32016,20], + [255.18,1497838.333,32017,20], + [255.44,1497858.333,32018,20], + [255.51,1497878.333,32019,20], + [256.13,1497798.333,32015,20], + [256.3,1497958.333,32023,20], + [256.37,1497898.333,32020,20], + [256.42,1497938.333,32022,20], + [256.44,1497918.333,32021,20], + [256.53,1497998.333,32025,20], + [256.55,1497978.333,32024,20], + [256.66,1498018.333,32026,20], + [256.97,1498058.333,32028,20], + [257,1498038.333,32027,20], + [257.05,1498078.333,32029,20], + [257.4,1498098.333,32030,20], + [257.47,1498118.333,32031,20], + [257.59,1498138.333,32032,20], + [257.65,1498158.333,32033,20], + [257.69,1498178.333,32034,20], + [257.84,1498198.333,32035,20], + [258.01,1498218.333,32036,20], + [258.46,1498238.333,32037,20], + [258.51,1498258.333,32038,20], + [258.58,1498278.333,32039,20], + [259.02,1498338.333,32042,20], + [259.09,1498318.333,32041,20], + [259.18,1498298.333,32040,20], + [259.22,1498358.333,32043,20], + [259.34,1498398.333,32045,20], + [259.38,1498378.333,32044,20], + [259.64,1498418.333,32046,20], + [259.67,1498438.333,32047,20], + [259.89,1498458.333,32048,20], + [260.03,1498478.333,32049,20], + [260.13,1498498.333,32050,20], + [260.24,1498518.333,32051,20], + [260.41,1498538.333,32052,20], + [260.8,1498558.333,32053,20], + [260.87,1498578.333,32054,20], + [261.06,1498618.333,32056,20], + [261.09,1498598.333,32055,20], + [261.37,1498638.333,32057,20], + [261.42,1498658.333,32058,20], + [261.5,1498678.333,32059,20], + [261.56,1498698.333,32060,20], + [261.66,1498718.333,32061,20], + [261.83,1498738.333,32062,20], + [261.85,1498758.333,32063,20], + [262.02,1498778.333,32064,20], + [262.31,1498798.333,32065,20], + [262.46,1498838.333,32067,20], + [262.49,1498818.333,32066,20], + [263.8,1498858.333,32068,20], + [263.94,1498898.333,32070,20], + [264.03,1498878.333,32069,20], + [264.09,1498918.333,32071,20], + [264.16,1498938.333,32072,20], + [264.46,1498958.333,32073,20], + [264.49,1498978.333,32074,20], + [264.55,1498998.333,32075,20], + [264.84,1499038.333,32077,20], + [264.89,1499018.333,32076,20], + [264.95,1499058.333,32078,20], + [265.06,1499078.333,32079,20], + [265.25,1499098.333,32080,20], + [265.47,1499118.333,32081,20], + [265.5,1499138.333,32082,20], + [266.08,1499158.333,32083,20], + [266.14,1499178.333,32084,20], + [266.38,1499198.333,32085,20], + [266.77,1499238.333,32087,20], + [266.85,1499258.333,32088,20], + [266.9,1499218.333,32086,20], + [266.96,1499278.333,32089,20], + [267.05,1499298.333,32090,20], + [267.25,1499318.333,32091,20], + [267.31,1499338.333,32092,20], + [267.5,1499358.333,32093,20], + [267.88,1499418.333,32096,20], + [267.91,1499398.333,32095,20], + [267.94,1499378.333,32094,20], + [268.31,1499438.333,32097,20], + [268.36,1499458.333,32098,20], + [268.44,1499478.333,32099,20], + [268.68,1499498.333,32100,20], + [268.72,1499518.333,32101,20], + [268.83,1499538.333,32102,20], + [269.13,1499558.333,32103,20], + [269.18,1499578.333,32104,20], + [269.4,1499618.333,32106,20], + [269.41,1499598.333,32105,20], + [269.85,1499678.333,32109,20], + [269.9,1499658.333,32108,20], + [269.96,1499638.333,32107,20], + [270.05,1499698.333,32110,20], + [270.19,1499718.333,32111,20], + [270.27,1499738.333,32112,20], + [270.35,1499758.333,32113,20], + [270.54,1499778.333,32114,20], + [270.63,1499798.333,32115,20], + [270.77,1499818.333,32116,20], + [270.96,1499838.333,32117,20], + [271.66,1499858.333,32118,20], + [271.73,1499878.333,32119,20], + [271.91,1499898.333,32120,20], + [272,1499918.333,32121,20], + [272.36,1499938.333,32122,20], + [272.41,1499958.333,32123,20], + [272.6,1499978.333,32124,20], + [272.66,1499998.333,32125,20], + [272.96,1500038.333,32127,20], + [272.99,1500018.333,32126,20], + [273.16,1500058.333,32128,20], + [273.33,1500078.333,32129,20], + [273.41,1500098.333,32130,20], + [273.64,1500118.333,32131,20], + [273.71,1500138.333,32132,20], + [274.47,1500158.333,32133,20], + [274.56,1500178.333,32134,20], + [274.61,1500198.333,32135,20], + [274.68,1500238.333,32137,20], + [274.74,1500218.333,32136,20], + [274.85,1500278.333,32139,20], + [274.91,1500258.333,32138,20], + [275.02,1500318.333,32141,20], + [275.07,1500298.333,32140,20], + [275.16,1500338.333,32142,20], + [275.21,1500358.333,32143,20], + [275.38,1500378.333,32144,20], + [275.61,1500398.333,32145,20], + [276.49,1500418.333,32146,20], + [276.91,1500458.333,32148,20], + [276.97,1500478.333,32149,20], + [277.04,1500438.333,32147,20], + [277.1,1500498.333,32150,20], + [277.16,1500518.333,32151,20], + [277.22,1500538.333,32152,20], + [277.48,1500578.333,32154,20], + [277.53,1500558.333,32153,20], + [277.79,1500618.333,32156,20], + [277.83,1500598.333,32155,20], + [287.6,1500638.333,32157,20], + [306.19,1500658.333,32158,20], + [326.97,1500678.333,32159,20], + [346.65,1500698.333,32160,20], + [366.87,1500718.333,32161,20], + [387.28,1500738.333,32162,20], + [407.16,1500758.333,32163,20], + [427.65,1500778.333,32164,20], + [447.6,1500798.333,32165,20], + [468.3,1500818.333,32166,20], + [488.6,1500838.333,32167,20], + [508.89,1500858.333,32168,20], + [542.25,1500878.333,32169,20], + [548.47,1500898.333,32170,20], + [568.29,1500918.333,32171,20], + [588.62,1500938.333,32172,20], + [608.41,1500958.333,32173,20], + [628.33,1500978.333,32174,20], + [648.34,1500998.333,32175,20], + [668.47,1501018.333,32176,20], + [688.54,1501038.333,32177,20], + [708.18,1501058.333,32178,20], + [728.68,1501078.333,32179,20], + [748.99,1501098.333,32180,20], + [768.6,1501118.333,32181,20], + [794.16,1501138.333,32182,20], + [807.59,1501158.333,32183,20], + [827.18,1501178.333,32184,20], + [849.25,1501198.333,32185,20], + [869.22,1501218.333,32186,20], + [888.84,1501238.333,32187,20], + [908.85,1501258.333,32188,20], + [928.22,1501278.333,32189,20], + [948.22,1501298.333,32190,20], + [968.19,1501318.333,32191,20], + [988.34,1501338.333,32192,20], + [1008.66,1501358.333,32193,20], + [1028,1501378.333,32194,20], + [1048.37,1501398.333,32195,20], + [1067.58,1501418.333,32196,20], + [1087.5,1501438.333,32197,20], + [1108.21,1501458.333,32198,20], + [1128.86,1501478.333,32199,20], + [1148.41,1501498.333,32200,20], + [1168.69,1501518.333,32201,20], + [1189.81,1501538.333,32202,20], + [1208.7,1501558.333,32203,20], + [1229.15,1501578.333,32204,20], + [1249.53,1501598.333,32205,20], + [1268.21,1501618.333,32206,20], + [1288.72,1501638.333,32207,20], + [1309.23,1501658.333,32208,20], + [1328.75,1501678.333,32209,20], + [1348.28,1501698.333,32210,20], + [1368.71,1501718.333,32211,20], + [1387.3,1501738.333,32212,20], + [1408.12,1501758.333,32213,20], + [1428.26,1501778.333,32214,20], + [1447.85,1501798.333,32215,20], + [1468.35,1501818.333,32216,20], + [1488.56,1501838.333,32217,20], + [1508.36,1501858.333,32218,20], + [1529.41,1501878.333,32219,20], + [1548.75,1501898.333,32220,20], + [1568.77,1501918.333,32221,20], + [1588.16,1501938.333,32222,20], + [1608.35,1501958.333,32223,20], + [1629.02,1501978.333,32224,20], + [1648.25,1501998.333,32225,20], + [1668.3,1502018.333,32226,20], + [1688.34,1502038.333,32227,20], + [1708.62,1502058.333,32228,20], + [1728.94,1502078.333,32229,20], + [1748.69,1502098.333,32230,20], + [1769.21,1502118.333,32231,20], + [1788.77,1502138.333,32232,20], + [1808.22,1502158.333,32233,20], + [1831.47,1502178.333,32234,20], + [1848.65,1502198.333,32235,20], + [1869.25,1502218.333,32236,20], + [1888.97,1502238.333,32237,20], + [1909.41,1502258.333,32238,20], + [1928.91,1502278.333,32239,20], + [1949.27,1502298.333,32240,20], + [1969.32,1502318.333,32241,20], + [1989.34,1502338.333,32242,20], + [2009.13,1502358.333,32243,20], + [2029.12,1502378.333,32244,20], + [2048.48,1502398.333,32245,20], + [2068.34,1502418.333,32246,20], + [2089.06,1502438.333,32247,20], + [2108.65,1502458.333,32248,20], + [2128.59,1502478.333,32249,20], + [2149.21,1502498.333,32250,20], + [2168.49,1502518.333,32251,20], + [2187.38,1502538.333,32252,20], + [2208.17,1502558.333,32253,20], + [2228.15,1502578.333,32254,20], + [2248.12,1502598.333,32255,20], + [2268.53,1502618.333,32256,20], + [2288.3,1502638.333,32257,20], + [2308.4,1502658.333,32258,20], + [2328.44,1502678.333,32259,20], + [2348.47,1502698.333,32260,20], + [2368.5,1502718.333,32261,20], + [2388.41,1502738.333,32262,20], + [2408.56,1502758.333,32263,20], + [2429.16,1502778.333,32264,20], + [2448.43,1502798.333,32265,20], + [2468.13,1502818.333,32266,20], + [2488.06,1502838.333,32267,20], + [2508.25,1502858.333,32268,20], + [2528.75,1502878.333,32269,20], + [2548.35,1502898.333,32270,20], + [2568.24,1502918.333,32271,20], + [2588.39,1502938.333,32272,20], + [2608.53,1502958.333,32273,20], + [2628.4,1502978.333,32274,20], + [2647.94,1502998.333,32275,20], + [2668.08,1503018.333,32276,20], + [2688.22,1503038.333,32277,20], + [2708.49,1503058.333,32278,20], + [2728.44,1503078.333,32279,20], + [2749.72,1503098.333,32280,20], + [2767.45,1503118.332,32280,20], + [2788.83,1503138.332,32281,20], + [2809.25,1503158.332,32282,20], + [2828.47,1503178.332,32283,20], + [2848.53,1503198.332,32284,20], + [2868.52,1503218.332,32285,20], + [2888.39,1503238.332,32286,20], + [2908.22,1503258.332,32287,20], + [2928.58,1503278.332,32288,20], + [2948.13,1503298.332,32289,20], + [2967.93,1503318.332,32290,20], + [2988.56,1503338.332,32291,20], + [3008.43,1503358.332,32292,20], + [3029.97,1503378.332,32293,20], + [3049.19,1503398.332,32294,20], + [3068.4,1503418.332,32295,20], + [3088.37,1503438.332,32296,20], + [3108.27,1503458.332,32297,20], + [3128.34,1503478.332,32298,20], + [3148.69,1503498.332,32299,20], + [3168.08,1503518.332,32300,20], + [3188.88,1503538.332,32301,20], + [3208.59,1503558.332,32302,20], + [3228.78,1503578.332,32303,20], + [3248.98,1503598.332,32304,20], + [3269.22,1503618.332,32305,20], + [3289.62,1503638.332,32306,20], + [3308.46,1503658.332,32307,20], + [3328.62,1503678.332,32308,20], + [3348.6,1503698.332,32309,20], + [3376.28,1503718.332,32310,20], + [3390.53,1503738.332,32311,20], + [3409.44,1503758.332,32312,20], + [3429.78,1503778.332,32313,20], + [3451.56,1503798.332,32314,20], + [3469.24,1503818.332,32315,20], + [3491.07,1503838.332,32316,20], + [3512.18,1503858.332,32317,20], + [3533.87,1503878.332,32318,20], + [3553.91,1503898.333,32319,20], + [3571.03,1503918.333,32320,20], + [3591.63,1503938.333,32321,20], + [3609.23,1503958.333,32322,20], + [3632.94,1503978.333,32323,20], + [3659.35,1503998.333,32324,20], + [3673.17,1504018.333,32325,20], + [3693.55,1504038.333,32326,20], + [3736.7,1504058.333,32327,20], + [3736.89,1504078.333,32328,20], + [3750.24,1504098.333,32329,20], + [3768.33,1504118.333,32330,20], + [3788.34,1504138.333,32331,20], + [3808.6,1504158.333,32332,20], + [3828.69,1504178.333,32333,20], + [3848.01,1504198.333,32334,20], + [3869.19,1504218.333,32335,20], + [3889.16,1504238.333,32336,20], + [3908.84,1504258.333,32337,20], + [3929.28,1504278.333,32338,20], + [3948.28,1504298.333,32339,20], + [3968.25,1504318.333,32340,20], + [3988.97,1504338.333,32341,20], + [4009.37,1504358.333,32342,20], + [4029.08,1504378.333,32343,20], + [4049.16,1504398.333,32344,20], + [4068.83,1504418.333,32345,20], + [4089.25,1504438.333,32346,20], + [4109.72,1504458.333,32347,20], + [4131.06,1504478.333,32348,20], + [4148.85,1504498.333,32349,20], + [4168.79,1504518.333,32350,20], + [4191.18,1504538.333,32351,20], + [4208.94,1504558.333,32352,20], + [4229.38,1504578.333,32353,20], + [4248.41,1504598.333,32354,20], + [4268.78,1504618.333,32355,20], + [4288.31,1504638.333,32356,20], + [4307.74,1504658.333,32357,20], + [4330.13,1504678.333,32358,20], + [4348.05,1504698.333,32359,20], + [4367.5,1504718.333,32360,20], + [4387.91,1504738.333,32361,20], + [4408.5,1504758.333,32362,20], + [4428.58,1504778.333,32363,20], + [4448.73,1504798.333,32364,20], + [4468.47,1504818.333,32365,20], + [4488.45,1504838.333,32366,20], + [4508.46,1504858.333,32367,20], + [4528.85,1504878.333,32368,20], + [4548.49,1504898.333,32369,20], + [4568.47,1504918.333,32370,20], + [4588.94,1504938.333,32371,20], + [4608.68,1504958.333,32372,20], + [4628.78,1504978.333,32373,20], + [4648.31,1504998.333,32374,20], + [4669.14,1505018.333,32375,20], + [4688.33,1505038.333,32376,20], + [4708.58,1505058.333,32377,20], + [4728.81,1505078.333,32378,20], + [4748.53,1505098.333,32379,20], + [4769.04,1505118.333,32380,20], + [4788.89,1505138.333,32381,20], + [4808.59,1505158.333,32382,20], + [4828.48,1505178.333,32383,20], + [4848.76,1505198.333,32384,20], + [4868.73,1505218.333,32385,20], + [4888.2,1505238.333,32386,20], + [4908.68,1505258.333,32387,20], + [4928.58,1505278.333,32388,20], + [4948.77,1505298.333,32389,20], + [4968.68,1505318.333,32390,20], + [4988.31,1505338.333,32391,20], + [5008.15,1505358.333,32392,20], + [5028.55,1505378.333,32393,20], + [5048.6,1505398.333,32394,20], + [5069.18,1505418.333,32395,20], + [5088.93,1505438.333,32396,20], + [5108.41,1505458.333,32397,20], + [5128.19,1505478.333,32398,20], + [5148.3,1505498.333,32399,20], + [5169.16,1505518.333,32400,20], + [5188.9,1505538.333,32401,20], + [5207.87,1505558.333,32402,20], + [5227.77,1505578.333,32403,20], + [5248.38,1505598.333,32404,20], + [5268.43,1505618.333,32405,20], + [5289.15,1505638.333,32406,20], + [5307.97,1505658.333,32407,20], + [5328.81,1505678.333,32408,20], + [5349.09,1505698.333,32409,20], + [5369.09,1505718.333,32410,20], + [5388.69,1505738.333,32411,20], + [5409.27,1505758.333,32412,20], + [5428.38,1505778.333,32413,20], + [5447.66,1505798.333,32414,20], + [5469.41,1505818.333,32415,20], + [5489.18,1505838.333,32416,20], + [5508.91,1505858.333,32417,20], + [5528.49,1505878.333,32418,20], + [5548.55,1505898.333,32419,20], + [5568.76,1505918.333,32420,20], + [5588.99,1505938.333,32421,20], + [5608.69,1505958.333,32422,20], + [5627.95,1505978.333,32423,20], + [5648.61,1505998.333,32424,20], + [5668.21,1506018.333,32425,20], + [5688.15,1506038.333,32426,20], + [5708.12,1506058.333,32427,20], + [5728.3,1506078.333,32428,20], + [5748.28,1506098.333,32429,20], + [5768.31,1506118.333,32430,20], + [5789.1,1506138.333,32431,20], + [5808.58,1506158.333,32432,20], + [5828.33,1506178.333,32433,20], + [5848.47,1506198.333,32434,20], + [5868.45,1506218.333,32435,20], + [5888.88,1506238.333,32436,20], + [5909.09,1506258.333,32437,20], + [5928.2,1506278.333,32438,20], + [5949.23,1506298.333,32439,20], + [5968.49,1506318.333,32440,20], + [5988.65,1506338.333,32441,20], + [6008.35,1506358.333,32442,20], + [6028.53,1506378.333,32443,20], + [6049.81,1506398.333,32444,20], + [6068.3,1506418.333,32445,20], + [6089.06,1506438.333,32446,20], + [6108.71,1506458.333,32447,20], + [6128.96,1506478.333,32448,20], + [6148.5,1506498.333,32449,20], + [6168.24,1506518.333,32450,20], + [6188.95,1506538.333,32451,20], + [6208.47,1506558.333,32452,20], + [6228.38,1506578.333,32453,20], + [6248.35,1506598.333,32454,20], + [6268.28,1506618.333,32455,20], + [6288.22,1506638.333,32456,20], + [6308.66,1506658.333,32457,20], + [6328.44,1506678.333,32458,20], + [6348.94,1506698.333,32459,20], + [6368.44,1506718.333,32460,20], + [6390.09,1506738.333,32461,20], + [6409.04,1506758.333,32462,20], + [6427.91,1506778.333,32463,20], + [6448.1,1506798.333,32464,20], + [6468.72,1506818.333,32465,20], + [6488.14,1506838.333,32466,20], + [6508.28,1506858.333,32467,20], + [6529.27,1506878.333,32468,20], + [6550.44,1506898.333,32469,20], + [6568.97,1506918.333,32470,20], + [6588.56,1506938.333,32471,20], + [6608.59,1506958.333,32472,20], + [6628.21,1506978.333,32473,20], + [6648.27,1506998.333,32474,20], + [6668.44,1507018.333,32475,20], + [6688.25,1507038.333,32476,20], + [6708.4,1507058.333,32477,20], + [6728.5,1507078.333,32478,20], + [6752.21,1507098.333,32479,20], + [6768.83,1507118.333,32480,20], + [6789.02,1507138.333,32481,20], + [6809.13,1507158.333,32482,20], + [6828.28,1507178.333,32483,20], + [6848.22,1507198.333,32484,20], + [6868.61,1507218.333,32485,20], + [6888.5,1507238.333,32486,20], + [6909.02,1507258.333,32487,20], + [6931.46,1507278.333,32488,20], + [6948.34,1507298.333,32489,20], + [6968.48,1507318.333,32490,20], + [6988.85,1507338.333,32491,20], + [7008.61,1507358.333,32492,20], + [7028.27,1507378.333,32493,20], + [7048.3,1507398.333,32494,20], + [7068.59,1507418.333,32495,20], + [7088.59,1507438.333,32496,20], + [7108.3,1507458.333,32497,20], + [7128.41,1507478.333,32498,20], + [7148.63,1507498.333,32499,20], + [7168.64,1507518.333,32500,20], + [7189.34,1507538.333,32501,20], + [7208.96,1507558.333,32502,20], + [7229.19,1507578.333,32503,20], + [7248.39,1507598.333,32504,20], + [7268.46,1507618.333,32505,20], + [7288.5,1507638.333,32506,20], + [7308.46,1507658.333,32507,20], + [7328.66,1507678.333,32508,20], + [7348.59,1507698.333,32509,20], + [7373.81,1507718.333,32510,20], + [7393.84,1507738.333,32511,20], + [7412.12,1507758.333,32512,20], + [7443.01,1507778.333,32513,20], + [7466.41,1507798.333,32514,20], + [7483.95,1507818.333,32515,20], + [7508.12,1507838.333,32516,20], + [7508.25,1507858.333,32517,20], + [7529.08,1507878.333,32518,20], + [7553.95,1507898.333,32519,20], + [7588.32,1507918.333,32520,20], + [7588.45,1507938.333,32521,20], + [7617.75,1507958.333,32522,20], + [7639.33,1507978.333,32523,20], + [7656.42,1507998.333,32524,20], + [7669.24,1508018.333,32525,20], + [7696.09,1508038.333,32526,20], + [7714.35,1508058.333,32527,20], + [7738.5,1508078.333,32528,20], + [7759.84,1508098.333,32529,20], + [7768.16,1508118.333,32530,20], + [7795.47,1508138.333,32531,20], + [7808.64,1508158.333,32532,20], + [7828.44,1508178.333,32533,20], + [7848.08,1508198.333,32534,20], + [7869.94,1508218.333,32535,20], + [7890.17,1508238.333,32536,20], + [7908.45,1508258.333,32537,20], + [7947.13,1508278.333,32538,20], + [7947.88,1508298.333,32539,20], + [7969,1508318.333,32540,20], + [7988.7,1508338.333,32541,20], + [8008.22,1508358.333,32542,20], + [8029.03,1508378.333,32543,20], + [8048.28,1508398.333,32544,20], + [8068.78,1508418.333,32545,20], + [8088.43,1508438.333,32546,20], + [8108.34,1508458.333,32547,20], + [8128.92,1508478.333,32548,20], + [8149.06,1508498.333,32549,20], + [8168.4,1508518.333,32550,20], + [8189.09,1508538.333,32551,20], + [8209.75,1508558.333,32552,20], + [8229.44,1508578.333,32553,20], + [8248.28,1508598.333,32554,20], + [8268.75,1508618.333,32555,20], + [8289.08,1508638.333,32556,20], + [8308.33,1508658.333,32557,20], + [8328.46,1508678.333,32558,20], + [8348.66,1508698.333,32559,20], + [8368.36,1508718.333,32560,20], + [8388.22,1508738.333,32561,20], + [8408.81,1508758.333,32562,20], + [8428.22,1508778.333,32563,20], + [8447.84,1508798.333,32564,20], + [8468.52,1508818.333,32565,20], + [8488.24,1508838.333,32566,20], + [8508.28,1508858.333,32567,20], + [8528.91,1508878.333,32568,20], + [8548.74,1508898.333,32569,20], + [8568.6,1508918.333,32570,20], + [8588.66,1508938.333,32571,20], + [8608.3,1508958.333,32572,20], + [8628.59,1508978.333,32573,20], + [8648.51,1508998.333,32574,20], + [8669.17,1509018.333,32575,20], + [8689.57,1509038.333,32576,20], + [8709.03,1509058.333,32577,20], + [8728.88,1509078.333,32578,20], + [8749.28,1509098.333,32579,20], + [8769.12,1509118.333,32580,20], + [8789.41,1509138.333,32581,20], + [8808.81,1509158.333,32582,20], + [8828.68,1509178.333,32583,20], + [8848.53,1509198.333,32584,20], + [8868.58,1509218.333,32585,20], + [8889.37,1509238.333,32586,20], + [8908.91,1509258.333,32587,20], + [8929.03,1509278.333,32588,20], + [8948.63,1509298.333,32589,20], + [8968.5,1509318.333,32590,20], + [8988.78,1509338.333,32591,20], + [9009.33,1509358.333,32592,20], + [9029.32,1509378.333,32593,20], + [9048.47,1509398.333,32594,20], + [9068.88,1509418.333,32595,20], + [9088.78,1509438.333,32596,20], + [9108.44,1509458.333,32597,20], + [9128.94,1509478.333,32598,20], + [9148.95,1509498.333,32599,20], + [9168.96,1509518.333,32600,20], + [9190.13,1509538.333,32601,20], + [9208.35,1509558.333,32602,20], + [9228.59,1509578.333,32603,20], + [9249.12,1509598.333,32604,20], + [9269.91,1509618.333,32605,20], + [9289.59,1509638.333,32606,20], + [9310.03,1509658.333,32607,20], + [9329.1,1509678.333,32608,20], + [9349.27,1509698.333,32609,20], + [9369.25,1509718.333,32610,20], + [9389.81,1509738.333,32611,20], + [9409.17,1509758.333,32612,20], + [9427.93,1509778.333,32613,20], + [9448.98,1509798.333,32614,20], + [9469.25,1509818.333,32615,20], + [9489.58,1509838.333,32616,20], + [9509.72,1509858.333,32617,20], + [9528.56,1509878.333,32618,20], + [9549.02,1509898.333,32619,20], + [9568.47,1509918.333,32620,20], + [9588.93,1509938.333,32621,20], + [9608.28,1509958.333,32622,20], + [9628.73,1509978.333,32623,20], + [9648.86,1509998.333,32624,20], + [9668.29,1510018.333,32625,20], + [9688.06,1510038.333,32626,20], + [9708.18,1510058.333,32627,20], + [9728.46,1510078.333,32628,20], + [9748.59,1510098.333,32629,20], + [9768.58,1510118.333,32630,20], + [9788.89,1510138.333,32631,20], + [9807.87,1510158.333,32632,20], + [9828.5,1510178.333,32633,20], + [9848.25,1510198.333,32634,20], + [9868.29,1510218.333,32635,20], + [9888.33,1510238.333,32636,20], + [9908.2,1510258.333,32637,20], + [9928.12,1510278.333,32638,20], + [9948.63,1510298.333,32639,20], + [9968.19,1510318.333,32640,20], + [9988.55,1510338.333,32641,20], + [10008.63,1510358.333,32642,20], + [10028.47,1510378.333,32643,20], + [10048.71,1510398.333,32644,20], + [10068.5,1510418.333,32645,20], + [10089.09,1510438.333,32646,20], + [10108.91,1510458.333,32647,20], + [10128.23,1510478.333,32648,20], + [10148.73,1510498.333,32649,20], + [10168.58,1510518.333,32650,20], + [10189.08,1510538.333,32651,20], + [10208.81,1510558.333,32652,20], + [10229.03,1510578.333,32653,20], + [10248.37,1510598.333,32654,20], + [10268.76,1510618.333,32655,20], + [10288.55,1510638.333,32656,20], + [10308.31,1510658.333,32657,20], + [10327.58,1510678.333,32658,20], + [10348.78,1510698.333,32659,20], + [10368.37,1510718.333,32660,20], + [10388.15,1510738.333,32661,20], + [10408.5,1510758.333,32662,20], + [10435.86,1510778.333,32663,20], + [10448.39,1510798.333,32664,20], + [10468.38,1510818.333,32665,20], + [10488.44,1510838.333,32666,20], + [10508.57,1510858.333,32667,20], + [10528.47,1510878.333,32668,20], + [10548.63,1510898.333,32669,20], + [10568.32,1510918.333,32670,20], + [10589,1510938.333,32671,20], + [10608.62,1510958.333,32672,20], + [10627.66,1510978.333,32673,20], + [10648.03,1510998.333,32674,20], + [10668.44,1511018.333,32675,20], + [10689.03,1511038.333,32676,20], + [10708.17,1511058.333,32677,20], + [10728.3,1511078.333,32678,20], + [10748.64,1511098.333,32679,20], + [10768.58,1511118.333,32680,20], + [10788.23,1511138.333,32681,20], + [10808.59,1511158.333,32682,20], + [10828.29,1511178.333,32683,20], + [10848.96,1511198.333,32684,20], + [10868.2,1511218.333,32685,20], + [10888.38,1511238.333,32686,20], + [10908.5,1511258.333,32687,20], + [10928.35,1511278.333,32688,20], + [10948.49,1511298.333,32689,20], + [10968.4,1511318.333,32690,20], + [10988.94,1511338.333,32691,20], + [11008.25,1511358.333,32692,20], + [11028.31,1511378.333,32693,20], + [11048.05,1511398.333,32694,20], + [11068.88,1511418.333,32695,20], + [11088.79,1511438.333,32696,20], + [11108.31,1511458.333,32697,20], + [11127.88,1511478.333,32698,20], + [11148.13,1511498.333,32699,20], + [11168.16,1511518.333,32700,20], + [11189.11,1511538.333,32701,20], + [11208.88,1511558.333,32702,20], + [11229.97,1511578.333,32703,20], + [11249.28,1511598.333,32704,20], + [11268.28,1511618.333,32705,20], + [11288.38,1511638.333,32706,20], + [11308.99,1511658.333,32707,20], + [11328.15,1511678.333,32708,20], + [11350.68,1511698.333,32709,20], + [11374.12,1511718.333,32710,20], + [11391.63,1511738.333,32711,20], + [11409,1511758.333,32712,20], + [11433.52,1511778.333,32713,20], + [11449.65,1511798.333,32714,20], + [11476.32,1511818.333,32715,20], + [11488.98,1511838.333,32716,20], + [11515.63,1511858.333,32717,20], + [11528.25,1511878.333,32718,20], + [11548.41,1511898.333,32719,20], + [11582.13,1511918.333,32720,20], + [11588.53,1511938.333,32721,20], + [11615.15,1511958.333,32722,20], + [11632.66,1511978.333,32723,20], + [11664.9,1511998.333,32724,20], + [11668.05,1512018.333,32725,20], + [11730.39,1512038.333,32726,20], + [11730.5,1512058.333,32727,20], + [11730.56,1512078.333,32728,20], + [11751.56,1512098.333,32729,20], + [11769.96,1512118.333,32730,20], + [11788.34,1512138.333,32731,20], + [11808.18,1512158.333,32732,20], + [11827.93,1512178.333,32733,20], + [11847.87,1512198.333,32734,20], + [11868.28,1512218.333,32735,20], + [11889.05,1512238.333,32736,20], + [11908.33,1512258.333,32737,20], + [11928.35,1512278.333,32738,20], + [11948.59,1512298.333,32739,20], + [11968.24,1512318.333,32740,20], + [11989,1512338.333,32741,20], + [12011.52,1512358.333,32742,20], + [12029,1512378.333,32743,20], + [12049.06,1512398.333,32744,20], + [12072.28,1512418.333,32745,20], + [12090.77,1512438.333,32746,20], + [12108.72,1512458.333,32747,20], + [12129.11,1512478.333,32748,20], + [12149.69,1512498.333,32749,20], + [12169.28,1512518.333,32750,20], + [12189.08,1512538.333,32751,20], + [12209.11,1512558.333,32752,20], + [12230.44,1512578.333,32753,20], + [12249.08,1512598.333,32754,20], + [12270.41,1512618.333,32755,20], + [12290.39,1512638.333,32756,20], + [12309.38,1512658.333,32757,20], + [12329.5,1512678.333,32758,20], + [12349.27,1512698.333,32759,20], + [12369,1512718.333,32760,20], + [12389.37,1512738.333,32761,20], + [12408.79,1512758.333,32762,20], + [12428.69,1512778.333,32763,20], + [12448.5,1512798.333,32764,20], + [12470.85,1512818.333,32765,20], + [12488.37,1512838.333,32766,20], + [12509.46,1512858.333,32767,20], + [12529.59,1512878.333,32768,20], + [12551.47,1512898.333,32769,20], + [12569.72,1512918.333,32770,20], + [12589.01,1512938.333,32771,20], + [12608.84,1512958.333,32772,20], + [12628.97,1512978.333,32773,20], + [12649.69,1512998.333,32774,20], + [12669.8,1513018.333,32775,20], + [12689.05,1513038.333,32776,20], + [12709.6,1513058.333,32777,20], + [12730.07,1513078.333,32778,20], + [12748.94,1513098.333,32779,20], + [12770.18,1513118.333,32780,20], + [12790.37,1513138.333,32781,20], + [12809,1513158.333,32782,20], + [12829.15,1513178.333,32783,20], + [12849.13,1513198.333,32784,20], + [12871.15,1513218.333,32785,20], + [12890.71,1513238.333,32786,20], + [12909.27,1513258.333,32787,20], + [12935.16,1513278.333,32788,20], + [12951.16,1513298.333,32789,20], + [12976.23,1513318.333,32790,20], + [12988.82,1513338.333,32791,20], + [13010.13,1513358.333,32792,20], + [13028.91,1513378.333,32793,20], + [13049.62,1513398.333,32794,20], + [13070.16,1513418.333,32795,20], + [13092.22,1513438.333,32796,20], + [13113.33,1513458.333,32797,20], + [13128.65,1513478.333,32798,20], + [13162.44,1513498.333,32799,20], + [13173.28,1513518.333,32800,20], + [13190.96,1513538.333,32801,20], + [13209.75,1513558.333,32802,20], + [13233.08,1513578.333,32803,20], + [13249.85,1513598.333,32804,20], + [13269.1,1513618.333,32805,20], + [13289.53,1513638.333,32806,20], + [13308.92,1513658.333,32807,20], + [13332.27,1513678.333,32808,20], + [13355.05,1513698.333,32809,20], + [13369.33,1513718.333,32810,20], + [13390.3,1513738.333,32811,20], + [13410.25,1513758.333,32812,20], + [13431.85,1513778.333,32813,20], + [13449.26,1513798.333,32814,20], + [13469.8,1513818.333,32815,20], + [13491.34,1513838.333,32816,20], + [13510.74,1513858.333,32817,20], + [13528.1,1513878.333,32818,20], + [13548.97,1513898.333,32819,20], + [13570.44,1513918.333,32820,20], + [13589.42,1513938.333,32821,20], + [13608.75,1513958.333,32822,20], + [13629.51,1513978.333,32823,20], + [13649.19,1513998.333,32824,20], + [13669.07,1514018.333,32825,20], + [13689.28,1514038.333,32826,20], + [13711.27,1514058.333,32827,20], + [13730.66,1514078.333,32828,20], + [13751.55,1514098.333,32829,20], + [13769.03,1514118.333,32830,20], + [13790.06,1514138.333,32831,20], + [13811.21,1514158.333,32832,20], + [13829.6,1514178.333,32833,20], + [13848.84,1514198.333,32834,20], + [13868.59,1514218.333,32835,20], + [13889.08,1514238.333,32836,20], + [13908.63,1514258.333,32837,20], + [13929.09,1514278.333,32838,20], + [13949.99,1514298.333,32839,20], + [13971.38,1514318.333,32840,20], + [13989.41,1514338.333,32841,20], + [14009.24,1514358.333,32842,20], + [14029.13,1514378.333,32843,20], + [14049.21,1514398.333,32844,20], + [14070.02,1514418.333,32845,20], + [14089.16,1514438.333,32846,20], + [14109,1514458.333,32847,20], + [14129.84,1514478.333,32848,20], + [14149.77,1514498.333,32849,20], + [14168.98,1514518.333,32850,20], + [14190.41,1514538.333,32851,20], + [14209.5,1514558.333,32852,20], + [14229.29,1514578.333,32853,20], + [14248.78,1514598.333,32854,20], + [14269.03,1514618.333,32855,20], + [14288.66,1514638.333,32856,20], + [14308.4,1514658.333,32857,20], + [14329.75,1514678.333,32858,20], + [14349.25,1514698.333,32859,20], + [14370.5,1514718.333,32860,20], + [14391.84,1514738.333,32861,20], + [14408.98,1514758.333,32862,20], + [14429.09,1514778.333,32863,20], + [14448.64,1514798.333,32864,20], + [14469.1,1514818.333,32865,20], + [14489.44,1514838.333,32866,20], + [14509.63,1514858.333,32867,20], + [14528.94,1514878.333,32868,20], + [14548.48,1514898.333,32869,20], + [14569.14,1514918.333,32870,20], + [14589.56,1514938.333,32871,20], + [14609.59,1514958.333,32872,20], + [14629.22,1514978.333,32873,20], + [14649.4,1514998.333,32874,20], + [14669.66,1515018.333,32875,20], + [14689.47,1515038.333,32876,20], + [14709.34,1515058.333,32877,20], + [14729.31,1515078.333,32878,20], + [14750.03,1515098.333,32879,20], + [14768.94,1515118.333,32880,20], + [14789.77,1515138.333,32881,20], + [14809.16,1515158.333,32882,20], + [14833.28,1515178.333,32883,20], + [14862.34,1515198.333,32884,20], + [14877.71,1515218.333,32885,20], + [14892.68,1515238.333,32886,20], + [14925.88,1515258.333,32887,20], + [14930.94,1515278.333,32888,20], + [14951.63,1515298.333,32889,20], + [14970.54,1515318.333,32890,20], + [16500.67,1515338.333,32891,20], + [16504.67,1515358.333,32892,20], + [16515.06,1515378.333,32893,20], + [16525.16,1515398.333,32894,20], + [16561.92,1515438.333,32896,20], + [16562.1,1515458.333,32897,20], + [16562.15,1515418.333,32895,20], + [16567.33,1515478.333,32898,20], + [16575.31,1515498.333,32899,20], + [16588.7,1515518.333,32900,20], + [16595.6,1515538.333,32901,20], + [16613.15,1515558.333,32902,20], + [16617.96,1515578.333,32903,20], + [16624.91,1515598.333,32904,20], + [16634.71,1515618.333,32905,20], + [16644.67,1515638.333,32906,20], + [16654.4,1515658.333,32907,20], + [16664.39,1515678.333,32908,20], + [16675.23,1515698.333,32909,20], + [16684.44,1515718.333,32910,20], + [16694.42,1515738.333,32911,20], + [16704.6,1515758.333,32912,20], + [16714.26,1515778.333,32913,20], + [16724.4,1515798.333,32914,20], + [16734.47,1515818.333,32915,20], + [16747.01,1515838.333,32916,20], + [16754.79,1515858.333,32917,20], + [16765.26,1515878.333,32918,20], + [16775.84,1515898.333,32919,20], + [16786.67,1515918.333,32920,20], + [16797.15,1515938.333,32921,20], + [16805.95,1515958.333,32922,20], + [16814.26,1515978.333,32923,20], + [16824.06,1515998.333,32924,20], + [16834.78,1516018.333,32925,20], + [16844.47,1516038.333,32926,20], + [16855.33,1516058.333,32927,20], + [16864.44,1516078.333,32928,20], + [16874.9,1516098.333,32929,20], + [16884.01,1516118.333,32930,20], + [16894.71,1516138.333,32931,20], + [16904.4,1516158.333,32932,20], + [16914.47,1516178.333,32933,20], + [16924.51,1516198.333,32934,20], + [16934.51,1516218.333,32935,20], + [16944.42,1516238.333,32936,20], + [16954.31,1516258.333,32937,20], + [16964.19,1516278.333,32938,20], + [16975.46,1516298.333,32939,20], + [16984.61,1516318.333,32940,20], + [16994.51,1516338.333,32941,20], + [17004.53,1516358.333,32942,20], + [17015.08,1516378.333,32943,20], + [17024.47,1516398.333,32944,20], + [17034.87,1516418.333,32945,20], + [17044.6,1516438.333,32946,20], + [17054.6,1516458.333,32947,20], + [17064.78,1516478.333,32948,20], + [17074.33,1516498.333,32949,20], + [17084.06,1516518.333,32950,20], + [17094.36,1516538.333,32951,20], + [17104.15,1516558.333,32952,20], + [17115.03,1516578.333,32953,20], + [17124.79,1516598.333,32954,20], + [17134.74,1516618.333,32955,20], + [17144.44,1516638.333,32956,20], + [17154.42,1516658.333,32957,20], + [17164.46,1516678.333,32958,20], + [17174.29,1516698.333,32959,20], + [17184.78,1516718.333,32960,20], + [17194.36,1516738.333,32961,20], + [17204.37,1516758.333,32962,20], + [17214.58,1516778.333,32963,20], + [17224.43,1516798.333,32964,20], + [17234.58,1516818.333,32965,20], + [17244.38,1516838.333,32966,20], + [17254.48,1516858.333,32967,20], + [17264.64,1516878.333,32968,20], + [17274.64,1516898.333,32969,20], + [17284.6,1516918.333,32970,20], + [17294.92,1516938.333,32971,20], + [17304.75,1516958.333,32972,20], + [17314.39,1516978.333,32973,20], + [17325.08,1516998.333,32974,20], + [17334.44,1517018.333,32975,20], + [17344.47,1517038.333,32976,20], + [17354.0,1517058.333,32977,20], + [17364.44,1517078.333,32978,20], + [17374.33,1517098.333,32979,20], + [17385.07,1517118.333,32980,20], + [17394.14,1517138.333,32981,20], + [17404.01,1517158.333,32982,20], + [17414.51,1517178.333,32983,20], + [17424.42,1517198.333,32984,20], + [17434.45,1517218.333,32985,20], + [17444.42,1517238.333,32986,20], + [17454.44,1517258.333,32987,20], + [17464.45,1517278.333,32988,20], + [17474.47,1517298.333,32989,20], + [17484.35,1517318.333,32990,20], + [17494.92,1517338.333,32991,20], + [17504.29,1517358.333,32992,20], + [17514.4,1517378.333,32993,20], + [17524.4,1517398.333,32994,20], + [17535.35,1517418.333,32995,20], + [17544.62,1517438.333,32996,20], + [17554.35,1517458.333,32997,20], + [17565.53,1517478.333,32998,20], + [17574.51,1517498.333,32999,20], + [17584.31,1517518.333,33000,20], + [17595.84,1517538.333,33001,20], + [17604.28,1517558.333,33002,20], + [17614.5,1517578.333,33003,20], + [17624.4,1517598.333,33004,20], + [17634.37,1517618.333,33005,20], + [17644.62,1517638.333,33006,20], + [17654.57,1517658.333,33007,20], + [17664.5,1517678.333,33008,20], + [17674.61,1517698.333,33009,20], + [17684.28,1517718.333,33010,20], + [17695.48,1517738.333,33011,20], + [17704.44,1517758.333,33012,20], + [17714.22,1517778.333,33013,20], + [17724.34,1517798.333,33014,20], + [17734.39,1517818.333,33015,20], + [17744.42,1517838.333,33016,20], + [17754.82,1517858.333,33017,20], + [17764.39,1517878.333,33018,20], + [17774.61,1517898.333,33019,20], + [17784.43,1517918.333,33020,20], + [17794.4,1517938.333,33021,20], + [17804.24,1517958.333,33022,20], + [17814.32,1517978.333,33023,20], + [17824.35,1517998.333,33024,20], + [17835.0,1518018.333,33025,20], + [17844.24,1518038.333,33026,20], + [17854.67,1518058.333,33027,20], + [17864.74,1518078.333,33028,20], + [17874.46,1518098.333,33029,20], + [17884.47,1518118.333,33030,20], + [17894.94,1518138.333,33031,20], + [17904.96,1518158.333,33032,20], + [17914.87,1518178.333,33033,20], + [17924.22,1518198.333,33034,20], + [17934.22,1518218.333,33035,20], + [17945.36,1518238.333,33036,20], + [17954.45,1518258.333,33037,20], + [17965.4,1518278.333,33038,20], + [17977.06,1518298.333,33039,20], + [17986.82,1518318.333,33040,20], + [17995.46,1518338.333,33041,20], + [18009.66,1518358.333,33042,20], + [18028.71,1518378.333,33043,20], + [18049.41,1518398.333,33044,20], + [18069.62,1518418.333,33045,20], + [18089.68,1518438.333,33046,20], + [18109.63,1518458.333,33047,20], + [18129.44,1518478.333,33048,20], + [18149.27,1518498.333,33049,20], + [18168.18,1518518.333,33050,20], + [18189.12,1518538.333,33051,20], + [18208.06,1518558.333,33052,20], + [18228.5,1518578.333,33053,20], + [18248.7,1518598.333,33054,20], + [18269.8,1518618.333,33055,20], + [18289,1518638.333,33056,20], + [18309.3,1518658.333,33057,20], + [18331.72,1518678.333,33058,20], + [18350.01,1518698.333,33059,20], + [18369.09,1518718.333,33060,20], + [18389.35,1518738.333,33061,20], + [18408.84,1518758.333,33062,20], + [18428.84,1518778.333,33063,20], + [18448.69,1518798.333,33064,20], + [18469.53,1518818.333,33065,20], + [18489.63,1518838.333,33066,20], + [18509.37,1518858.333,33067,20], + [18530.12,1518878.333,33068,20], + [18549.53,1518898.333,33069,20], + [18568.72,1518918.333,33070,20], + [18588.85,1518938.333,33071,20], + [18608.52,1518958.333,33072,20], + [18628.43,1518978.333,33073,20], + [18648.57,1518998.333,33074,20], + [18668.76,1519018.333,33075,20], + [18689.02,1519038.333,33076,20], + [18708.77,1519058.333,33077,20], + [18729.06,1519078.333,33078,20], + [18749.6,1519098.333,33079,20], + [18769.2,1519118.333,33080,20], + [18788.77,1519138.333,33081,20], + [18808.96,1519158.333,33082,20], + [18829.11,1519178.333,33083,20], + [18849.01,1519198.333,33084,20], + [18879,1519218.333,33085,20], + [18896.19,1519238.333,33086,20], + [18914.38,1519258.333,33087,20], + [18929.52,1519278.333,33088,20], + [18959.48,1519298.333,33089,20], + [18969.25,1519318.333,33090,20], + [18997.9,1519338.333,33091,20], + [19018.42,1519358.333,33092,20], + [19029.53,1519378.333,33093,20], + [19055.03,1519398.333,33094,20], + [19081.86,1519418.333,33095,20], + [19091.55,1519438.333,33096,20], + [19111.08,1519458.333,33097,20], + [19145.66,1519478.333,33098,20], + [19152.18,1519498.333,33099,20], + [19180.56,1519518.333,33100,20], + [19193.85,1519538.333,33101,20], + [19214.28,1519558.333,33102,20], + [19234.59,1519578.333,33103,20], + [19254.47,1519598.333,33104,20], + [19269.6,1519618.333,33105,20], + [19288.16,1519638.333,33106,20], + [19308.52,1519658.333,33107,20], + [19329.86,1519678.333,33108,20], + [19348.65,1519698.333,33109,20], + [19368.91,1519718.333,33110,20], + [19389.49,1519738.333,33111,20], + [19408.34,1519758.333,33112,20], + [19429.03,1519778.333,33113,20], + [19448.3,1519798.333,33114,20], + [19468.97,1519818.333,33115,20], + [19488.74,1519838.333,33116,20], + [19508.69,1519858.333,33117,20], + [19529.15,1519878.333,33118,20], + [19548.98,1519898.333,33119,20], + [19568.14,1519918.333,33120,20], + [19588.59,1519938.333,33121,20], + [19608.83,1519958.333,33122,20], + [19628.68,1519978.333,33123,20], + [19648.4,1519998.333,33124,20], + [19668.66,1520018.333,33125,20], + [19688.59,1520038.333,33126,20], + [19708.72,1520058.333,33127,20], + [19728.64,1520078.333,33128,20], + [19749.28,1520098.333,33129,20], + [19768.83,1520118.333,33130,20], + [19788.87,1520138.333,33131,20], + [19809.53,1520158.333,33132,20], + [19828.68,1520178.333,33133,20], + [19848.53,1520198.333,33134,20], + [19869.19,1520218.333,33135,20], + [19889.62,1520238.333,33136,20], + [19909.58,1520258.333,33137,20], + [19929.58,1520278.333,33138,20], + [19949.26,1520298.333,33139,20], + [19977.86,1520318.333,33140,20], + [19988.04,1520338.333,33141,20], + [20006.74,1520358.333,33142,20], + [20026.89,1520378.333,33143,20], + [20049.46,1520398.333,33144,20], + [20068.97,1520418.333,33145,20], + [20089.7,1520438.333,33146,20], + [20108.74,1520458.333,33147,20], + [20128.9,1520478.333,33148,20], + [20149,1520498.333,33149,20], + [20172.47,1520518.333,33150,20], + [20189.55,1520538.333,33151,20], + [20210.44,1520558.333,33152,20], + [20229.47,1520578.333,33153,20], + [20248.67,1520598.333,33154,20], + [20271.4,1520618.333,33155,20], + [20289.5,1520638.333,33156,20], + [20348.94,1520678.333,33158,20], + [20349.09,1520658.333,33157,20], + [20349.16,1520698.333,33159,20], + [20368.52,1520718.333,33160,20], + [20390.16,1520738.333,33161,20], + [20409.69,1520758.333,33162,20], + [20428.56,1520778.333,33163,20], + [20449.49,1520798.333,33164,20], + [20468.65,1520818.333,33165,20], + [20489.15,1520838.333,33166,20], + [20510.65,1520858.333,33167,20], + [20531.18,1520878.333,33168,20], + [20548.74,1520898.333,33169,20], + [20569.51,1520918.333,33170,20], + [20588.66,1520938.333,33171,20], + [20608.85,1520958.333,33172,20], + [20629.88,1520978.333,33173,20], + [20648.22,1520998.333,33174,20], + [20668.83,1521018.333,33175,20], + [20688.28,1521038.333,33176,20], + [20708.49,1521058.333,33177,20], + [20728.82,1521078.333,33178,20], + [20748.47,1521098.333,33179,20], + [20769.27,1521118.333,33180,20], + [20789.03,1521138.333,33181,20], + [20808.53,1521158.333,33182,20], + [20830.94,1521178.333,33183,20], + [20848.61,1521198.333,33184,20], + [20869.3,1521218.333,33185,20], + [20889.62,1521238.333,33186,20], + [20908.53,1521258.333,33187,20], + [20928.53,1521278.333,33188,20], + [20948.94,1521298.333,33189,20], + [20968.89,1521318.333,33190,20], + [20989.84,1521338.333,33191,20], + [21008.91,1521358.333,33192,20], + [21029.62,1521378.333,33193,20], + [21050.04,1521398.333,33194,20], + [21069.19,1521418.333,33195,20], + [21090.63,1521438.333,33196,20], + [21109.94,1521458.333,33197,20], + [21129.85,1521478.333,33198,20], + [21149.86,1521498.333,33199,20], + [21169.08,1521518.333,33200,20], + [21190.55,1521538.333,33201,20], + [21208.55,1521558.333,33202,20], + [21228.81,1521578.333,33203,20], + [21249.11,1521598.333,33204,20], + [21270.25,1521618.333,33205,20], + [21288.91,1521638.333,33206,20], + [21309.36,1521658.333,33207,20], + [21329.19,1521678.333,33208,20], + [21348.81,1521698.333,33209,20], + [21368.47,1521718.333,33210,20], + [21389.05,1521738.333,33211,20], + [21411.92,1521758.333,33212,20], + [21428.48,1521778.333,33213,20], + [21448.38,1521798.333,33214,20], + [21468.91,1521818.333,33215,20], + [21489.53,1521838.333,33216,20], + [21508.74,1521858.333,33217,20], + [21529.16,1521878.333,33218,20], + [21551.99,1521898.333,33219,20], + [21568.71,1521918.333,33220,20], + [21589.35,1521938.333,33221,20], + [21608.47,1521958.333,33222,20], + [21629.49,1521978.333,33223,20], + [21649.62,1521998.333,33224,20], + [21668.24,1522018.333,33225,20], + [21694.7,1522038.333,33226,20], + [21711.57,1522058.333,33227,20], + [21728.72,1522078.333,33228,20], + [21748.48,1522098.333,33229,20], + [21768.87,1522118.333,33230,20], + [21788.52,1522138.333,33231,20], + [21808.92,1522158.333,33232,20], + [21830.31,1522178.333,33233,20], + [21848.66,1522198.333,33234,20], + [21869.41,1522218.333,33235,20], + [21888.69,1522238.333,33236,20], + [21910.73,1522258.333,33237,20], + [21931.65,1522278.333,33238,20], + [21949.01,1522298.333,33239,20], + [21968.69,1522318.333,33240,20], + [21987.71,1522338.333,33241,20], + [22009.37,1522358.333,33242,20], + [22028.84,1522378.333,33243,20], + [22048.44,1522398.333,33244,20], + [22069.08,1522418.333,33245,20], + [22088.5,1522438.333,33246,20], + [22108.3,1522458.333,33247,20], + [22128.49,1522478.333,33248,20], + [22149.3,1522498.333,33249,20], + [22169.83,1522518.333,33250,20], + [22191.87,1522538.333,33251,20], + [22208.69,1522558.333,33252,20], + [22228.88,1522578.333,33253,20], + [22249.85,1522598.333,33254,20], + [22268.67,1522618.333,33255,20], + [22288.6,1522638.333,33256,20], + [22313.21,1522658.333,33257,20], + [22328.57,1522678.333,33258,20], + [22349.55,1522698.333,33259,20], + [22369.19,1522718.333,33260,20], + [22389.05,1522738.333,33261,20], + [22408.19,1522758.333,33262,20], + [22428.81,1522778.333,33263,20], + [22448.53,1522798.333,33264,20], + [22469.87,1522818.333,33265,20], + [22488.53,1522838.333,33266,20], + [22508.13,1522858.333,33267,20], + [22527.99,1522878.333,33268,20], + [22548.67,1522898.333,33269,20], + [22569.54,1522918.333,33270,20], + [22589.72,1522938.333,33271,20], + [22612.93,1522958.333,33272,20], + [22628.88,1522978.333,33273,20], + [22648.62,1522998.333,33274,20], + [22671.81,1523018.333,33275,20], + [22688.25,1523038.333,33276,20], + [22712.43,1523058.333,33277,20], + [22728.77,1523078.333,33278,20], + [22748.27,1523098.333,33279,20], + [22768.56,1523118.333,33280,20], + [22789.44,1523138.333,33281,20], + [22809.13,1523158.333,33282,20], + [22829.9,1523178.333,33283,20], + [22865.27,1523198.333,33284,20], + [22868.93,1523218.333,33285,20], + [22900.65,1523238.333,33286,20], + [22948.66,1523258.333,33287,20], + [22948.96,1523278.333,33288,20], + [22955.32,1523298.333,33289,20], + [22985.3,1523318.333,33290,20], + [23023.11,1523338.333,33291,20], + [23023.31,1523358.333,33292,20], + [23036.5,1523378.333,33293,20], + [23053.52,1523398.333,33294,20], + [23075.47,1523418.333,33295,20], + [23118.98,1523458.333,33297,20], + [23119.13,1523438.333,33296,20], + [23136.85,1523478.333,33298,20], + [23149.56,1523498.333,33299,20], + [23170.74,1523518.333,33300,20], + [23189.52,1523538.333,33301,20], + [23208.99,1523558.333,33302,20], + [23228.97,1523578.333,33303,20], + [23249.34,1523598.333,33304,20], + [23268.78,1523618.333,33305,20], + [23289.15,1523638.333,33306,20], + [23308.75,1523658.333,33307,20], + [23329.13,1523678.333,33308,20], + [23348.72,1523698.333,33309,20], + [23369.22,1523718.333,33310,20], + [23402.91,1523738.333,33311,20], + [23412.34,1523758.333,33312,20], + [23428.29,1523778.333,33313,20], + [23448.96,1523798.333,33314,20], + [23469.41,1523818.333,33315,20], + [23489.14,1523838.333,33316,20], + [23512.05,1523858.333,33317,20], + [23528.69,1523878.333,33318,20], + [23549.06,1523898.333,33319,20], + [23568.88,1523918.333,33320,20], + [23588.69,1523938.333,33321,20], + [23608.94,1523958.333,33322,20], + [23628.35,1523978.333,33323,20], + [23648.71,1523998.333,33324,20], + [23668.81,1524018.333,33325,20], + [23688.6,1524038.333,33326,20], + [23708.36,1524058.333,33327,20], + [23730.18,1524078.333,33328,20], + [23748.69,1524098.333,33329,20], + [23768.44,1524118.333,33330,20], + [23788.6,1524138.333,33331,20], + [23808.73,1524158.333,33332,20], + [23828.59,1524178.333,33333,20], + [23849.03,1524198.333,33334,20], + [23870.16,1524218.333,33335,20], + [23888.81,1524238.333,33336,20], + [23908.63,1524258.333,33337,20], + [23928.69,1524278.333,33338,20], + [23948.88,1524298.333,33339,20], + [23968.97,1524318.333,33340,20], + [23990.09,1524338.333,33341,20], + [24008.68,1524358.333,33342,20], + [24028.69,1524378.333,33343,20], + [24049.77,1524398.333,33344,20], + [24070.2,1524418.333,33345,20], + [24093.58,1524438.333,33346,20], + [24108.85,1524458.333,33347,20], + [24129.46,1524478.333,33348,20], + [24148.93,1524498.333,33349,20], + [24168.31,1524518.333,33350,20], + [24191.42,1524538.333,33351,20], + [24208.81,1524558.333,33352,20], + [24229.06,1524578.333,33353,20], + [24248.58,1524598.333,33354,20], + [24268.88,1524618.333,33355,20], + [24288.55,1524638.333,33356,20], + [24309.18,1524658.333,33357,20], + [24331.5,1524678.333,33358,20], + [24348.73,1524698.333,33359,20], + [24375.32,1524718.333,33360,20], + [24388.77,1524738.333,33361,20], + [24409.67,1524758.333,33362,20], + [24428.82,1524778.333,33363,20], + [24448.68,1524798.333,33364,20], + [24468.78,1524818.333,33365,20], + [24488.02,1524838.333,33366,20], + [24508.73,1524858.333,33367,20], + [24529.16,1524878.333,33368,20], + [24549.36,1524898.333,33369,20], + [24568.72,1524918.333,33370,20], + [24588.57,1524938.333,33371,20], + [24607.65,1524958.333,33372,20], + [24628.55,1524978.333,33373,20], + [24648.95,1524998.333,33374,20], + [24671.47,1525018.333,33375,20], + [24689.24,1525038.333,33376,20], + [24708.45,1525058.333,33377,20], + [24729.5,1525078.333,33378,20], + [24748.7,1525098.333,33379,20], + [24768.49,1525118.333,33380,20], + [24788.7,1525138.333,33381,20], + [24810.85,1525158.333,33382,20], + [24828.71,1525178.333,33383,20], + [24848.49,1525198.333,33384,20], + [24869.05,1525218.333,33385,20], + [24888.51,1525238.333,33386,20], + [24908.37,1525258.333,33387,20], + [24928.53,1525278.333,33388,20], + [24949.26,1525298.333,33389,20], + [24968.95,1525318.333,33390,20], + [24988.72,1525338.333,33391,20], + [25009.12,1525358.333,33392,20], + [25028.65,1525378.333,33393,20], + [25054,1525398.333,33394,20], + [25068.3,1525418.333,33395,20], + [25091.88,1525438.333,33396,20], + [25108.88,1525458.333,33397,20], + [25130.96,1525478.333,33398,20], + [25148.47,1525498.333,33399,20], + [25168.96,1525518.333,33400,20], + [25189.41,1525538.333,33401,20], + [25209.37,1525558.333,33402,20], + [25229.29,1525578.333,33403,20], + [25249.6,1525598.333,33404,20], + [25269.15,1525618.333,33405,20], + [25288.84,1525638.333,33406,20], + [25309.11,1525658.333,33407,20], + [25328.89,1525678.333,33408,20], + [25348.41,1525698.333,33409,20], + [25368.88,1525718.333,33410,20], + [25389.28,1525738.333,33411,20], + [25408.82,1525758.333,33412,20], + [25429.69,1525778.333,33413,20], + [25448.75,1525798.333,33414,20], + [25471.39,1525818.333,33415,20], + [25489.69,1525838.333,33416,20], + [25526.96,1525858.333,33417,20], + [25547.88,1525878.333,33418,20], + [25572.53,1525898.333,33419,20], + [25597.44,1525918.333,33420,20], + [25617.8,1525938.333,33421,20], + [25639.78,1525958.333,33422,20], + [25661.5,1525978.333,33423,20], + [25682.59,1525998.333,33424,20], + [25701.5,1526018.333,33425,20], + [25718.72,1526038.333,33426,20], + [25741.18,1526058.333,33427,20], + [25754.7,1526078.333,33428,20], + [25767.99,1526098.333,33429,20], + [25788.47,1526118.333,33430,20], + [25815.22,1526138.333,33431,20], + [25840.81,1526158.333,33432,20], + [25859.04,1526178.333,33433,20], + [25879.96,1526198.333,33434,20], + [25896.43,1526218.333,33435,20], + [25905.82,1526238.333,33436,20], + [25917.48,1526258.333,33437,20], + [25928.78,1526278.333,33438,20], + [25954.06,1526298.333,33439,20], + [25968.9,1526318.333,33440,20], + [25988.33,1526338.333,33441,20], + [26008.52,1526358.333,33442,20], + [26029.56,1526378.333,33443,20], + [26057.16,1526398.333,33444,20], + [26078.75,1526418.333,33445,20], + [26104.84,1526438.333,33446,20], + [26116.89,1526458.333,33447,20], + [26133.74,1526478.333,33448,20], + [26156.04,1526498.333,33449,20], + [26168.13,1526518.333,33450,20], + [26197.94,1526538.333,33451,20], + [26212.56,1526558.333,33452,20], + [26237.81,1526578.333,33453,20], + [26249.9,1526598.333,33454,20], + [26268.46,1526618.333,33455,20], + [26300.58,1526638.333,33456,20], + [26321.81,1526658.333,33457,20], + [26340.9,1526678.333,33458,20], + [26357.01,1526698.333,33459,20], + [26379.91,1526718.333,33460,20], + [26388.86,1526738.333,33461,20], + [26408.99,1526758.333,33462,20], + [26428.62,1526778.333,33463,20], + [26448.4,1526798.333,33464,20], + [26484.78,1526818.333,33465,20], + [26488.78,1526838.333,33466,20], + [26508.59,1526858.333,33467,20], + [26528.6,1526878.333,33468,20], + [26548.59,1526898.333,33469,20], + [26568.53,1526918.333,33470,20], + [26588.32,1526938.333,33471,20], + [26609.6,1526958.333,33472,20], + [26628.88,1526978.333,33473,20], + [26649.57,1526998.333,33474,20], + [26670.59,1527018.333,33475,20], + [26689.6,1527038.333,33476,20], + [26708.56,1527058.333,33477,20], + [26728.68,1527078.333,33478,20], + [26748.96,1527098.333,33479,20], + [26768.53,1527118.333,33480,20], + [26788.74,1527138.333,33481,20], + [26808.31,1527158.333,33482,20], + [26829.56,1527178.333,33483,20], + [26848.69,1527198.333,33484,20], + [26869.41,1527218.333,33485,20], + [26892.26,1527238.333,33486,20], + [26913.87,1527258.333,33487,20], + [26930.25,1527278.333,33488,20], + [26958.36,1527298.333,33489,20], + [26983.5,1527318.333,33490,20], + [26992.93,1527338.333,33491,20], + [27011.75,1527358.333,33492,20], + [27028.9,1527378.333,33493,20], + [27049.89,1527398.333,33494,20], + [27082.97,1527418.333,33495,20], + [27097.72,1527438.333,33496,20], + [27116.6,1527458.333,33497,20], + [27139.52,1527478.333,33498,20], + [27172.83,1527518.333,33500,20], + [27173,1527498.333,33499,20], + [27214.87,1527538.333,33501,20], + [27215.05,1527558.333,33502,20], + [27238.89,1527578.333,33503,20], + [27248.75,1527598.333,33504,20], + [27268.62,1527618.333,33505,20], + [27288.5,1527638.333,33506,20], + [27308.4,1527658.333,33507,20], + [27329.31,1527678.333,33508,20], + [27349.51,1527698.333,33509,20], + [27367.53,1527718.333,33510,20], + [27387.4,1527738.333,33511,20], + [27408.64,1527758.333,33512,20], + [27429.55,1527778.333,33513,20], + [27448.44,1527798.333,33514,20], + [27468.91,1527818.333,33515,20], + [27488.33,1527838.333,33516,20], + [27509.13,1527858.333,33517,20], + [27529.79,1527878.333,33518,20], + [27550.52,1527898.333,33519,20], + [27568.3,1527918.333,33520,20], + [27588.71,1527938.333,33521,20], + [27608.59,1527958.333,33522,20], + [27628.88,1527978.333,33523,20], + [27649.34,1527998.333,33524,20], + [27669.24,1528018.333,33525,20], + [27688.62,1528038.333,33526,20], + [27708.74,1528058.333,33527,20], + [27728.66,1528078.333,33528,20], + [27748.41,1528098.333,33529,20], + [27768.8,1528118.333,33530,20], + [27788.4,1528138.333,33531,20], + [27809.73,1528158.333,33532,20], + [27829.93,1528178.333,33533,20], + [27848.56,1528198.333,33534,20], + [27871.82,1528218.333,33535,20], + [27888.38,1528238.333,33536,20], + [27908.56,1528258.333,33537,20], + [27928.83,1528278.333,33538,20], + [27949.66,1528298.333,33539,20], + [27969.09,1528318.333,33540,20], + [27988.64,1528338.333,33541,20], + [28008.43,1528358.333,33542,20], + [28041.09,1528378.333,33543,20], + [28052.71,1528398.333,33544,20], + [28068.78,1528418.333,33545,20], + [28088.84,1528438.333,33546,20], + [28108.71,1528458.333,33547,20], + [28130.15,1528478.333,33548,20], + [28150.86,1528498.333,33549,20], + [28168.69,1528518.333,33550,20], + [28189.09,1528538.333,33551,20], + [28208.74,1528558.333,33552,20], + [28228.8,1528578.333,33553,20], + [28248.05,1528598.333,33554,20], + [28268.88,1528618.333,33555,20], + [28291.02,1528638.333,33556,20], + [28309.05,1528658.333,33557,20], + [28328.69,1528678.333,33558,20], + [28349.49,1528698.333,33559,20], + [28368.16,1528718.333,33560,20], + [28389.01,1528738.333,33561,20], + [28408.56,1528758.333,33562,20], + [28435.96,1528778.333,33563,20], + [28448.84,1528798.333,33564,20], + [28468.95,1528818.333,33565,20], + [28489.5,1528838.333,33566,20], + [28508.91,1528858.333,33567,20], + [28529.85,1528878.333,33568,20], + [28548.52,1528898.333,33569,20], + [28569.73,1528918.333,33570,20], + [28588.93,1528938.333,33571,20], + [28608.68,1528958.333,33572,20], + [28629.47,1528978.333,33573,20], + [28649.75,1528998.333,33574,20], + [28669.5,1529018.333,33575,20], + [28688.88,1529038.333,33576,20], + [28708.83,1529058.333,33577,20], + [28728.78,1529078.333,33578,20], + [28749.41,1529098.333,33579,20], + [28769.49,1529118.333,33580,20], + [28788.5,1529138.333,33581,20], + [28808.84,1529158.333,33582,20], + [28828.49,1529178.333,33583,20], + [28849.72,1529198.333,33584,20], + [28870.63,1529218.333,33585,20], + [28888.69,1529238.333,33586,20], + [28911.59,1529258.333,33587,20], + [28929.04,1529278.333,33588,20], + [28948.09,1529298.333,33589,20], + [28973.3,1529318.333,33590,20], + [28989,1529338.333,33591,20], + [29008.71,1529358.333,33592,20], + [29028.8,1529378.333,33593,20], + [29049.03,1529398.333,33594,20], + [29068.63,1529418.333,33595,20], + [29088.63,1529438.333,33596,20], + [29108.93,1529458.333,33597,20], + [29128.52,1529478.333,33598,20], + [29148.64,1529498.333,33599,20], + [29168.72,1529518.333,33600,20], + [29189.51,1529538.333,33601,20], + [29209.57,1529558.333,33602,20], + [29230.37,1529578.333,33603,20], + [29249.08,1529598.333,33604,20], + [29268.74,1529618.333,33605,20], + [29288.41,1529638.333,33606,20], + [29308.56,1529658.333,33607,20], + [29328.89,1529678.333,33608,20], + [29349.46,1529698.333,33609,20], + [29368.57,1529718.333,33610,20], + [29388.75,1529738.333,33611,20], + [29408.89,1529758.333,33612,20], + [29428.88,1529778.333,33613,20], + [29449.66,1529798.333,33614,20], + [29469.44,1529818.333,33615,20], + [29489.91,1529838.333,33616,20], + [29508.46,1529858.333,33617,20], + [29530.76,1529878.333,33618,20], + [29548.97,1529898.333,33619,20], + [29569.4,1529918.333,33620,20], + [29590.41,1529938.333,33621,20], + [29613.59,1529958.333,33622,20], + [29635.5,1529978.333,33623,20], + [29648.85,1529998.333,33624,20], + [29669.24,1530018.333,33625,20], + [29689.44,1530038.333,33626,20], + [29708.7,1530058.333,33627,20], + [29729.17,1530078.333,33628,20], + [29748.94,1530098.333,33629,20], + [29771.86,1530118.333,33630,20], + [29793.78,1530138.333,33631,20], + [29808.85,1530158.333,33632,20], + [29829.93,1530178.333,33633,20], + [29848.69,1530198.333,33634,20], + [29868.96,1530218.333,33635,20], + [29890.3,1530238.333,33636,20], + [29909.7,1530258.333,33637,20], + [29931.74,1530278.333,33638,20], + [29949.46,1530298.333,33639,20], + [29969.06,1530318.333,33640,20], + [29991.69,1530338.333,33641,20], + [30011.02,1530358.333,33642,20], + [30030.27,1530378.333,33643,20], + [30049.81,1530398.333,33644,20], + [30069.37,1530418.333,33645,20], + [30088.81,1530438.333,33646,20], + [30108.72,1530458.333,33647,20], + [30129.89,1530478.333,33648,20], + [30149.87,1530498.333,33649,20], + [30169.56,1530518.333,33650,20], + [30189.07,1530538.333,33651,20], + [30208.52,1530558.333,33652,20], + [30229.78,1530578.333,33653,20], + [30248.73,1530598.333,33654,20], + [30268.03,1530618.333,33655,20], + [30289.4,1530638.333,33656,20], + [30309.3,1530658.333,33657,20], + [30329.38,1530678.333,33658,20], + [30349.22,1530698.333,33659,20], + [30369.55,1530718.333,33660,20], + [30388.93,1530738.333,33661,20], + [30410.12,1530758.333,33662,20], + [30430.85,1530778.333,33663,20], + [30449.54,1530798.333,33664,20], + [30474,1530818.333,33665,20], + [30489.48,1530838.333,33666,20], + [30510.52,1530858.333,33667,20], + [30529.39,1530878.333,33668,20], + [30550.4,1530898.333,33669,20], + [30569.17,1530918.333,33670,20], + [30588.75,1530938.333,33671,20], + [30609.26,1530958.333,33672,20], + [30631.28,1530978.333,33673,20], + [30649.49,1530998.333,33674,20], + [30672.61,1531018.333,33675,20], + [30689.06,1531038.333,33676,20], + [30708.7,1531058.333,33677,20], + [30728.69,1531078.333,33678,20], + [30749.94,1531098.333,33679,20], + [30768.44,1531118.333,33680,20], + [30788.77,1531138.333,33681,20], + [30808.44,1531158.333,33682,20], + [30828.96,1531178.333,33683,20], + [30850.3,1531198.333,33684,20], + [30872.53,1531218.333,33685,20], + [30889.48,1531238.333,33686,20], + [30924.52,1531258.333,33687,20], + [30931.92,1531278.333,33688,20], + [30950.34,1531298.333,33689,20], + [30980.12,1531318.333,33690,20], + [30990.93,1531338.333,33691,20], + [31014.69,1531358.333,33692,20], + [31030.19,1531378.333,33693,20], + [31050.59,1531398.333,33694,20], + [31076.03,1531418.333,33695,20], + [31091.19,1531438.333,33696,20], + [31110.74,1531458.333,33697,20], + [31144.26,1531478.333,33698,20], + [31152.76,1531498.333,33699,20], + [31170.47,1531518.333,33700,20], + [31202.79,1531538.333,33701,20], + [31210.11,1531558.333,33702,20], + [31229.86,1531578.333,33703,20], + [31262.17,1531598.333,33704,20], + [31270.87,1531618.333,33705,20], + [31293.66,1531638.333,33706,20], + [31314.68,1531658.333,33707,20], + [31334.16,1531678.333,33708,20], + [31348.63,1531698.333,33709,20], + [31368.88,1531718.333,33710,20], + [31388.32,1531738.333,33711,20], + [31408.63,1531758.333,33712,20], + [31428.99,1531778.333,33713,20], + [31449.93,1531798.333,33714,20], + [31468.77,1531818.333,33715,20], + [31488.47,1531838.333,33716,20], + [31540.69,1531858.333,33717,20], + [31540.96,1531878.333,33718,20], + [31549.17,1531898.333,33719,20], + [31569.13,1531918.333,33720,20], + [31588.6,1531938.333,33721,20], + [31612.02,1531958.333,33722,20], + [31629.62,1531978.333,33723,20], + [31648.5,1531998.333,33724,20], + [31668.77,1532018.333,33725,20], + [31688.74,1532038.333,33726,20], + [31708.84,1532058.333,33727,20], + [31730.43,1532078.333,33728,20], + [31750.49,1532098.333,33729,20], + [31770.13,1532118.333,33730,20], + [31789.16,1532138.333,33731,20], + [31809.4,1532158.333,33732,20], + [31829.12,1532178.333,33733,20], + [31849.4,1532198.333,33734,20], + [31870.58,1532218.333,33735,20], + [31889.45,1532238.333,33736,20], + [31909.28,1532258.333,33737,20], + [31928.84,1532278.333,33738,20], + [31948.8,1532298.333,33739,20], + [31968.69,1532318.333,33740,20], + [31989.37,1532338.333,33741,20], + [32008.63,1532358.333,33742,20], + [32028.84,1532378.333,33743,20], + [32053.94,1532398.333,33744,20], + [32070.4,1532418.333,33745,20], + [32090.38,1532438.333,33746,20], + [32109.71,1532458.333,33747,20], + [32129.69,1532478.333,33748,20], + [32148.59,1532498.333,33749,20], + [32168.35,1532518.333,33750,20], + [32187.7,1532538.333,33751,20], + [32208.6,1532558.333,33752,20], + [32228.53,1532578.333,33753,20], + [32248.33,1532598.333,33754,20], + [32270.69,1532618.333,33755,20], + [32287.94,1532638.333,33756,20], + [32308.9,1532658.333,33757,20], + [32328.47,1532678.333,33758,20], + [32349.02,1532698.333,33759,20], + [32368.47,1532718.333,33760,20], + [32388.88,1532738.333,33761,20], + [32414.51,1532758.333,33762,20], + [32428.53,1532778.333,33763,20], + [32449.16,1532798.333,33764,20], + [32468.27,1532818.333,33765,20], + [32488.59,1532838.333,33766,20], + [32508.9,1532858.333,33767,20], + [32528.68,1532878.333,33768,20], + [32553.62,1532898.333,33769,20], + [32568.16,1532918.333,33770,20], + [32588.24,1532938.333,33771,20], + [32609.35,1532958.333,33772,20], + [32630.13,1532978.333,33773,20], + [32648.6,1532998.333,33774,20], + [32667.88,1533018.333,33775,20], + [32688.34,1533038.333,33776,20], + [32708.32,1533058.333,33777,20], + [32729.64,1533078.333,33778,20], + [32749.47,1533098.333,33779,20], + [32768.4,1533118.333,33780,20], + [32788.62,1533138.333,33781,20], + [32808.4,1533158.333,33782,20], + [32830.97,1533178.333,33783,20], + [32848.99,1533198.333,33784,20], + [32869.4,1533218.333,33785,20], + [32888.77,1533238.333,33786,20], + [32908.63,1533258.333,33787,20], + [32928.77,1533278.333,33788,20], + [32950.53,1533298.333,33789,20], + [32968.59,1533318.333,33790,20], + [32988.6,1533338.333,33791,20], + [33008.71,1533358.333,33792,20], + [33028.85,1533378.333,33793,20], + [33048.22,1533398.333,33794,20], + [33069.66,1533418.333,33795,20], + [33088.61,1533438.333,33796,20], + [33110.59,1533458.333,33797,20], + [33128.23,1533478.333,33798,20], + [33148.41,1533498.333,33799,20], + [33170.46,1533518.333,33800,20], + [33189.9,1533538.333,33801,20], + [33208.89,1533558.333,33802,20], + [33229.51,1533578.333,33803,20], + [33250.69,1533598.333,33804,20], + [33268.86,1533618.333,33805,20], + [33288.75,1533638.333,33806,20], + [33308.62,1533658.333,33807,20], + [33329.56,1533678.333,33808,20], + [33349.78,1533698.333,33809,20], + [33368.29,1533718.333,33810,20], + [33390.52,1533738.333,33811,20], + [33408.41,1533758.333,33812,20], + [33428.56,1533778.333,33813,20], + [33447.84,1533798.333,33814,20], + [33469.09,1533818.333,33815,20], + [33492,1533838.333,33816,20], + [33508.43,1533858.333,33817,20], + [33529.96,1533878.333,33818,20], + [33548.81,1533898.333,33819,20], + [33568.71,1533918.333,33820,20], + [33590.71,1533938.333,33821,20], + [33608.65,1533958.333,33822,20], + [33628.6,1533978.333,33823,20], + [33648.37,1533998.333,33824,20], + [33670.81,1534018.333,33825,20], + [33688.31,1534038.333,33826,20], + [33721.3,1534058.333,33827,20], + [33728.92,1534078.333,33828,20], + [33753.44,1534098.333,33829,20], + [33767.63,1534118.333,33830,20], + [33788.08,1534138.333,33831,20], + [33808.31,1534158.333,33832,20], + [33828.57,1534178.333,33833,20], + [33848.63,1534198.333,33834,20], + [33868.47,1534218.333,33835,20], + [33888.97,1534238.333,33836,20], + [33908.87,1534258.333,33837,20], + [33928.27,1534278.333,33838,20], + [33949.28,1534298.333,33839,20], + [33967.71,1534318.333,33840,20], + [33988.66,1534338.333,33841,20], + [34007.72,1534358.333,33842,20], + [34029.33,1534378.333,33843,20], + [34048.52,1534398.333,33844,20], + [34069.49,1534418.333,33845,20], + [34088.99,1534438.333,33846,20], + [34109.55,1534458.333,33847,20], + [34129.61,1534478.333,33848,20], + [34148.46,1534498.333,33849,20], + [34168.79,1534518.333,33850,20], + [34189.53,1534538.333,33851,20], + [34208.93,1534558.333,33852,20], + [34229.41,1534578.333,33853,20], + [34248.71,1534598.333,33854,20], + [34269.37,1534618.333,33855,20], + [34289.35,1534638.333,33856,20], + [34323.33,1534658.333,33857,20], + [34335.84,1534678.333,33858,20], + [34352.63,1534698.333,33859,20], + [34383.96,1534718.333,33860,20], + [34391.94,1534738.333,33861,20], + [34421.64,1534758.333,33862,20], + [34438.5,1534778.333,33863,20], + [34453.1,1534798.333,33864,20], + [34474.47,1534818.333,33865,20], + [34494.59,1534838.333,33866,20], + [34520.74,1534858.333,33867,20], + [34535.03,1534878.333,33868,20], + [34556.4,1534898.333,33869,20], + [34588.54,1534918.333,33870,20], + [34596.46,1534938.333,33871,20], + [34613.68,1534958.333,33872,20], + [34630.65,1534978.333,33873,20], + [34649.82,1534998.333,33874,20], + [34671.13,1535018.333,33875,20], + [34692.53,1535038.333,33876,20], + [34708.45,1535058.333,33877,20], + [34730.7,1535078.333,33878,20], + [34748.81,1535098.333,33879,20], + [34768.99,1535118.333,33880,20], + [34789.89,1535138.333,33881,20], + [34808.78,1535158.333,33882,20], + [34828.58,1535178.333,33883,20], + [34848.73,1535198.333,33884,20], + [34870.74,1535218.333,33885,20], + [34888.44,1535238.333,33886,20], + [34908.75,1535258.333,33887,20], + [34928.53,1535278.333,33888,20], + [34949.66,1535298.333,33889,20], + [34968.59,1535318.333,33890,20], + [34988.69,1535338.333,33891,20] + ] +} diff --git a/test/justfile b/test/justfile index e4a498103a6..d7a8b4deaaf 100644 --- a/test/justfile +++ b/test/justfile @@ -153,8 +153,8 @@ native-play: ./native-play/run.sh # Plays a tone in headless Chromium and the native `moq play` through moq-shaper and grades -# what the listener heard (underruns, skip-aheads, silence, the resolved delay) against -# audio-quality/budgets.json. The full matrix is 24 rows at 60 s; nightly runs it with +# what the listener heard (underruns, trimmed audio, silence, A/V lag, the resolved delay) against +# audio-quality/budgets.json. The full matrix is 28 rows at 60 s; nightly runs it with # --enforce. Narrow it with `--profiles mild --codecs opus --runtimes chromium --duration 20`; # `--runtimes native` is the native player alone. # `--replays` grades only the recorded traces, in seconds, as `just ci` does on a diff touching the player. From 711769ab6f5dfb76aa205632fc9f53696bef872f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 14:06:07 -0800 Subject: [PATCH 3/4] test(audio-quality): budget lag and trims, measure the congestion rows Co-Authored-By: Claude Opus 5.5 --- quest/m1/audio-jitter-target/README.md | 7 +- quest/m1/audio-jitter-target/grading.md | 80 ------- quest/m1/audio-jitter-target/stretch.md | 1 - test/audio-quality/budgets.json | 285 +++++++++++++++++------- 4 files changed, 205 insertions(+), 168 deletions(-) delete mode 100644 quest/m1/audio-jitter-target/grading.md diff --git a/quest/m1/audio-jitter-target/README.md b/quest/m1/audio-jitter-target/README.md index e29e7129189..99b595c656f 100644 --- a/quest/m1/audio-jitter-target/README.md +++ b/quest/m1/audio-jitter-target/README.md @@ -70,9 +70,9 @@ reach zero underruns, and some underruns during congestion are expected. - Bound: ✅ configurable, as [the `stretch` setting](/quest/m1/audio-jitter-target/stretch-setting.md) records. -- Tests: no gate may reward moving away from the rule, so - [the grading quest](/quest/m1/audio-jitter-target/grading.md) lands before - [the model](/quest/m1/audio-jitter-target/stretch.md). +- Tests: no gate may reward moving away from the rule, so the audio harness + grades steady-state lag, the player's own trims, and recovery from a stall + before [the model](/quest/m1/audio-jitter-target/stretch.md) lands. - Milestone: ✅ every new child in m1, here (rejected: the model and grading in m0; the setting in m2). @@ -89,7 +89,6 @@ native playback against its budgets. ## Required -- [Grading](/quest/m1/audio-jitter-target/grading.md) - the audio harness grades steady-state lag, dropped audio, and recovery from a stall, with no gate fixed at zero underruns or zero lag - [Stretch model](/quest/m1/audio-jitter-target/stretch.md) - every player slows down when its buffer runs low and speeds up once it refills, by one rule and one set of vectors, buffered mode included - [The `stretch` setting](/quest/m1/audio-jitter-target/stretch-setting.md) - a player sets how far audio may trail before it skips, and zero turns the stretch off - [Calibrate](/quest/m1/audio-jitter-target/calibrate.md) - every browser and native ceiling re-measured from seven Nightlies with the model diff --git a/quest/m1/audio-jitter-target/grading.md b/quest/m1/audio-jitter-target/grading.md deleted file mode 100644 index 03344d7dca8..00000000000 --- a/quest/m1/audio-jitter-target/grading.md +++ /dev/null @@ -1,80 +0,0 @@ -# [M] The audio harness grades the stretch model - -## Goal - -No audio test, budget, or benchmark rewards a player for moving away from the -[epic's model](/quest/m1/audio-jitter-target/README.md). On today's player, -before the model lands, `test/audio-quality` grades: - -- Steady-state lag: every row, native and browser included, carries - `av_lag_ms` p50, so latency can no longer buy fewer underruns unnoticed. -- Temporary lag passes: p95 lag is a ceiling with measured headroom on the - browser and native rows, and no note calls audio trailing through a stall a - regression. -- Dropped audio is the player's own count (`trimmed_ms`, `player_skips`). - Speeding up is not a skip. -- No row's budget is fixed at zero underruns or zero stalls. -- A congestion row, where the path stalls for longer than the target and - then delivers the backlog, reports the audio dropped and how long audio - takes to return to the clock. - -Boundaries: no player behavior changes here. Ceilings are measured, never -chosen. - -## Plan - -Planned 2026-11-09 (maintainer, /quest-plan: "make sure there are no tests or -benchmarks that cause us to optimize in the wrong direction"). ✅ m1, in this -epic, and before [the model](/quest/m1/audio-jitter-target/stretch.md), so -its implementer is never graded against the old rule. - -The gates the audit of `main` found pushing the wrong way (2026-11-09, -`10772522a5`): - -- `test/audio-quality/budgets.json` budgets the replay rows' `av_lag_ms` p50 - and p95 exactly, at -19 to -22 ms, and its note says "any change that - settles audio later to buy fewer underruns fails them". That forbids any - temporary lag and treats audio leading the clock as the resting point. -- `skip_aheads_per_min` and `discarded_ms_per_min`, on all 29 rows, infer a - skip from a step in the playhead's lag, so a catch-up reads as dropped - audio. Decided 2026-11-09 (maintainer, on - [moq-dev/moq#8308](https://github.com/moq-dev/moq/pull/8308#issuecomment-6730322286)): - ✅ budget the player's own trims (rejected: keep budgeting accelerates as - `discarded_ms`). -- The 24 browser and native rows cap underruns with no ceiling on lag. Native - settled 60 to 88 ms behind its clock without failing one. -- `test/audio-quality/clients/js/ptt-analyze.ts` failed on any underrun or - stall. [moq-dev/moq#8364](https://github.com/moq-dev/moq/pull/8364) made it - report the counts without gating them (maintainer, /quest-unblock, - 2026-11-09), leaving their judgment to this quest. -- The unit tests that pin the old rule belong to the model quest, which - rewrites them with the behavior. - -Neutral, and left alone: `just rs bench-playback` and -`js/watch/bench/ring.ts` measure CPU per callback, and the estimator's -conformance corpus measures the target. - -Recommendations: - -- Replay rows stay exact, so any change to one still fails until it is - re-measured. Rewrite the note to say which re-measured moves are - regressions to fix rather than budget: a steady-state p50 lag that rises, - or audio the player trimmed. A p95 lag that rises through a stall, or an - underrun count that moves, is re-measured in. -- Add the congestion case twice: a shaper profile that queues until packets - drop, per the repository's impairment rule, and a replay trace where media - trickles in late after a stall, which the audit of #8360 asked for. -- New ceilings on the browser and native rows are provisional until - [the re-measure](/quest/m1/audio-jitter-target/calibrate.md), as the native - rows already are. -- The `step` rows' lag is budgeted as measured, with a sentence in the note: - the shared clock's reference only moves earlier, so a lasting path-delay - step leaves it stale. The follow-up is deferred until the model's numbers - exist. -- Update `test/audio-quality/README.md` for every metric added or dropped. - -Public API: none. Wire: none. - -## Related - -- [Audio outlives video under bufferbloat](/quest/m4/audio-bufferbloat-av.md) - adds audio and video rows through a rate-limited link to the same harness diff --git a/quest/m1/audio-jitter-target/stretch.md b/quest/m1/audio-jitter-target/stretch.md index 9e73984f2b1..262a02e6fed 100644 --- a/quest/m1/audio-jitter-target/stretch.md +++ b/quest/m1/audio-jitter-target/stretch.md @@ -125,7 +125,6 @@ Public API: none expected. Wire: none. ## Required -- [The audio harness grades the stretch model](/quest/m1/audio-jitter-target/grading.md) - the gates that pushed toward zero underruns and zero lag are gone before this is measured against them - [Native backpressure](/quest/m1/audio-jitter-target/native-backpressure.md) - native holds its ring at a floor and the rest of the target encoded, as the browser does, so one rule reads the same buffer in both ## Closes diff --git a/test/audio-quality/budgets.json b/test/audio-quality/budgets.json index 44a9c6b926c..42cf24ec64c 100644 --- a/test/audio-quality/budgets.json +++ b/test/audio-quality/budgets.json @@ -1,317 +1,425 @@ { - "note": "The browser rows are measured on the nightly runner (ubuntu-24.04-arm, headless Chromium, seed 7, 60 s a row), from the audio-quality-run artifacts of the seven scheduled Nightly runs on main from 2026-10-29 to 2026-11-04 (40885347517, 41065371094, 41204380716, 41313466339, 41483654426, 41656613559, 41852517544), the first after a fresh subscriber stopped receiving the relay's cached history. The AAC rows predate the TS importer publishing each PES as one group. Each ceiling is the worst of its seven nights times 1.25, plus one runner hiccup, rounded up to two significant figures. The hiccup is sized from the single gaps the 2026-10-08 night put on otherwise clean rows, the fixed-250 control among them: 250 underruns/min, 700 gap ms/min, 3.3 skips/min, 280 discarded ms/min, 0.01 stalled, 0.015 silence, and one 20 ms bucket of target. Budgeted this way, every night passes when it is held out of its row's measurement except one, and that row's own ceiling includes it: the 2026-11-03 Opus bursty row raised its target to 300 ms 2.6 s in and held it for one 20 s half-life before settling at 180. Such startup holds, Opus near-zero's 100 ms on 2026-10-30 and 10-31 among them, are budgeted as measured. These ceilings record today's player as the runner hears it, not target audio quality. To re-measure, download the same artifact from the latest scheduled nightlies (`gh run download -n audio-quality-run`), which keep every run, and apply the same rule. The replay rows are deterministic, so their ceilings are exactly what they measured, through the end of each recording, with no headroom: any regression fails them, and an improvement should be tightened in. They were last re-measured on 2026-10-22 using version 3 traces with encoded frame durations: AAC-LC uses its fixed 1024 samples, and relay-mic retains Opus packet TOC durations. relay-mic was re-recorded on 2026-11-03 from a real microphone, Chrome 156 on a MacBook Air publishing its built-in microphone through the public relay, recorded by headless Chromium on a Linux host (35 s, minimum RTT 2 ms), which raised its target ceiling from 60 to 80 ms and its silence from 0 to 0.001 as measured. The recording path itself has no added RTT. relay-mic-rtt40 is the 2026-11-03 Chrome row at 40 ms of added RTT on that laptop (180 s, minimum RTT 47 ms), kept as the baseline time stretch improves on; like every replay row, its player_underruns_per_min ceiling is what it measures, not a fixed zero. player_underruns_per_min, the player's own counter that its stats panel shows, is budgeted on the replay rows only; it counts the run-dry re-stalls the tap files as stalled time. On 2026-11-07, after the ordered read stopped delivering groups below its cursor (#8071) and took Rust's hole and age bounds (#8218), relay-bbb was re-measured at 16.1 player underruns/min, 0.025 stalled and 0.02 silence, and relay-mic-rtt40 at 8.2, its discarded audio at 70.9 ms/min and its target p95 at 320 ms rather than 780, since the stale backlog it never played no longer reaches the estimator; neither row lost audio the previous player heard. On 2026-11-08 the player began time-stretching live playback with NetEq's accelerate, deciding on the ring's depth right after each arrival and never expanding, and every replay row was re-measured with it, the browser rows left to the nightly runner. Each row's av_lag_ms ceilings, how far the playhead trails the shared clock video plays from, are what it measured: the ring rests one frame ahead of the newest arrival's playout, as the trim it replaces left it, so audio leads the clock by 19 to 23 ms at p50, and any change that settles audio later to buy fewer underruns fails them. Against the trim, the A/V lag p50 fell from 0.7, -17.5, -21.5, -18.2 and -15.6 ms to -22.4 on bursty-aac, -22.2 on local-aac, -22.7 on relay-bbb, -19 on relay-mic and -20.1 on relay-mic-rtt40, and its p95 fell on every row, most on relay-bbb (10.5 to -4.2) and relay-mic-rtt40 (-0.9 to -13.4). Underruns stayed where the trim had them, as the latency they would cost is not spent: player_underruns_per_min held at 4.4, 12.1, 16.1 and 6.1 and rose from 8.2 to 10.6 on relay-mic-rtt40, and relay-mic's tap now files 2 short quanta a minute, 2 ms of missing audio, where it filed none. What the stretch buys is the audio the trim dropped: discarded_ms_per_min fell from 87.8 to 0 on relay-bbb and from 127.5 to 100.6 on local-aac, whose remainder drops nothing: two receive stalls 14 and 15.3 s in leave audio 159 and 132 ms behind the clock, and the fast accelerate that brings it back within half a second steps the playhead's lag the way skip_aheads reads as a skip. player_skips_per_min, the ring's own count of re-anchors that dropped buffered audio, is budgeted beside it, at 0 on every row. Once durations became whole nanoseconds, relay-bbb's delay, 200 ms plus one 1024-sample AAC frame, rounds up by a fraction of a sample, so its ring holds one more sample (23 µs) and its A/V lag p50 measures -22.6 rather than -22.7. Neither replay calibration changed the browser or native ceilings. bursty-aac is the 2026-10-18 AAC bursty isolated capture, recorded with the observer subscribed at the decoder's 2 s budget, so it holds every group the player saw. The native rows are provisional: measured on a loaded developer host (x86_64 Linux, the private PulseAudio null sink, seed 7, 60 s a row) on 2026-10-17, three runs of every row from the debug build nightly uses plus three more of the AAC rows from a release build, which played alike. Each ceiling is the worst clean run times 1.25, plus one native hiccup sized from the unimpaired Opus row's worst run (20 underruns/min, 50 gap ms/min, 2.2 skips/min, 110 discarded ms/min, 0.01 stalled, 0.005 silence, one 20 ms bucket of target), rounded up to two significant figures. On that host the null sink's clock ran about 150 ppm slow against the monotonic clock, read within 5 ms at p95 per sample, and its output latency sat between 14 and 28 ms. Five of the 36 AAC rows (none of the 18 Opus rows) voided on the clock: the device stopped pulling for about two seconds mid-row, sometimes after a backend error and a stream restart, which is a native playback defect rather than noise, and the ceilings exclude those runs. Re-measure from the nightly runner's artifacts once it has a week of native rows.", + "note": "The browser rows are measured on the nightly runner (ubuntu-24.04-arm, headless Chromium, seed 7, 60 s a row), from the audio-quality-run artifacts of the seven scheduled Nightly runs on main from 2026-10-29 to 2026-11-04 (40885347517, 41065371094, 41204380716, 41313466339, 41483654426, 41656613559, 41852517544), the first after a fresh subscriber stopped receiving the relay's cached history. The AAC rows predate the TS importer publishing each PES as one group. Each ceiling is the worst of its seven nights times 1.25, plus one runner hiccup, rounded up to two significant figures. The hiccup is sized from the single gaps the 2026-10-08 night put on otherwise clean rows, the fixed-250 control among them: 250 underruns/min, 700 gap ms/min, 3.3 skips/min, 280 dropped ms/min (both sized on the playhead's skip-ahead inference, and now applied to player_skips_per_min and trimmed_ms_per_min), 0.01 stalled, 0.015 silence, and one 20 ms bucket of target. Budgeted this way, every night passes when it is held out of its row's measurement except one, and that row's own ceiling includes it: the 2026-11-03 Opus bursty row raised its target to 300 ms 2.6 s in and held it for one 20 s half-life before settling at 180. Such startup holds, Opus near-zero's 100 ms on 2026-10-30 and 10-31 among them, are budgeted as measured. These ceilings record today's player as the runner hears it, not target audio quality. To re-measure, download the same artifact from the latest scheduled nightlies (`gh run download -n audio-quality-run`), which keep every run, and apply the same rule. On 2026-11-10 the inferred skip_aheads and discarded_ms keys were dropped, since they read a time stretch's catch-up as dropped audio, and every browser row gained player_skips_per_min, trimmed_ms_per_min, and av_lag_ms p50 and p95, by the same rule from the only two scheduled nights on main with today's browser player and its trim counter, 2026-11-09 and 2026-11-10 (42659882487, 42842827718). A lag is signed, so its ceiling is the worst night plus a quarter of its size plus one 20 ms bucket. These four keys are provisional until seven nights with the stretch model re-measure every row. The grade follows the model: audio rests on the shared clock, trails it through a stall, and catches up after. When a change moves a row, a steady-state lag (av_lag_ms p50) that rises, or audio the player trimmed, is a regression to fix rather than budget; a p95 lag that rises through a stall, or an underrun count that moves, is re-measured in. No ceiling is fixed at zero underruns or zero stalls; a replay row's is exactly what it measured. The replay rows are deterministic, so their ceilings are exactly what they measured, through the end of each recording, with no headroom: any regression fails them, and an improvement should be tightened in. They were last re-measured on 2026-10-22 using version 3 traces with encoded frame durations: AAC-LC uses its fixed 1024 samples, and relay-mic retains Opus packet TOC durations. relay-mic was re-recorded on 2026-11-03 from a real microphone, Chrome 156 on a MacBook Air publishing its built-in microphone through the public relay, recorded by headless Chromium on a Linux host (35 s, minimum RTT 2 ms), which raised its target ceiling from 60 to 80 ms and its silence from 0 to 0.001 as measured. The recording path itself has no added RTT. relay-mic-rtt40 is the 2026-11-03 Chrome row at 40 ms of added RTT on that laptop (180 s, minimum RTT 47 ms), kept as the baseline time stretch improves on; like every replay row, its player_underruns_per_min ceiling is what it measures, not a fixed zero. player_underruns_per_min, the player's own counter that its stats panel shows, is budgeted on the replay rows only; it counts the run-dry re-stalls the tap files as stalled time. On 2026-11-07, after the ordered read stopped delivering groups below its cursor (#8071) and took Rust's hole and age bounds (#8218), relay-bbb was re-measured at 16.1 player underruns/min, 0.025 stalled and 0.02 silence, and relay-mic-rtt40 at 8.2, its discarded audio at 70.9 ms/min and its target p95 at 320 ms rather than 780, since the stale backlog it never played no longer reaches the estimator; neither row lost audio the previous player heard. On 2026-11-08 the player began time-stretching live playback with NetEq's accelerate, deciding on the ring's depth right after each arrival and never expanding, and every replay row was re-measured with it, the browser rows left to the nightly runner. Each row's av_lag_ms, how far the playhead trails the shared clock video plays from, is what it measured: the ring rests one frame ahead of the newest arrival's playout, as the trim it replaces left it, so audio leads the clock by 19 to 23 ms at p50. Against the trim, the A/V lag p50 fell from 0.7, -17.5, -21.5, -18.2 and -15.6 ms to -22.4 on bursty-aac, -22.2 on local-aac, -22.7 on relay-bbb, -19 on relay-mic and -20.1 on relay-mic-rtt40, and its p95 fell on every row, most on relay-bbb (10.5 to -4.2) and relay-mic-rtt40 (-0.9 to -13.4). Underruns stayed where the trim had them, as the latency they would cost is not spent: player_underruns_per_min held at 4.4, 12.1, 16.1 and 6.1 and rose from 8.2 to 10.6 on relay-mic-rtt40, and relay-mic's tap now files 2 short quanta a minute, 2 ms of missing audio, where it filed none. What the stretch buys is the audio the trim dropped: discarded_ms_per_min fell from 87.8 to 0 on relay-bbb and from 127.5 to 100.6 on local-aac, whose remainder drops nothing: two receive stalls 14 and 15.3 s in leave audio 159 and 132 ms behind the clock, and the fast accelerate brings it back within half a second. player_skips_per_min and trimmed_ms_per_min, the ring's own count of re-anchors that dropped buffered audio and the media they dropped, are budgeted beside it, at 0 on every recorded row. relay-mic-stall, added 2026-11-10, is relay-mic with nothing arriving from 15 s to 16.5 s and the held frames then trickling in at twice real time until 18 s; today's player trims 2152.5 ms/min of it and its target p95 rises to 1540 ms. Once durations became whole nanoseconds, relay-bbb's delay, 200 ms plus one 1024-sample AAC frame, rounds up by a fraction of a sample, so its ring holds one more sample (23 µs) and its A/V lag p50 measures -22.6 rather than -22.7. Neither replay calibration changed the browser or native ceilings. bursty-aac is the 2026-10-18 AAC bursty isolated capture, recorded with the observer subscribed at the decoder's 2 s budget, so it holds every group the player saw. The native rows are provisional: measured on a loaded developer host (x86_64 Linux, the private PulseAudio null sink, seed 7, 60 s a row) on 2026-10-17, three runs of every row from the debug build nightly uses plus three more of the AAC rows from a release build, which played alike. Each ceiling is the worst clean run times 1.25, plus one native hiccup sized from the unimpaired Opus row's worst run (20 underruns/min, 50 gap ms/min, 2.2 skips/min, 110 discarded ms/min, 0.01 stalled, 0.005 silence, one 20 ms bucket of target), rounded up to two significant figures. On 2026-11-10, after native playback began reporting its A/V lag (#8361), the native rows' player_skips_per_min, trimmed_ms_per_min, and av_lag_ms p50 and p95, and every key of the native and browser congestion rows, were measured by the same rules from three runs of each on a loaded developer host (x86_64 Linux, the debug build, seed 7, 60 s a row), with no void; native audio rests 9 to 95 ms behind its clock at p50. These are provisional until the stretch model's nightly re-measure, which also moves the browser congestion rows onto the runner. On the 2026-10-17 host the null sink's clock ran about 150 ppm slow against the monotonic clock, read within 5 ms at p95 per sample, and its output latency sat between 14 and 28 ms. Five of the 36 AAC rows (none of the 18 Opus rows) voided on the clock: the device stopped pulling for about two seconds mid-row, sometimes after a backend error and a stream restart, which is a native playback defect rather than noise, and the ceilings exclude those runs. Re-measure from the nightly runner's artifacts once it has a week of native rows.", "rows": [ { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "bursty", + "player_skips_per_min": 3.3, "underruns_per_min": 260, "underrun_ms_per_min": 710, - "skip_aheads_per_min": 6.1, - "discarded_ms_per_min": 750, + "trimmed_ms_per_min": 280, "stalled_share": 0.022, "silence_share": 0.03, - "target_ms_p95": 450 + "target_ms_p95": 450, + "av_lag_ms_p50": 190, + "av_lag_ms_p95": 200 }, { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "fixed-250", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 340 + "target_ms_p95": 340, + "av_lag_ms_p50": 8, + "av_lag_ms_p95": 15 }, { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "mild", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 290 + "target_ms_p95": 290, + "av_lag_ms_p50": 11, + "av_lag_ms_p95": 17 }, { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "near-zero", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 290 + "target_ms_p95": 290, + "av_lag_ms_p50": 7.5, + "av_lag_ms_p95": 14 }, { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "step", + "player_skips_per_min": 3.3, "underruns_per_min": 260, "underrun_ms_per_min": 710, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.022, "silence_share": 0.023, - "target_ms_p95": 300 + "target_ms_p95": 300, + "av_lag_ms_p50": 61, + "av_lag_ms_p95": 82 }, { "runtime": "chromium", "codec": "aac", "rate": 44100, "profile": "wide", + "player_skips_per_min": 3.3, "underruns_per_min": 260, "underrun_ms_per_min": 710, - "skip_aheads_per_min": 8.8, - "discarded_ms_per_min": 540, + "trimmed_ms_per_min": 280, "stalled_share": 0.033, "silence_share": 0.034, - "target_ms_p95": 430 + "target_ms_p95": 430, + "av_lag_ms_p50": 25, + "av_lag_ms_p95": 85 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "bursty", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 4.7, - "discarded_ms_per_min": 430, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 400 + "target_ms_p95": 400, + "av_lag_ms_p50": 17, + "av_lag_ms_p95": 32 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "fixed-250", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 340 + "target_ms_p95": 340, + "av_lag_ms_p50": 15, + "av_lag_ms_p95": 21 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "mild", + "player_skips_per_min": 3.3, "underruns_per_min": 260, "underrun_ms_per_min": 710, - "skip_aheads_per_min": 4.7, - "discarded_ms_per_min": 360, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.017, - "target_ms_p95": 200 + "target_ms_p95": 200, + "av_lag_ms_p50": 15, + "av_lag_ms_p95": 23 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "near-zero", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 3.3, - "discarded_ms_per_min": 280, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 150 + "target_ms_p95": 150, + "av_lag_ms_p50": 15, + "av_lag_ms_p95": 21 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "step", + "player_skips_per_min": 3.3, "underruns_per_min": 250, "underrun_ms_per_min": 700, - "skip_aheads_per_min": 6.1, - "discarded_ms_per_min": 430, + "trimmed_ms_per_min": 280, "stalled_share": 0.022, "silence_share": 0.019, - "target_ms_p95": 200 + "target_ms_p95": 200, + "av_lag_ms_p50": 70, + "av_lag_ms_p95": 93 }, { "runtime": "chromium", "codec": "opus", "rate": 48000, "profile": "wide", + "player_skips_per_min": 3.3, "underruns_per_min": 260, "underrun_ms_per_min": 710, - "skip_aheads_per_min": 7.5, - "discarded_ms_per_min": 630, + "trimmed_ms_per_min": 280, "stalled_share": 0.01, "silence_share": 0.018, - "target_ms_p95": 620 + "target_ms_p95": 620, + "av_lag_ms_p50": 28, + "av_lag_ms_p95": 70 + }, + { + "runtime": "chromium", + "codec": "aac", + "rate": 44100, + "profile": "congestion", + "player_skips_per_min": 24, + "underruns_per_min": 270, + "underrun_ms_per_min": 720, + "trimmed_ms_per_min": 2300, + "stalled_share": 0.11, + "silence_share": 0.11, + "target_ms_p95": 850, + "av_lag_ms_p50": 1.3, + "av_lag_ms_p95": 44 + }, + { + "runtime": "chromium", + "codec": "opus", + "rate": 48000, + "profile": "congestion", + "player_skips_per_min": 36, + "underruns_per_min": 280, + "underrun_ms_per_min": 740, + "trimmed_ms_per_min": 2400, + "stalled_share": 0.078, + "silence_share": 0.082, + "target_ms_p95": 1300, + "av_lag_ms_p50": 8.3, + "av_lag_ms_p95": 32 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "near-zero", + "player_skips_per_min": 2.2, "underruns_per_min": 44, "underrun_ms_per_min": 110, - "skip_aheads_per_min": 5.0, - "discarded_ms_per_min": 250, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.024, - "target_ms_p95": 300 + "target_ms_p95": 300, + "av_lag_ms_p50": 130, + "av_lag_ms_p95": 150 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "mild", + "player_skips_per_min": 2.2, "underruns_per_min": 25, "underrun_ms_per_min": 58, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.01, - "target_ms_p95": 260 + "target_ms_p95": 260, + "av_lag_ms_p50": 130, + "av_lag_ms_p95": 150 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "wide", + "player_skips_per_min": 2.2, "underruns_per_min": 66, "underrun_ms_per_min": 170, - "skip_aheads_per_min": 3.6, - "discarded_ms_per_min": 180, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.037, - "target_ms_p95": 400 + "target_ms_p95": 400, + "av_lag_ms_p50": 110, + "av_lag_ms_p95": 140 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "bursty", + "player_skips_per_min": 2.2, "underruns_per_min": 170, "underrun_ms_per_min": 450, - "skip_aheads_per_min": 7.6, - "discarded_ms_per_min": 660, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.057, - "target_ms_p95": 650 + "target_ms_p95": 650, + "av_lag_ms_p50": 140, + "av_lag_ms_p95": 200 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "step", + "player_skips_per_min": 3.6, "underruns_per_min": 48, "underrun_ms_per_min": 120, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 150, "stalled_share": 0.01, "silence_share": 0.015, - "target_ms_p95": 330 + "target_ms_p95": 330, + "av_lag_ms_p50": 140, + "av_lag_ms_p95": 170 }, { "runtime": "native", "codec": "aac", "rate": 44100, "profile": "fixed-250", + "player_skips_per_min": 2.2, "underruns_per_min": 20, "underrun_ms_per_min": 50, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.005, - "target_ms_p95": 340 + "target_ms_p95": 340, + "av_lag_ms_p50": 120, + "av_lag_ms_p95": 140 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "near-zero", + "player_skips_per_min": 2.2, "underruns_per_min": 42, "underrun_ms_per_min": 110, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.01, - "target_ms_p95": 120 + "target_ms_p95": 120, + "av_lag_ms_p50": 47, + "av_lag_ms_p95": 57 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "mild", + "player_skips_per_min": 2.2, "underruns_per_min": 35, "underrun_ms_per_min": 88, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.01, - "target_ms_p95": 150 + "target_ms_p95": 150, + "av_lag_ms_p50": 49, + "av_lag_ms_p95": 72 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "wide", + "player_skips_per_min": 2.2, "underruns_per_min": 84, "underrun_ms_per_min": 220, - "skip_aheads_per_min": 5.0, - "discarded_ms_per_min": 220, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.038, - "target_ms_p95": 300 + "target_ms_p95": 300, + "av_lag_ms_p50": 68, + "av_lag_ms_p95": 90 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "bursty", + "player_skips_per_min": 2.2, "underruns_per_min": 110, "underrun_ms_per_min": 270, - "skip_aheads_per_min": 3.6, - "discarded_ms_per_min": 170, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.034, - "target_ms_p95": 350 + "target_ms_p95": 350, + "av_lag_ms_p50": 79, + "av_lag_ms_p95": 110 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "step", + "player_skips_per_min": 2.2, "underruns_per_min": 39, "underrun_ms_per_min": 99, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.01, - "target_ms_p95": 170 + "target_ms_p95": 170, + "av_lag_ms_p50": 50, + "av_lag_ms_p95": 94 }, { "runtime": "native", "codec": "opus", "rate": 48000, "profile": "fixed-250", + "player_skips_per_min": 2.2, "underruns_per_min": 20, "underrun_ms_per_min": 50, - "skip_aheads_per_min": 2.2, - "discarded_ms_per_min": 110, + "trimmed_ms_per_min": 110, "stalled_share": 0.01, "silence_share": 0.005, - "target_ms_p95": 340 + "target_ms_p95": 340, + "av_lag_ms_p50": 36, + "av_lag_ms_p95": 46 + }, + { + "runtime": "native", + "codec": "aac", + "rate": 44100, + "profile": "congestion", + "player_skips_per_min": 7.6, + "underruns_per_min": 1200, + "underrun_ms_per_min": 3200, + "trimmed_ms_per_min": 3000, + "stalled_share": 0.01, + "silence_share": 0.062, + "target_ms_p95": 2600, + "av_lag_ms_p50": 130, + "av_lag_ms_p95": 570 + }, + { + "runtime": "native", + "codec": "opus", + "rate": 48000, + "profile": "congestion", + "player_skips_per_min": 7.6, + "underruns_per_min": 1400, + "underrun_ms_per_min": 3700, + "trimmed_ms_per_min": 2500, + "stalled_share": 0.01, + "silence_share": 0.067, + "target_ms_p95": 2600, + "av_lag_ms_p50": 50, + "av_lag_ms_p95": 1400 }, { "runtime": "replay", @@ -322,8 +430,7 @@ "player_skips_per_min": 0, "underruns_per_min": 0, "underrun_ms_per_min": 0, - "skip_aheads_per_min": 0, - "discarded_ms_per_min": 0, + "trimmed_ms_per_min": 0, "stalled_share": 0.009, "silence_share": 0.012, "target_ms_p95": 343.2, @@ -339,8 +446,7 @@ "player_skips_per_min": 0, "underruns_per_min": 0, "underrun_ms_per_min": 0, - "skip_aheads_per_min": 2, - "discarded_ms_per_min": 100.6, + "trimmed_ms_per_min": 0, "stalled_share": 0.017, "silence_share": 0.021, "target_ms_p95": 203.2, @@ -356,8 +462,7 @@ "player_skips_per_min": 0, "underruns_per_min": 0, "underrun_ms_per_min": 0, - "skip_aheads_per_min": 0, - "discarded_ms_per_min": 0, + "trimmed_ms_per_min": 0, "stalled_share": 0.025, "silence_share": 0.02, "target_ms_p95": 223.2, @@ -373,8 +478,7 @@ "player_skips_per_min": 0, "underruns_per_min": 2, "underrun_ms_per_min": 2, - "skip_aheads_per_min": 0, - "discarded_ms_per_min": 0, + "trimmed_ms_per_min": 0, "stalled_share": 0, "silence_share": 0.002, "target_ms_p95": 80, @@ -390,13 +494,28 @@ "player_skips_per_min": 0, "underruns_per_min": 0.7, "underrun_ms_per_min": 0.5, - "skip_aheads_per_min": 0.3, - "discarded_ms_per_min": 72, + "trimmed_ms_per_min": 0, "stalled_share": 0.003, "silence_share": 0.004, "target_ms_p95": 320, "av_lag_ms_p50": -20.1, "av_lag_ms_p95": -13.4 + }, + { + "runtime": "replay", + "codec": "opus", + "rate": 48000, + "profile": "relay-mic-stall", + "player_underruns_per_min": 6.1, + "player_skips_per_min": 6.1, + "underruns_per_min": 24.2, + "underrun_ms_per_min": 61.2, + "trimmed_ms_per_min": 2152.5, + "stalled_share": 0.067, + "silence_share": 0.076, + "target_ms_p95": 1540, + "av_lag_ms_p50": -19.5, + "av_lag_ms_p95": -9.5 } ] } From c008a8c09afb4649d9a5b5f3ac17056ae91a1646 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 14:11:07 -0800 Subject: [PATCH 4/4] style(audio-quality): format Co-Authored-By: Claude Opus 5.5 --- test/audio-quality/clients/js/src/analyze.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/audio-quality/clients/js/src/analyze.ts b/test/audio-quality/clients/js/src/analyze.ts index e5ede40c75f..8f443e1df9f 100644 --- a/test/audio-quality/clients/js/src/analyze.ts +++ b/test/audio-quality/clients/js/src/analyze.ts @@ -210,7 +210,8 @@ export function analyze(input: Input): Summary { }), ) ?? null; // Both on the media clock, read at one instant, so no reduction to the viewer's is needed. - const lagOf = (s: Sample) => (s.clock === undefined || s.timestamp === undefined ? undefined : s.clock - s.timestamp); + const lagOf = (s: Sample) => + s.clock === undefined || s.timestamp === undefined ? undefined : s.clock - s.timestamp; const behind = playing.flatMap((s) => { const lag = lagOf(s); return lag === undefined ? [] : [lag];