diff --git a/mobile/demo/build-empire-state.mjs b/mobile/demo/build-empire-state.mjs new file mode 100644 index 000000000..f843989bb --- /dev/null +++ b/mobile/demo/build-empire-state.mjs @@ -0,0 +1,927 @@ +#!/usr/bin/env node +/** + * Builds the hero Moment, mobile/demo/moments/empire-state.json: + * "Climbers on the Empire State Building" (DESIGN.md §12.4). + * + * ILLUSTRATIVE. Nothing here happened. The event, the helicopters, their + * callsigns and tail numbers, the witnesses, the chat and the posts are all + * fictional, and the file says so (`illustrative: true`). What is real is the + * place: the building's position and heights, the street corners, the + * heliports, and the neighbouring building massing (midtown-buildings.json). + * + * The helicopter tracks come from a small flight model, not from hand-drawn + * circles: each aircraft flies a constant airspeed in a steady wind, steers + * to hold an orbit radius with a rate-limited heading (about standard rate), + * and drifts in altitude. The ground track that results is what ADS-B shows + * for a real news orbit: stretched downwind, faster on the downwind side, + * with a few metres of position noise. Output is 1 Hz. + * + * node mobile/demo/build-empire-state.mjs + * + * Deterministic: the same seed always writes the same file. + */ +import { writeFile, mkdir } from 'node:fs/promises'; +import { fileURLToPath } from 'node:url'; +import path from 'node:path'; + +/** JSON as the repo's Prettier would write it (so `prettier --check` passes). */ +async function prettyJson(value) { + const text = JSON.stringify(value); + try { + const prettier = await import('prettier'); + return await prettier.format(text, { parser: 'json' }); + } catch { + return `${text}\n`; + } +} + +const HERE = path.dirname(fileURLToPath(import.meta.url)); +const SEED = 0x35_0f1f7a; + +/* ── Place (real) ───────────────────────────────────────────────── */ +const ESB = { lon: -73.98566, lat: 40.74844 }; +const GROUND_MSL = 15; // m, 5th Ave at 34th St +const ROOF = 381; // m above street (102nd floor roof) +const ANTENNA = 443; // m, antenna tip +const DECK_86 = 320; // m, 86th floor open-air deck +const DECK_102 = 373; // m, 102nd floor deck +const DMH = { + lon: -74.00905, + lat: 40.70137, + name: 'Downtown Manhattan Heliport', +}; +const E34 = { + lon: -73.97175, + lat: 40.74245, + name: 'East 34th Street Heliport', +}; +const NJ = { lon: -74.0742, lat: 40.7727, name: 'over Secaucus, NJ' }; + +/* ── Clock (fictional date) ─────────────────────────────────────── */ +const T0 = Date.UTC(2026, 8, 18, 21, 18, 0); // 5:18 PM EDT +const DURATION_S = 25 * 60; +const at = (mmss) => { + const [m, s] = String(mmss).split(':').map(Number); + return T0 + (m * 60 + (s || 0)) * 1000; +}; + +/* ── Deterministic randomness ───────────────────────────────────── */ +function mulberry32(a) { + return () => { + a |= 0; + a = (a + 0x6d2b79f5) | 0; + let t = Math.imul(a ^ (a >>> 15), 1 | a); + t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; + return ((t ^ (t >>> 14)) >>> 0) / 4294967296; + }; +} +const rand = mulberry32(SEED); +const gauss = () => { + let u = 0; + let v = 0; + while (!u) u = rand(); + while (!v) v = rand(); + return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v); +}; + +/* ── Local metric frame ─────────────────────────────────────────── */ +const D2R = Math.PI / 180; +const KX = 111_320 * Math.cos(ESB.lat * D2R); +const KY = 110_574; +const toXY = (p) => [(p.lon - ESB.lon) * KX, (p.lat - ESB.lat) * KY]; +const toLL = (x, y) => ({ lon: ESB.lon + x / KX, lat: ESB.lat + y / KY }); +const KT = 0.514444; +const FT = 0.3048; +const wrap = (d) => (((d % 360) + 540) % 360) - 180; +const bearingXY = (dx, dy) => (Math.atan2(dx, dy) / D2R + 360) % 360; + +/* ── Flight model ───────────────────────────────────────────────── */ +// Wind at 1,000–1,500 ft over Midtown: 14 kt from 290° (blowing toward 110°). +const WIND = { fromDeg: 290, kt: 14 }; +const windV = () => { + const to = (WIND.fromDeg + 180) * D2R; + return [Math.sin(to) * WIND.kt * KT, Math.cos(to) * WIND.kt * KT]; +}; + +/** + * Fly a helicopter through `plan` (a list of legs) and return 1 Hz points. + * Legs: { until, mode:'ground'|'goto'|'orbit', ... }. + */ +function fly({ start, startAltFt, plan, tStart, tEnd, noiseM = 4 }) { + const dt = 0.2; + let [x, y] = toXY(start); + let alt = startAltFt * FT; + let hdg = plan[0].initialHeading ?? 0; + let air = 0; // airspeed m/s + const [wx, wy] = windV(); + const out = []; + let leg = 0; + let nextOut = tStart; + let altPhase = rand() * Math.PI * 2; + for (let t = tStart; t <= tEnd; t += dt * 1000) { + while (leg < plan.length - 1 && t >= plan[leg].until) leg++; + const L = plan[leg]; + let targetAir = (L.kt ?? 0) * KT; + let targetAlt = (L.altFt ?? startAltFt) * FT; + let desired = hdg; + if (L.mode === 'ground') { + targetAir = 0; + targetAlt = (L.altFt ?? 0) * FT; + } else if (L.mode === 'goto') { + const [tx, ty] = toXY(L.to); + desired = bearingXY(tx - x, ty - y); + // Arrive gently: slow down inside 600 m of the end of a goto leg. + const d = Math.hypot(tx - x, ty - y); + if (L.slowNear && d < 600) + targetAir = Math.max(L.slowNear * KT, targetAir * (d / 600)); + } else if (L.mode === 'orbit') { + const [cx, cy] = toXY(L.center); + const dx = x - cx; + const dy = y - cy; + const d = Math.hypot(dx, dy); + const beta = bearingXY(dx, dy); + // Radius breathes a little: pilots never fly a perfect circle. + const r = + L.radius * (1 + 0.06 * Math.sin((t - tStart) / 1000 / 47 + L.radius)); + const err = Math.atan((d - r) / 110) / D2R; + desired = L.dir === 'cw' ? beta + 90 + err : beta - 90 - err; + // The heading that holds that ground track in the wind (crab angle). + const gx = Math.sin(desired * D2R); + const gy = Math.cos(desired * D2R); + const cross = wx * gy - wy * gx; // wind across the track + const crab = Math.asin( + Math.max(-0.9, Math.min(0.9, cross / Math.max(8, targetAir))), + ); + desired = desired + crab / D2R; + } + // Heading: rate-limited, about standard rate (3°/s), up to 5.5°/s. + const maxRate = (L.maxRate ?? 5.5) * dt; + const dh = wrap(desired - hdg); + hdg = (hdg + Math.max(-maxRate, Math.min(maxRate, dh)) + 360) % 360; + // Speed and altitude respond with first-order lags. + air += (targetAir - air) * Math.min(1, dt / 6); + altPhase += dt / 37; + const drift = + L.mode === 'orbit' ? (28 * Math.sin(altPhase) + 9 * gauss()) * FT : 0; + alt += (targetAlt + drift - alt) * Math.min(1, dt / 9); + if (L.mode === 'ground') { + air = 0; + alt += (0 - alt) * Math.min(1, dt / 4); + } else { + x += (Math.sin(hdg * D2R) * air + wx * Math.min(1, air / 10)) * dt; + y += (Math.cos(hdg * D2R) * air + wy * Math.min(1, air / 10)) * dt; + } + if (t >= nextOut) { + nextOut += 1000; + if (L.mode === 'hidden') continue; + const p = toLL(x + gauss() * noiseM, y + gauss() * noiseM); + // ADS-B altitude: 25 ft steps, MSL. + const altFt = Math.round((alt / FT + GROUND_MSL / FT) / 25) * 25; + out.push({ + t: Math.round(t), + lon: Math.round(p.lon * 1e6) / 1e6, + lat: Math.round(p.lat * 1e6) / 1e6, + altM: Math.round(altFt * FT), + }); + } + } + return out; +} + +const near = (p, m, deg) => { + const [x, y] = toXY(p); + return toLL(x + Math.sin(deg * D2R) * m, y + Math.cos(deg * D2R) * m); +}; +const orbitCenter = (m, deg) => near(ESB, m, deg); + +/* ── The three helicopters (fictional) ──────────────────────────── */ +const police = fly({ + start: DMH, + startAltFt: 0, + tStart: T0, + tEnd: T0 + DURATION_S * 1000, + plan: [ + { mode: 'ground', until: at('0:20'), initialHeading: 20 }, + // Up the west side, over the Hudson shoreline, then across to 34th St. + { + mode: 'goto', + to: { lon: -74.0135, lat: 40.7205 }, + kt: 95, + altFt: 900, + until: at('0:55'), + }, + { + mode: 'goto', + to: { lon: -74.0055, lat: 40.739 }, + kt: 110, + altFt: 1100, + until: at('1:40'), + }, + { + mode: 'goto', + to: near(ESB, 520, 240), + kt: 90, + altFt: 1100, + slowNear: 70, + until: at('2:10'), + }, + { + mode: 'orbit', + center: orbitCenter(60, 200), + radius: 470, + kt: 64, + altFt: 1100, + dir: 'ccw', + until: at('14:00'), + }, + // Tightens and steps down once officers reach the 102nd floor deck. + { + mode: 'orbit', + center: orbitCenter(30, 120), + radius: 410, + kt: 58, + altFt: 1000, + dir: 'ccw', + until: at('25:01'), + }, + ], +}); + +const news7 = fly({ + start: NJ, + startAltFt: 900, + tStart: T0 + 85_000, + tEnd: T0 + DURATION_S * 1000, + plan: [ + { + mode: 'goto', + to: { lon: -74.024, lat: 40.7585 }, + kt: 120, + altFt: 1400, + until: at('3:20'), + initialHeading: 120, + }, + { + mode: 'goto', + to: near(ESB, 700, 300), + kt: 105, + altFt: 1450, + slowNear: 80, + until: at('4:30'), + }, + { + mode: 'orbit', + center: orbitCenter(120, 30), + radius: 660, + kt: 76, + altFt: 1450, + dir: 'ccw', + until: at('25:01'), + }, + ], +}); + +const sky4 = fly({ + start: E34, + startAltFt: 0, + tStart: T0 + 330_000, + tEnd: T0 + DURATION_S * 1000, + plan: [ + { mode: 'ground', until: at('6:00'), initialHeading: 300 }, + { + mode: 'goto', + to: near(ESB, 600, 140), + kt: 70, + altFt: 1250, + slowNear: 62, + until: at('7:25'), + }, + { + mode: 'orbit', + center: orbitCenter(90, 160), + radius: 560, + kt: 68, + altFt: 1250, + dir: 'ccw', + until: at('21:00'), + }, + // Leaves for the next story: back out over the East River, south. + { + mode: 'goto', + to: { lon: -73.962, lat: 40.728 }, + kt: 110, + altFt: 1300, + until: at('22:30'), + }, + { + mode: 'goto', + to: { lon: -73.99, lat: 40.69 }, + kt: 120, + altFt: 1300, + until: at('25:01'), + }, + ], +}); + +const tracks = [ + { + id: 'pd-14', + kind: 'helicopter', + label: 'PD-14 (illustrative)', + callsign: 'PD14', + registration: 'ILLUS-14', + type: 'Bell 429', + operator: 'City police aviation (fictional)', + role: 'police', + color: '#5EC8FF', + points: police, + }, + { + id: 'news-7', + kind: 'helicopter', + label: 'NEWS-7 (illustrative)', + callsign: 'NEWS7', + registration: 'ILLUS-07', + type: 'Airbus H125', + operator: 'Channel 7 News (fictional)', + role: 'news', + color: '#FFD166', + points: news7, + }, + { + id: 'sky-4', + kind: 'helicopter', + label: 'SKY-4 (illustrative)', + callsign: 'SKY4', + registration: 'ILLUS-04', + type: 'Airbus H130', + operator: 'Sky 4 News (fictional)', + role: 'news', + color: '#FF9F6B', + points: sky4, + }, +]; + +/* ── Witness captures (fictional people, real corners) ──────────── */ +function aim(p, altM, targetAltM) { + const [x, y] = toXY(p); + const d = Math.hypot(x, y); + return { + headingDeg: Math.round(bearingXY(-x, -y) * 10) / 10, + pitchDeg: Math.round((Math.atan2(targetAltM - altM, d) / D2R) * 10) / 10, + rangeM: Math.round(d), + }; +} +const capture = (id, mmss, where, altM, targetAltM, fovDeg, rest) => ({ + id, + t: at(mmss), + lon: where.lon, + lat: where.lat, + altM, + ...aim(where, altM, targetAltM), + fovDeg, + sealed: true, + ...rest, +}); +const captures = [ + capture( + 'c1', + '0:52', + { lon: -73.98795, lat: 40.74968 }, + 1.5, + DECK_86 + 10, + 22, + { + title: 'Two figures outside the 86th floor fence', + handle: 'kvn_on_34th', + place: 'W 34th St & 6th Ave', + firstEyes: true, + kind: 'photo', + }, + ), + capture( + 'c2', + '3:05', + { lon: -73.98752, lat: 40.74482 }, + 1.5, + DECK_86 + 30, + 30, + { + title: 'North face, police helicopter overhead', + handle: 'jules_flatiron', + place: '5th Ave & 29th St', + kind: 'clip', + }, + ), + capture('c3', '6:10', { lon: -73.99325, lat: 40.75195 }, 142, ROOF + 20, 18, { + title: 'On the mast, east side, from the 40th floor', + handle: 'penn_plaza_40th', + place: '1 Penn Plaza, 40th floor', + kind: 'clip', + }), + capture('c4', '8:40', { lon: -74.00355, lat: 40.75255 }, 9, ROOF, 14, { + title: 'Three helicopters around the spire', + handle: 'hellsk1tchen', + place: 'The High Line at W 30th St', + kind: 'photo', + }), + capture('c5', '12:20', { lon: -73.98805, lat: 40.74745 }, 55, DECK_102, 40, { + title: 'Officers on the 102nd floor deck', + handle: 'lena.ktown', + place: 'Rooftop, W 32nd St (Koreatown)', + kind: 'clip', + }), + capture('c6', '15:30', { lon: -73.98205, lat: 40.75112 }, 1.5, ROOF, 28, { + title: 'Crowd on 5th Ave looking up', + handle: 'midtown_mara', + place: '5th Ave & 38th St', + kind: 'photo', + }), + capture('c7', '19:45', { lon: -73.97765, lat: 40.74662 }, 48, DECK_102, 20, { + title: 'Both back over the rail at 102', + handle: 'rooftop_rafa', + place: 'Rooftop, Murray Hill', + kind: 'clip', + }), + capture( + 'c8', + '21:10', + { lon: -73.98875, lat: 40.74905 }, + 1.5, + ROOF - 40, + 34, + { + title: 'SKY-4 peeling away east', + handle: 'deli_guy_dan', + place: 'Broadway & 33rd St (Herald Sq)', + kind: 'photo', + }, + ), +]; + +/* ── Live lane: chat (fictional handles) ────────────────────────── */ +// [m:ss, handle, text, badge?]. Bursts follow the beats: first sighting, +// police arrival, news arrival, the mast climb, the top, officers on deck, +// coming down. +const CHAT = [ + ['0:12', 'deli_guy_dan', 'why is everyone on 34th looking up'], + [ + '0:31', + 'kvn_on_34th', + 'theres PEOPLE on the empire state. outside the fence on 86', + 'local', + ], + ['0:38', 'midtown_mara', 'wait what'], + ['0:44', 'brklyn_bea', 'link??'], + [ + '0:52', + 'kvn_on_34th', + 'sealed photo up. north side, two of them', + 'first-eyes', + ], + ['0:58', 'throwaway_tom', 'thats a window washer rig'], + ['1:04', 'kvn_on_34th', 'no rig. no ropes that I can see', 'first-eyes'], + ['1:10', 'jules_flatiron', 'omg I see them from 29th'], + ['1:19', 'nyc_scanner_nerd', 'scanner: units responding to 350 5th', 'local'], + ['1:33', 'ess_ay_dee', '👀👀👀'], + ['1:41', 'midtown_mara', 'this is insane'], + [ + '1:52', + 'avgeek_jfk', + 'police helo just lifted out of the downtown heliport', + 'pilot', + ], + ['2:04', 'brklyn_bea', 'I hear it'], + ['2:10', 'nyc_scanner_nerd', 'PD-14 overhead now, orbiting', 'local'], + ['2:12', 'deli_guy_dan', 'LOUD'], + ['2:14', 'ess_ay_dee', '🔥🔥'], + ['2:16', 'hellsk1tchen', 'can see the heli circling from the west side'], + ['2:21', 'throwaway_tom', 'ok not window washers lol'], + ['2:25', 'murrayhill_mo', 'is this a protest?'], + [ + '2:31', + 'kvn_on_34th', + 'no banner, they just look like climbers. helmets', + 'first-eyes', + ], + ['2:44', 'lena.ktown', 'going up to our roof'], + ['2:58', 'jules_flatiron', 'clip sealed from 5th & 29th', 'witness'], + ['3:12', 'brklyn_bea', 'how did they even get out there'], + [ + '3:26', + 'avgeek_jfk', + 'orbit looks ~1,100 ft, tight, maybe 500 m radius', + 'pilot', + ], + ['3:39', 'midtown_mara', 'they are not moving'], + ['3:55', 'ess_ay_dee', 'pray for them fr'], + ['4:08', 'nyc_scanner_nerd', 'second helo inbound from jersey', 'local'], + ['4:22', 'deli_guy_dan', 'news is here'], + ['4:30', 'avgeek_jfk', 'NEWS-7 up high, ~1,450', 'pilot'], + ['4:33', 'murrayhill_mo', 'its on tv now'], + ['4:35', 'brklyn_bea', 'channel 7 live rn'], + ['4:37', 'ess_ay_dee', '😮'], + ['4:41', 'throwaway_tom', 'tv is 40s behind this chat lmao'], + ['4:52', 'hellsk1tchen', 'two helis circling opposite sides'], + ['5:10', 'kvn_on_34th', 'THEY ARE CLIMBING. the mast', 'first-eyes'], + ['5:12', 'midtown_mara', 'NO'], + ['5:13', 'jules_flatiron', 'oh my god'], + ['5:15', 'deli_guy_dan', 'nope nope nope'], + ['5:17', 'ess_ay_dee', '😮😮😮'], + ['5:20', 'brklyn_bea', 'im shaking'], + [ + '5:24', + 'lena.ktown', + 'on the roof, I can see them on the east side', + 'local', + ], + ['5:31', 'murrayhill_mo', 'how high is that'], + ['5:36', 'avgeek_jfk', 'mast starts ~1,250 ft. antenna tip 1,454', 'pilot'], + ['5:52', 'throwaway_tom', 'who does this'], + [ + '6:02', + 'nyc_scanner_nerd', + 'third helo lifting from E 34th St heliport', + 'local', + ], + [ + '6:10', + 'penn_plaza_40th', + 'from 1 Penn 40th fl. sealed. they are halfway up the mast', + 'witness', + ], + ['6:14', 'deli_guy_dan', 'thats so close'], + ['6:25', 'midtown_mara', 'is that a drone?'], + ['6:40', 'hellsk1tchen', 'drone over by the river too'], + [ + '6:58', + 'avgeek_jfk', + 'not a drone, thats SKY-4 coming off the E 34th pad', + 'pilot', + ], + ['7:20', 'brklyn_bea', 'three helicopters now'], + ['7:26', 'ess_ay_dee', '🔥🔥🔥'], + [ + '7:41', + 'metwx_paul', + 'winds ~15 kt from WNW at 1,000+ ft. thats why the orbits look stretched east', + 'met', + ], + ['7:58', 'jules_flatiron', 'the gusts up there must be brutal'], + ['8:12', 'murrayhill_mo', 'they stopped'], + ['8:30', 'kvn_on_34th', 'one is waving??', 'first-eyes'], + [ + '8:40', + 'hellsk1tchen', + 'sealed from the high line, all three helis in frame', + 'witness', + ], + ['8:51', 'deli_guy_dan', 'crowd on 5th is massive now'], + ['9:05', 'brklyn_bea', 'please come down'], + ['9:22', 'lena.ktown', 'they are going higher', 'witness'], + ['9:34', 'throwaway_tom', 'HOW'], + ['9:40', 'kvn_on_34th', 'ONE IS AT THE TOP OF THE MAST', 'first-eyes'], + ['9:41', 'midtown_mara', 'NOOOO'], + ['9:42', 'ess_ay_dee', '😮😮😮😮'], + ['9:43', 'jules_flatiron', 'oh my god oh my god'], + ['9:44', 'deli_guy_dan', 'cant watch'], + ['9:46', 'murrayhill_mo', 'insane'], + ['9:48', 'brklyn_bea', '😭'], + ['9:51', 'hellsk1tchen', 'the whole avenue just gasped'], + ['9:55', 'penn_plaza_40th', 'whole office is at the window', 'witness'], + [ + '10:08', + 'heli_dispatch_ret', + 'three ships stacked 1,000/1,250/1,450, all left orbits. textbook', + 'pilot', + ], + ['10:22', 'throwaway_tom', 'helmet cam. this is for a video 100%'], + [ + '10:40', + 'avgeek_jfk', + 'NEWS-7 widening out, prob for the wide shot', + 'pilot', + ], + ['11:05', 'midtown_mara', 'is the deck closed?'], + [ + '11:20', + 'nyc_scanner_nerd', + 'scanner says deck cleared, ESU going up', + 'local', + ], + ['11:42', 'brklyn_bea', 'come on come on'], + ['12:05', 'murrayhill_mo', 'whats ESU'], + [ + '12:11', + 'nyc_scanner_nerd', + 'emergency service unit. rescue specialists', + 'local', + ], + [ + '12:20', + 'lena.ktown', + 'sealed: officers on the 102 deck right under them', + 'witness', + ], + ['12:24', 'ess_ay_dee', '🙏'], + ['12:35', 'deli_guy_dan', 'they are talking to them i think'], + ['13:02', 'jules_flatiron', 'PD-14 dropping lower'], + [ + '13:40', + 'heli_dispatch_ret', + 'police ship tightening the orbit, stepping down to ~1,000', + 'pilot', + ], + ['14:10', 'throwaway_tom', 'third climber on the setback??'], + ['14:14', 'midtown_mara', 'wait three??'], + ['14:20', 'brklyn_bea', 'I see a third one'], + [ + '14:48', + 'jules_flatiron', + 'thats the mast shadow lol. compare the 5th ave and high line shots', + 'witness', + ], + ['15:02', 'hellsk1tchen', 'yeah shadow, sun is behind us', 'witness'], + [ + '15:30', + 'midtown_mara', + 'sealed from 38th, the crowd is all phones', + 'witness', + ], + ['15:51', 'deli_guy_dan', 'sold out of water lol'], + ['16:20', 'murrayhill_mo', 'how long has it been'], + ['16:24', 'kvn_on_34th', '16 min since I saw them', 'first-eyes'], + ['16:50', 'ess_ay_dee', '❤️❤️'], + ['17:15', 'brklyn_bea', 'they are moving'], + ['17:30', 'lena.ktown', 'coming DOWN', 'witness'], + ['17:32', 'midtown_mara', 'YES'], + ['17:34', 'deli_guy_dan', 'thank god'], + ['17:36', 'ess_ay_dee', '❤️❤️❤️'], + ['17:55', 'throwaway_tom', 'slowly. slowly'], + ['18:30', 'jules_flatiron', 'first one at the rail'], + ['18:58', 'penn_plaza_40th', 'officers reaching over the rail', 'witness'], + ['19:20', 'kvn_on_34th', 'ONE IS IN', 'first-eyes'], + ['19:22', 'brklyn_bea', '😭😭'], + ['19:24', 'midtown_mara', 'ok im crying'], + ['19:40', 'lena.ktown', 'SECOND ONE IN', 'witness'], + ['19:42', 'deli_guy_dan', 'LETS GOOO'], + ['19:43', 'ess_ay_dee', '❤️🔥❤️🔥'], + ['19:44', 'murrayhill_mo', 'the street is clapping'], + [ + '19:45', + 'rooftop_rafa', + 'sealed from murray hill, both over the rail', + 'witness', + ], + ['19:50', 'hellsk1tchen', 'cheering from the high line too'], + ['20:10', 'throwaway_tom', 'they are so arrested'], + [ + '20:40', + 'nyc_scanner_nerd', + 'scanner: two in custody, no injuries reported', + 'local', + ], + ['21:00', 'avgeek_jfk', 'SKY-4 departing east, next story', 'pilot'], + ['21:10', 'deli_guy_dan', 'sealed one of SKY-4 leaving', 'witness'], + ['21:35', 'jules_flatiron', 'what a day for midtown'], + ['22:10', 'midtown_mara', 'the replay of this is gonna be wild'], + ['22:40', 'brklyn_bea', 'thank you everyone for the updates'], + [ + '23:15', + 'heli_dispatch_ret', + 'NEWS-7 and PD-14 still up. will hold till the street clears', + 'pilot', + ], + ['24:05', 'murrayhill_mo', 'traffic on 5th still stopped'], + [ + '24:40', + 'kvn_on_34th', + 'cant believe I just looked up at the right time', + 'first-eyes', + ], +]; + +/* ── Record lane: posts ─────────────────────────────────────────── */ +const POSTS = [ + [ + '0:58', + 'kvn_on_34th', + 'witness', + 'Two people outside the safety fence on the 86th floor setback, north face. Sealed photo from W 34th St & 6th Ave, 22° zoom.', + 412, + ], + [ + '2:40', + 'midtown_mara', + 'question', + 'Is the observation deck being cleared? Is anyone still up there?', + 88, + ], + [ + '3:30', + 'nyc_scanner_nerd', + 'context', + 'Police aviation is on scene, orbiting at about 1,100 ft. News helicopters usually follow within minutes.', + 230, + ], + [ + '6:15', + 'penn_plaza_40th', + 'witness', + 'From 1 Penn Plaza, 40th floor: both are on the mooring mast, east side, about halfway up. Sealed clip.', + 377, + ], + [ + '7:05', + 'avgeek_jfk', + 'correction', + 'The "drone" in clips around 6:30 is SKY-4 lifting out of the East 34th St heliport. Its track matches.', + 156, + ], + [ + '7:50', + 'metwx_paul', + 'context', + 'Wind at 1,000–1,500 ft is about 15 kt from the WNW. That is why every orbit looks stretched toward the East River.', + 141, + ], + [ + '10:15', + 'heli_dispatch_ret', + 'context', + 'Three helicopters holding 1,000, 1,250 and 1,450 ft in left-hand orbits. Staggered altitudes are normal deconfliction.', + 264, + ], + [ + '12:25', + 'lena.ktown', + 'witness', + 'Rooftop in Koreatown: officers visible on the 102nd floor deck directly below the climbers. Sealed.', + 198, + ], + [ + '14:55', + 'jules_flatiron', + 'correction', + "There is no third climber. The figure on the setback is the mast's shadow: compare the 5th Ave and High Line captures, taken 6 minutes apart.", + 301, + ], + ['16:10', 'brklyn_bea', 'question', 'Has anyone been hurt?', 64], + [ + '19:50', + 'rooftop_rafa', + 'witness', + 'Both are back over the rail at the 102nd floor and officers have them. Sealed clip from Murray Hill.', + 520, + ], + [ + '20:45', + 'nyc_scanner_nerd', + 'context', + 'Scanner traffic: two in custody, no injuries reported. Unconfirmed until an official statement.', + 187, + ], +]; + +/* ── Beats (for timeline pips) ──────────────────────────────────── */ +const BEATS = [ + ['0:52', 'First sealed capture: two figures outside the 86th floor fence'], + ['2:10', 'Police helicopter on scene'], + ['4:30', 'NEWS-7 arrives'], + ['5:10', 'Climbers start up the mast'], + ['7:25', 'SKY-4 joins: three helicopters orbiting'], + ['9:40', 'One climber at the top of the mast'], + ['12:20', 'Officers on the 102nd floor deck'], + ['17:30', 'Climbers start down'], + ['19:40', 'Both back over the rail'], + ['21:00', 'SKY-4 departs'], +]; + +/* ── Cinematic camera path, keyed to time ───────────────────────── */ +// Each key: bearing from the building, ground range, the camera's pitch +// down to the look point, and the look point's height (default the deck). +function camKey( + mmss, + bearingFromEsb, + rangeM, + pitchDownDeg, + lookAltM = DECK_86, +) { + const heightM = Math.round(lookAltM + Math.tan(pitchDownDeg * D2R) * rangeM); + const p = near(ESB, rangeM, bearingFromEsb); + const [x, y] = toXY(p); + const heading = bearingXY(-x, -y); + const pitch = Math.atan2(lookAltM - heightM, Math.hypot(x, y)) / D2R; + return { + t: at(mmss), + lon: Math.round(p.lon * 1e6) / 1e6, + lat: Math.round(p.lat * 1e6) / 1e6, + height: heightM, + heading: Math.round(heading * 10) / 10, + pitch: Math.round(pitch * 10) / 10, + }; +} +const cameraPath = [ + camKey('0:00', 212, 4200, 30, 150), + camKey('1:00', 218, 3200, 30, 200), + camKey('2:00', 228, 2300, 31, 260), + camKey('3:30', 248, 1800, 32), + camKey('5:00', 278, 1550, 31, ROOF), + camKey('6:30', 308, 1450, 30, ROOF), + camKey('8:00', 338, 1350, 29, ROOF), + camKey('9:40', 6, 1150, 26, ROOF + 20), + camKey('11:30', 38, 1350, 29, ROOF), + camKey('13:30', 72, 1650, 32), + camKey('15:30', 108, 1900, 34), + camKey('17:30', 142, 1600, 31, ROOF), + camKey('19:40', 172, 1300, 27, DECK_102), + camKey('21:30', 198, 2000, 31), + camKey('23:30', 216, 3000, 31, 220), + camKey('25:00', 224, 4000, 30, 150), +]; + +/* ── Assemble ───────────────────────────────────────────────────── */ +const jitter = (t, s) => t + Math.round(gauss() * s * 1000); +const chat = CHAT.map(([mmss, handle, text, badge]) => ({ + t: jitter(at(mmss), 1.2), + handle, + text, + ...(badge ? { badge } : {}), +})).sort((a, b) => a.t - b.t); +const posts = POSTS.map(([mmss, handle, kind, text, votes], i) => ({ + id: `p${i + 1}`, + t: at(mmss), + handle, + kind, + text, + votes, + ...(captures.find( + (c) => c.handle === handle && Math.abs(c.t - at(mmss)) < 60_000, + ) + ? { + captureId: captures.find( + (c) => c.handle === handle && Math.abs(c.t - at(mmss)) < 60_000, + ).id, + } + : {}), +})); + +const moment = { + id: 'empire-state', + title: 'Climbers on the Empire State Building', + place: 'Midtown Manhattan, New York', + lon: ESB.lon, + lat: ESB.lat, + time: { start: T0, end: T0 + DURATION_S * 1000 }, + illustrative: true, + illustrativeNote: + 'Illustrative reconstruction. The event, aircraft, callsigns, people, chat and posts are fictional; the place, building heights and heliports are real.', + recommendedSpeed: 30, + groundMslM: GROUND_MSL, + subject: { + lon: ESB.lon, + lat: ESB.lat, + altM: DECK_86, + label: 'Empire State Building', + roofM: ROOF, + antennaM: ANTENNA, + decks: [DECK_86, DECK_102], + }, + stage: { buildings: 'midtown-buildings.json', highlight: '1015862' }, + wind: WIND, + cameraPath, + beats: BEATS.map(([mmss, title]) => ({ t: at(mmss), title })), + tracks, + captures, + chat, + posts, + sources: [ + { + name: 'Illustrative reconstruction', + detail: + 'Helicopter tracks are synthetic, from a flight model (constant airspeed, 14 kt wind, rate-limited turns) shaped like real news and police orbits. Callsigns and tail numbers are fictional and are not real registrations.', + }, + { + name: 'NYC Open Data · Building Footprints', + detail: + 'Real footprints and roof heights for Midtown (NYC OTI, dataset 5zhs-2jue).', + }, + { + name: 'Esri World Imagery', + detail: 'Base imagery of the real place.', + }, + { + name: 'Simulated Live and Record lanes', + detail: + 'Chat, posts, handles and witness captures are simulated to show how a room forms around an event.', + }, + ], +}; + +await mkdir(path.join(HERE, 'moments'), { recursive: true }); +const file = path.join(HERE, 'moments', 'empire-state.json'); +await writeFile(file, await prettyJson(moment)); +console.log( + `wrote ${file}: ${tracks.map((t) => `${t.id} ${t.points.length} pts`).join(', ')}, ` + + `${captures.length} captures, ${chat.length} chat, ${posts.length} posts`, +); diff --git a/mobile/demo/build-midtown.mjs b/mobile/demo/build-midtown.mjs new file mode 100644 index 000000000..28aec8fbd --- /dev/null +++ b/mobile/demo/build-midtown.mjs @@ -0,0 +1,139 @@ +#!/usr/bin/env node +/** + * Builds mobile/demo/midtown-buildings.json: real building massing for the + * Empire State Moment, from NYC Open Data "Building Footprints" (DoITT, + * dataset 5zhs-2jue, roof heights from photogrammetry). Every building + * within 1.6 km of the Empire State Building whose roof is over 60 ft, and + * towers over 200 ft out to 2.6 km (so the massing thins out instead of + * ending at a hard circle). + * + * node mobile/demo/build-midtown.mjs [path/to/cached.json] + * + * Output: { origin:[lon,lat], source, fetchedAt, b:[[roofM, groundM, x0,y0,x1,y1,…]] } + * where x/y are integer metres east/north of `origin` (outer ring only, + * Douglas-Peucker simplified to 1 m). + */ +import { readFile, writeFile } from 'node:fs/promises'; +import { fileURLToPath } from 'node:url'; +import path from 'node:path'; + +/** JSON as the repo's Prettier would write it (so `prettier --check` passes). */ +async function prettyJson(value) { + const text = JSON.stringify(value); + try { + const prettier = await import('prettier'); + return await prettier.format(text, { parser: 'json' }); + } catch { + return `${text}\n`; + } +} + +const HERE = path.dirname(fileURLToPath(import.meta.url)); +const ORIGIN = [-73.9857, 40.7484]; +const FT = 0.3048; + +async function load() { + const cached = process.argv[2]; + if (cached) return JSON.parse(await readFile(cached, 'utf8')); + const url = new URL('https://data.cityofnewyork.us/resource/5zhs-2jue.json'); + url.searchParams.set( + '$select', + 'the_geom,height_roof,ground_elevation,bin,construction_year', + ); + url.searchParams.set( + '$where', + `within_circle(the_geom,${ORIGIN[1]},${ORIGIN[0]},2600) AND height_roof > 60`, + ); + url.searchParams.set('$limit', '20000'); + const r = await fetch(url); + if (!r.ok) throw new Error(`NYC Open Data HTTP ${r.status}`); + return r.json(); +} + +const kx = 111_320 * Math.cos((ORIGIN[1] * Math.PI) / 180); +const ky = 110_574; +const toXY = ([lon, lat]) => [(lon - ORIGIN[0]) * kx, (lat - ORIGIN[1]) * ky]; + +function simplify(pts, tol) { + if (pts.length < 4) return pts; + const keep = new Uint8Array(pts.length); + keep[0] = keep[pts.length - 1] = 1; + const stack = [[0, pts.length - 1]]; + while (stack.length) { + const [a, b] = stack.pop(); + const [ax, ay] = pts[a]; + const [bx, by] = pts[b]; + const dx = bx - ax; + const dy = by - ay; + const len = Math.hypot(dx, dy) || 1e-9; + let best = -1; + let bestD = tol; + for (let i = a + 1; i < b; i++) { + const d = Math.abs((pts[i][0] - ax) * dy - (pts[i][1] - ay) * dx) / len; + if (d > bestD) { + bestD = d; + best = i; + } + } + if (best > 0) { + keep[best] = 1; + stack.push([a, best], [best, b]); + } + } + return pts.filter((_, i) => keep[i]); +} + +const rows = await load(); +const out = []; +for (const row of rows) { + const roof = Number(row.height_roof) * FT; + if (!Number.isFinite(roof) || roof < 18) continue; + const ground = Number(row.ground_elevation) * FT; + const polys = row.the_geom?.coordinates || []; + // The largest outer ring stands for the building. + let ring = null; + for (const poly of polys) { + const r = poly[0]; + if (r && (!ring || r.length > ring.length)) ring = r; + } + if (!ring || ring.length < 4) continue; + let pts = ring.map(toXY); + const [fx, fy] = pts[0]; + const dist = Math.hypot(fx, fy); + if (dist > 2600) continue; + // Beyond 1.6 km only towers, thinning out with distance. + if (dist > 1600 && roof < 61 + ((dist - 1600) / 1000) * 60) continue; + // Open ring: split at the farthest vertex so both halves simplify cleanly. + pts = pts.slice(0, -1); + let far = 1; + for (let i = 1; i < pts.length; i++) + if ( + Math.hypot(pts[i][0] - pts[0][0], pts[i][1] - pts[0][1]) > + Math.hypot(pts[far][0] - pts[0][0], pts[far][1] - pts[0][1]) + ) + far = i; + pts = [ + ...simplify(pts.slice(0, far + 1), 1.0), + ...simplify([...pts.slice(far), pts[0]], 1.0).slice(1, -1), + ]; + if (pts.length < 3) continue; + const flat = []; + for (const [x, y] of pts) flat.push(Math.round(x), Math.round(y)); + out.push([ + Math.round(roof * 10) / 10, + Number.isFinite(ground) ? Math.round(ground * 10) / 10 : 15, + ...flat, + ]); +} +out.sort((a, b) => a[0] - b[0]); +const doc = { + origin: ORIGIN, + source: + 'NYC Open Data · Building Footprints (NYC OTI/DoITT, 5zhs-2jue), roof heights from photogrammetry', + fetchedAt: new Date().toISOString(), + count: out.length, + b: out, +}; +const file = path.join(HERE, 'midtown-buildings.json'); +await writeFile(file, await prettyJson(doc)); +console.log(`wrote ${out.length} buildings → ${file}`); diff --git a/mobile/demo/capture-snapshot.mjs b/mobile/demo/capture-snapshot.mjs new file mode 100644 index 000000000..fc56741d3 --- /dev/null +++ b/mobile/demo/capture-snapshot.mjs @@ -0,0 +1,144 @@ +#!/usr/bin/env node +/** + * Regenerates the bundled first-frame snapshot (DESIGN.md §12.8): + * + * mobile/demo/snapshot.json the live situations() result, with capturedAt + * mobile/demo/thumbs/.jpg each card's composited thumbnail + * + * It drives the real engine in headless Chromium against a running dev + * server, so every card is real data at capture time. + * + * npm run dev # or: npx vite --port 4173 + * node mobile/demo/capture-snapshot.mjs [--base http://localhost:4173] + * [--chrome /path/to/chrome] [--max 28] [--quality 0.8] + * [--lat 40.75 --lon -73.98] # a viewer position for distances + * + * Budget: thumbnails are 360×480 CSS px at 1.25× and JPEG-recompressed so + * the whole folder stays under ~3 MB. + */ +import { mkdir, readdir, rm, writeFile } from 'node:fs/promises'; +import { createRequire } from 'node:module'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const HERE = path.dirname(fileURLToPath(import.meta.url)); +const require = createRequire(path.join(HERE, '..', '..', 'package.json')); +const args = Object.fromEntries( + process.argv + .slice(2) + .join(' ') + .split('--') + .filter(Boolean) + .map((kv) => { + const [k, ...v] = kv.trim().split(/\s+/); + return [k, v.join(' ') || true]; + }), +); +const BASE = args.base || 'http://localhost:4173'; +const MAX = Number(args.max || 28); +const QUALITY = Number(args.quality || 0.8); +const BUDGET = 3 * 1024 * 1024; + +const puppeteer = (await import(require.resolve('puppeteer'))).default; +const browser = await puppeteer.launch({ + executablePath: args.chrome || process.env.CHROME_PATH || undefined, + args: [ + '--use-gl=angle', + '--use-angle=swiftshader', + '--enable-unsafe-swiftshader', + '--ignore-gpu-blocklist', + '--no-sandbox', + ], + protocolTimeout: 600_000, +}); +try { + const page = await browser.newPage(); + await page.setViewport({ width: 430, height: 932, deviceScaleFactor: 1 }); + page.on('pageerror', (e) => console.warn('[page]', e.message)); + await page.goto(`${BASE}/mobile/globe/dev.html?hud=0&labels=0`, { + waitUntil: 'domcontentloaded', + timeout: 120_000, + }); + await page.waitForFunction('window.globe', { timeout: 120_000 }); + console.log('engine up; building live situations (this takes ~30–60 s)…'); + const viewer = + args.lat && args.lon + ? { lat: Number(args.lat), lon: Number(args.lon) } + : null; + const result = await page.evaluate( + async ({ max, quality, viewer }) => { + if (viewer) globe.setViewer(viewer); + // Warm the recorder a little so detections have a chance to show. + const list = (await globe.situations()).slice(0, max); + const out = []; + for (const s of list) { + let thumb = null; + try { + const url = await globe.thumbnail(s, { + width: 360, + height: 480, + dpr: 1.25, + }); + const img = await createImageBitmap(await (await fetch(url)).blob()); + const c = document.createElement('canvas'); + c.width = img.width; + c.height = img.height; + c.getContext('2d').drawImage(img, 0, 0); + const blob = await new Promise((r) => + c.toBlob(r, 'image/jpeg', quality), + ); + const buf = new Uint8Array(await blob.arrayBuffer()); + let bin = ''; + for (let i = 0; i < buf.length; i += 0x8000) + bin += String.fromCharCode(...buf.subarray(i, i + 0x8000)); + thumb = btoa(bin); + } catch (error) { + console.warn('thumbnail failed', s.id, error?.message); + } + out.push({ situation: JSON.parse(JSON.stringify(s)), thumb }); + } + return out; + }, + { max: MAX, quality: QUALITY, viewer }, + ); + const thumbsDir = path.join(HERE, 'thumbs'); + await mkdir(thumbsDir, { recursive: true }); + for (const f of await readdir(thumbsDir)) + if (f.endsWith('.jpg')) await rm(path.join(thumbsDir, f)); + let bytes = 0; + const situations = []; + for (const { situation, thumb } of result) { + const file = `${String(situation.id).replace(/[^\w.-]+/g, '_')}.jpg`; + if (thumb) { + const buf = Buffer.from(thumb, 'base64'); + if (bytes + buf.length > BUDGET) { + console.warn(`budget reached; ${situation.id} ships without a thumb`); + } else { + bytes += buf.length; + await writeFile(path.join(thumbsDir, file), buf); + situation.thumbFile = `thumbs/${file}`; + } + } + situations.push(situation); + } + const snapshot = { + capturedAt: new Date().toISOString(), + source: + 'Live God’s Eye feeds through the dev server (see each card’s source)', + note: 'Bundled first frame for demos. The shell shows capturedAt and replaces these with live cards as soon as situations() resolves.', + situations, + }; + let text = JSON.stringify(snapshot); + try { + const prettier = await import('prettier'); + text = await prettier.format(text, { parser: 'json' }); + } catch { + text += '\n'; + } + await writeFile(path.join(HERE, 'snapshot.json'), text); + console.log( + `wrote ${situations.length} situations, ${Math.round(bytes / 1024)} KB of thumbnails`, + ); +} finally { + await browser.close(); +} diff --git a/mobile/demo/midtown-buildings.json b/mobile/demo/midtown-buildings.json new file mode 100644 index 000000000..0c23fc26c --- /dev/null +++ b/mobile/demo/midtown-buildings.json @@ -0,0 +1,10247 @@ +{ + "origin": [-73.9857, 40.7484], + "source": "NYC Open Data · Building Footprints (NYC OTI/DoITT, 5zhs-2jue), roof heights from photogrammetry", + "fetchedAt": "2026-10-23T07:26:04.961Z", + "count": 3928, + "b": [ + [18.3, 11.6, 531, -652, 520, -673, 513, -669, 524, -649], + [ + 18.3, 8.8, -1, -1220, -9, -1235, -14, -1232, -15, -1234, -14, -1235, -16, + -1240, -20, -1238, -8, -1216 + ], + [18.3, 7.6, 1443, 675, 1464, 663, 1461, 656, 1438, 669, 1442, 675], + [ + 18.3, 4.6, -1307, -268, -1326, -258, -1322, -251, -1299, -265, -1302, + -270, -1306, -267 + ], + [ + 18.3, 5.5, 283, -1506, 280, -1510, 279, -1510, 278, -1512, 279, -1513, + 275, -1519, 269, -1516, 272, -1509, 274, -1510, 275, -1508, 273, -1507, + 281, -1495, 286, -1498 + ], + [18.3, 12.2, -386, 1138, -399, 1115, -406, 1119, -393, 1142], + [18.3, 11, 973, 53, 944, 1, 916, 17, 944, 68], + [18.3, 13.1, -15, -163, -19, -170, -46, -156, -42, -149], + [18.3, 16.2, -173, 934, -156, 924, -170, 898, -198, 914, -183, 940], + [18.3, 10.4, -487, 1316, -491, 1309, -506, 1317, -502, 1324], + [18.3, 12.2, -380, 1134, -393, 1111, -399, 1115, -386, 1138], + [18.3, 12.8, -34, -323, -38, -329, -64, -315, -61, -308], + [18.3, 2.7, -1522, -115, -1530, -130, -1536, -127, -1528, -112], + [ + 18.3, 4.9, -1290, -50, -1300, -66, -1299, -67, -1303, -73, -1310, -70, + -1303, -60, -1302, -61, -1300, -58, -1302, -57, -1301, -54, -1297, -47 + ], + [ + 18.3, 20.1, 609, 117, 600, 101, 593, 105, 608, 131, 615, 127, 612, 122, + 608, 125, 604, 119 + ], + [ + 18.3, 13.4, -186, 1330, -181, 1327, -181, 1326, -179, 1324, -178, 1326, + -171, 1322, -175, 1315, -182, 1319, -181, 1320, -184, 1322, -184, 1320, + -202, 1330, -199, 1335 + ], + [18.3, 13.7, -253, 426, -266, 402, -272, 405, -257, 431], + [18.3, 10.7, -125, -1235, -138, -1259, -152, -1251, -138, -1228], + [18.3, 17.7, 675, 171, 666, 155, 661, 158, 675, 184, 679, 181, 672, 172], + [18.3, 21, 516, -2, 504, -24, 497, -20, 506, -3, 511, -5, 514, -1], + [18.3, 4.3, 519, -1332, 506, -1354, 500, -1351, 512, -1328], + [18.3, 8.8, -907, -749, -894, -725, -882, -732, -895, -755], + [18.3, 10.7, -207, -1021, -216, -1039, -223, -1035, -213, -1018], + [18.3, 21, 520, -11, 511, -27, 504, -24, 516, -2, 519, -4, 517, -9], + [ + 18.3, 9.4, -5, -1513, -8, -1511, -7, -1510, -16, -1507, -9, -1492, 0, + -1498, 0, -1497, 4, -1499, -4, -1513 + ], + [18.3, 11.6, 407, -682, 404, -688, 386, -679, 390, -672], + [ + 18.3, 9.8, 551, -825, 569, -835, 565, -842, 547, -832, 548, -830, 544, + -828, 546, -825, 550, -827 + ], + [18.3, 6.1, -1215, -463, -1225, -481, -1231, -477, -1222, -460], + [ + 18.4, 8.8, -932, -251, -940, -263, -946, -274, -952, -271, -945, -260, + -938, -244, -930, -248 + ], + [18.4, 14, -331, -313, -343, -334, -350, -330, -338, -309], + [ + 18.4, 5.8, -1228, -656, -1226, -659, -1225, -658, -1220, -662, -1208, + -668, -1212, -674, -1228, -665, -1230, -663, -1232, -663, -1237, -660, + -1234, -653 + ], + [18.4, 4.6, -1413, -448, -1409, -441, -1403, -444, -1407, -451], + [18.4, 4.6, -1409, -441, -1413, -448, -1428, -439, -1424, -432], + [ + 18.4, 11, 525, -741, 515, -759, 508, -756, 513, -749, 521, -733, 527, -737 + ], + [18.4, 19.5, 771, 969, 790, 960, 786, 952, 764, 964, 768, 970], + [ + 18.4, 11.6, -617, 1396, -623, 1388, -624, 1384, -625, 1384, -628, 1380, + -627, 1379, -630, 1373, -636, 1376, -624, 1400 + ], + [18.4, 10.4, 1315, 728, 1309, 716, 1303, 719, 1310, 731], + [18.4, 14.9, -345, 1482, -330, 1474, -334, 1468, -361, 1482, -357, 1489], + [ + 18.4, 12.8, -322, -454, -331, -470, -338, -466, -326, -444, -321, -446, + -325, -453 + ], + [ + 18.4, 7.3, 334, -1075, 321, -1098, 314, -1095, 320, -1084, 323, -1086, + 324, -1084, 322, -1082, 327, -1071 + ], + [18.4, 13.7, -213, 439, -228, 411, -235, 415, -219, 444], + [18.4, 11.9, 1424, 17, 1367, 49, 1379, 70, 1436, 39], + [18.4, 12.8, -41, -336, -45, -343, -73, -328, -68, -321], + [18.4, 20.7, 578, 45, 569, 30, 564, 33, 574, 52, 577, 51, 575, 47], + [18.4, 10.1, -762, -1094, -771, -1109, -775, -1106, -767, -1091], + [18.4, 7.9, -671, 1283, -678, 1270, -685, 1274, -673, 1296, -666, 1292], + [18.4, 7, -1291, -894, -1300, -910, -1307, -906, -1298, -890], + [18.4, 9.4, -721, 82, -732, 62, -739, 66, -728, 85], + [18.4, 11, 308, -798, 334, -812, 330, -819, 301, -803, 305, -796], + [18.4, 12.8, -819, 643, -803, 634, -806, 628, -828, 640, -825, 646], + [18.4, 16.2, 662, -45, 650, -67, 646, -65, 658, -42], + [ + 18.4, 7, -1294, -882, -1296, -888, -1303, -894, -1301, -895, -1307, -907, + -1314, -903, -1304, -889, -1303, -884, -1300, -879 + ], + [ + 18.4, 8.8, -1092, -1096, -1102, -1113, -1106, -1110, -1096, -1091, -1091, + -1094 + ], + [18.4, 6.4, 395, -1071, 383, -1092, 376, -1089, 389, -1066], + [18.4, 21.3, 561, 54, 553, 39, 547, 42, 555, 58], + [ + 18.4, 11.9, -501, 1513, -512, 1495, -513, 1495, -515, 1491, -520, 1493, + -518, 1498, -519, 1499, -508, 1517 + ], + [18.4, 18, 440, 1044, 427, 1021, 421, 1024, 434, 1048], + [18.4, 10.1, -758, -1096, -766, -1111, -771, -1109, -762, -1094], + [ + 18.4, 7, -1300, -879, -1309, -891, -1308, -891, -1314, -903, -1321, -899, + -1313, -888, -1312, -889, -1307, -875 + ], + [18.4, 11, -520, -599, -535, -625, -541, -622, -527, -596], + [18.4, 3.7, -1529, 302, -1538, 286, -1572, 305, -1561, 324, -1527, 306], + [ + 18.4, 7.9, -937, -527, -946, -540, -951, -550, -958, -546, -951, -537, + -952, -537, -945, -523 + ], + [ + 18.4, 11.6, -593, 1330, -594, 1328, -598, 1330, -600, 1329, -601, 1327, + -596, 1325, -600, 1317, -614, 1324, -609, 1332, -604, 1329, -602, 1336, + -600, 1335, -599, 1337, -605, 1340, -601, 1348, -587, 1341, -591, 1333, + -597, 1336, -598, 1334 + ], + [18.4, 3, -1478, 2, -1482, -4, -1496, 3, -1492, 10], + [18.4, 9.4, -92, -1253, -101, -1270, -108, -1266, -98, -1250], + [ + 18.4, 12.8, -799, 666, -810, 673, -807, 679, -788, 669, -794, 658, -798, + 661, -796, 665 + ], + [18.4, 13.4, -170, -268, -179, -284, -185, -280, -172, -257, -166, -261], + [ + 18.4, 12.2, -460, 1490, -468, 1476, -469, 1477, -474, 1467, -479, 1470, + -473, 1479, -475, 1480, -467, 1494 + ], + [18.5, 4.6, -1279, -249, -1293, -272, -1299, -269, -1286, -245], + [18.5, 20.1, 104, 355, 89, 329, 84, 331, 84, 333, 98, 358], + [18.5, 12.8, -221, -407, -224, -414, -227, -413, -252, -399, -251, -391], + [18.5, 11.9, 181, -278, 169, -300, 163, -296, 177, -271, 183, -275], + [18.5, 20.1, 119, 397, 106, 374, 96, 380, 104, 395, 106, 394, 110, 402], + [ + 18.5, 9.1, -910, -350, -921, -368, -920, -368, -923, -374, -929, -370, + -923, -361, -921, -355, -919, -353, -919, -351, -917, -346 + ], + [18.5, 11.6, -480, -999, -484, -1006, -510, -991, -506, -984], + [ + 18.5, 6.7, -1148, -542, -1147, -543, -1149, -548, -1169, -537, -1166, -532 + ], + [18.5, 6.7, -1152, -553, -1156, -560, -1175, -549, -1172, -542], + [18.5, 14, -325, -317, -337, -339, -343, -335, -331, -313, -324, -316], + [18.5, 12.2, -457, -191, -470, -214, -476, -211, -463, -188], + [ + 18.5, 12.2, -627, 1425, -614, 1448, -608, 1446, -607, 1445, -622, 1419, + -628, 1423 + ], + [18.5, 19.5, 579, 1, 572, -13, 570, -12, 566, -19, 562, -17, 574, 4], + [ + 18.5, 9.4, -945, -1073, -959, -1099, -966, -1095, -956, -1077, -954, + -1076, -955, -1075, -952, -1069 + ], + [ + 18.5, 5.5, -1388, -712, -1386, -707, -1379, -711, -1389, -726, -1394, + -739, -1400, -736, -1392, -722 + ], + [18.5, 7.3, -961, -428, -972, -448, -985, -441, -972, -419, -959, -426], + [18.5, 3.4, -1464, 3, -1461, 1, -1465, -5, -1492, 10, -1489, 16], + [18.5, 12.5, -976, 812, -984, 797, -991, 801, -983, 815], + [ + 18.5, 14.3, -386, 1532, -372, 1524, -376, 1517, -390, 1525, -389, 1526, + -393, 1528, -391, 1532, -387, 1530 + ], + [18.5, 2.4, -1525, -160, -1533, -174, -1542, -170, -1534, -156], + [ + 18.5, 9.8, 448, -532, 443, -541, 438, -538, 451, -515, 454, -516, 451, + -520, 453, -521, 447, -532 + ], + [18.5, 12.2, -372, -416, -385, -440, -391, -437, -377, -412, -371, -415], + [ + 18.5, 8.2, -1096, -1047, -1108, -1068, -1114, -1065, -1102, -1042, -1095, + -1045 + ], + [ + 18.5, 13.4, -181, -193, -152, -144, -106, -168, -118, -189, -129, -183, + -145, -213 + ], + [18.5, 4.9, 477, -1332, 487, -1314, 493, -1318, 483, -1335], + [ + 18.5, 6.4, -1267, -725, -1264, -726, -1265, -728, -1259, -731, -1258, + -729, -1251, -734, -1258, -747, -1266, -743, -1265, -742, -1271, -738, + -1272, -740, -1279, -736, -1272, -722 + ], + [ + 18.5, 5.5, 267, -1474, 273, -1477, 271, -1479, 266, -1476, 264, -1480, + 250, -1472, 253, -1466 + ], + [ + 18.5, 10.4, -844, -297, -854, -312, -860, -325, -866, -321, -857, -306, + -851, -293 + ], + [ + 18.5, 10.4, -604, -545, -587, -554, -605, -587, -639, -568, -610, -516, + -594, -524, -605, -544 + ], + [ + 18.5, 10.4, 268, -695, 273, -697, 272, -699, 280, -702, 277, -707, 270, + -702, 269, -704, 253, -695, 256, -689 + ], + [18.5, 12.2, -365, -422, -378, -444, -385, -440, -372, -416, -365, -420], + [18.5, 9.8, -512, 1312, -495, 1302, -498, 1296, -525, 1310, -522, 1317], + [ + 18.5, 7.9, -787, 1381, -782, 1377, -781, 1379, -776, 1374, -775, 1375, + -770, 1372, -777, 1359, -789, 1365, -788, 1367, -791, 1369, -793, 1368, + -801, 1372, -793, 1386 + ], + [ + 18.5, 12.2, -480, 1501, -487, 1489, -489, 1491, -490, 1489, -488, 1488, + -490, 1483, -492, 1484, -494, 1481, -492, 1480, -495, 1475, -501, 1479, + -498, 1484, -496, 1483, -495, 1486, -497, 1487, -487, 1505 + ], + [ + 18.5, 11.3, 518, -692, 512, -700, 511, -704, 509, -703, 507, -708, 508, + -708, 505, -715, 499, -711, 506, -701, 504, -700, 508, -695, 508, -693, + 511, -687 + ], + [ + 18.5, 4.6, -1525, -426, -1507, -436, -1506, -434, -1493, -441, -1500, + -454, -1513, -447, -1512, -445, -1530, -435, -1531, -437, -1543, -430, + -1536, -417, -1523, -424 + ], + [18.5, 23.2, 450, 161, 437, 136, 432, 139, 446, 163], + [18.5, 6.7, -1145, -537, -1148, -542, -1166, -532, -1163, -527], + [18.5, 13.1, -241, 367, -248, 353, -254, 357, -247, 370], + [ + 18.5, 4.3, -1484, -413, -1479, -405, -1475, -404, -1470, -407, -1475, + -414, -1476, -413, -1482, -424, -1487, -421, -1484, -416, -1483, -417, + -1481, -414 + ], + [18.5, 11.6, -589, -809, -601, -830, -608, -827, -596, -805], + [18.5, 8.8, -858, 156, -868, 139, -874, 143, -864, 160], + [ + 18.6, 10.1, 466, -931, 459, -943, 458, -942, 453, -955, 446, -951, 449, + -945, 453, -942, 459, -927 + ], + [18.6, 7.3, 547, -368, 539, -381, 532, -377, 547, -351, 554, -355], + [18.6, 12.2, -452, 291, -459, 278, -469, 283, -461, 296], + [18.6, 7, -1033, -610, -1040, -623, -1047, -620, -1039, -605, -1032, -609], + [18.6, 16.2, 245, 1065, 231, 1039, 222, 1044, 237, 1070], + [ + 18.6, 13.1, -362, -1055, -364, -1064, -387, -1052, -388, -1054, -389, + -1053, -395, -1064, -402, -1060, -391, -1039 + ], + [ + 18.6, 9.8, 336, -949, 332, -956, 330, -955, 330, -956, 331, -957, 328, + -962, 327, -961, 326, -963, 327, -964, 323, -971, 317, -967, 321, -960, + 322, -961, 323, -959, 322, -958, 324, -954, 326, -954, 327, -953, 325, + -952, 329, -945 + ], + [ + 18.6, 4.3, -1390, -392, -1377, -400, -1378, -404, -1381, -408, -1404, + -396, -1399, -387 + ], + [18.6, 8.2, -855, -422, -866, -442, -876, -436, -865, -416], + [ + 18.6, 10.1, 459, -927, 455, -934, 454, -933, 451, -938, 446, -951, 439, + -947, 452, -923 + ], + [18.6, 24.1, 329, 183, 350, 171, 345, 162, 321, 175, 325, 183], + [18.6, 17.4, 685, 177, 671, 153, 666, 155, 680, 180], + [ + 18.6, 15.5, -292, 1527, -295, 1522, -296, 1523, -297, 1521, -296, 1520, + -300, 1513, -307, 1516, -296, 1536, -290, 1533 + ], + [18.6, 14.6, 26, 1176, 24, 1169, 0, 1182, 4, 1188], + [18.6, 19.5, 534, -80, 541, -68, 546, -70, 536, -88, 531, -86], + [18.6, 12.5, -261, -902, -275, -928, -282, -924, -268, -897, -261, -901], + [ + 18.6, 10.4, -498, 1421, -509, 1402, -511, 1403, -512, 1401, -515, 1403, + -514, 1405, -516, 1406, -505, 1425 + ], + [ + 18.6, 10.1, 445, -918, 435, -932, 434, -937, 431, -943, 424, -938, 434, + -923, 433, -922, 437, -914 + ], + [18.6, 8.5, -847, -151, -846, -151, -860, -177, -867, -174, -852, -148], + [18.6, 20.4, 622, 115, 611, 96, 600, 102, 611, 122], + [18.6, 9.4, -688, 1417, -691, 1411, -708, 1420, -705, 1426], + [18.6, 11, 368, -830, 390, -843, 386, -849, 357, -833, 360, -826], + [18.6, 11.9, -384, -677, -397, -702, -404, -698, -390, -674], + [18.6, 18.6, 496, -85, 501, -77, 505, -80, 493, -106, 487, -103], + [18.6, 6.1, 232, -1263, 221, -1283, 211, -1277, 222, -1257], + [18.6, 10.1, 295, -574, 292, -578, 274, -568, 276, -564], + [ + 18.6, 9.8, 342, -952, 338, -959, 337, -958, 336, -960, 337, -961, 335, + -966, 333, -965, 332, -966, 334, -967, 330, -974, 323, -971, 327, -964, + 328, -964, 329, -963, 328, -962, 331, -957, 332, -958, 333, -956, 332, + -956, 336, -949 + ], + [18.6, 13.4, -177, -219, -190, -243, -197, -240, -184, -216], + [18.6, 21.3, 547, 400, 542, 403, 549, 416, 555, 413], + [18.6, 7.9, 1349, 640, 1361, 663, 1366, 660, 1353, 636, 1348, 639], + [18.6, 9.1, -735, -1174, -742, -1171, -733, -1155, -726, -1159], + [ + 18.6, 11.9, -178, -455, -182, -463, -215, -444, -206, -427, -197, -432, + -202, -442, -192, -447, -191, -445, -186, -447, -188, -450 + ], + [ + 18.7, 11.9, -426, 1130, -417, 1144, -414, 1148, -410, 1146, -411, 1141, + -419, 1126 + ], + [ + 18.7, 15.8, 215, 1296, 201, 1271, 192, 1278, 195, 1283, 191, 1285, 202, + 1305, 216, 1297 + ], + [18.7, 8.8, -924, 149, -934, 131, -940, 135, -930, 153], + [ + 18.7, 15.8, -289, 1486, -293, 1478, -294, 1479, -294, 1477, -302, 1464, + -307, 1467, -301, 1481, -299, 1480, -299, 1481, -300, 1482, -295, 1490 + ], + [18.7, 15.8, 667, -47, 653, -69, 650, -67, 662, -44], + [18.7, 12.8, -434, 1475, -447, 1453, -453, 1456, -441, 1480], + [ + 18.7, 5.8, -1207, -661, -1205, -662, -1207, -666, -1218, -660, -1220, + -661, -1227, -655, -1228, -656, -1234, -653, -1231, -648 + ], + [18.7, 9.4, 258, -736, 237, -724, 241, -718, 265, -731, 261, -737], + [ + 18.7, 15.8, -282, 1483, -286, 1474, -287, 1475, -287, 1473, -290, 1468, + -292, 1467, -295, 1460, -301, 1463, -294, 1477, -293, 1476, -292, 1478, + -293, 1478, -289, 1486 + ], + [ + 18.7, 7, -1020, -617, -1027, -630, -1034, -627, -1026, -614, -1025, -615, + -1023, -609, -1017, -612, -1021, -617 + ], + [18.7, 11, 983, 226, 971, 206, 966, 209, 968, 212, 966, 213, 976, 230], + [18.7, 7.6, 715, -269, 722, -256, 728, -259, 719, -277, 712, -273], + [18.7, 8.5, -8, -1216, -20, -1238, -27, -1234, -15, -1213], + [ + 18.7, 11.6, 551, -710, 547, -717, 544, -715, 543, -716, 545, -717, 537, + -732, 527, -726, 535, -712, 536, -713, 537, -711, 534, -710, 538, -702 + ], + [ + 18.7, 7.6, -1172, -910, -1175, -916, -1177, -915, -1177, -919, -1179, + -923, -1181, -922, -1185, -933, -1191, -930, -1184, -920, -1186, -920, + -1183, -915, -1181, -915, -1181, -911, -1178, -907 + ], + [18.7, 6.1, 222, -1257, 211, -1277, 204, -1273, 215, -1253], + [18.7, 23.2, 496, 226, 482, 201, 479, 203, 483, 210, 481, 212, 490, 229], + [18.7, 11, -486, 1414, -495, 1397, -501, 1400, -491, 1417], + [18.7, 7.6, 119, -1305, 116, -1310, 98, -1300, 101, -1295], + [ + 18.7, 4.6, -1239, -272, -1245, -283, -1246, -282, -1252, -294, -1258, + -291, -1245, -267, -1238, -271 + ], + [ + 18.7, 9.4, 206, -813, 205, -815, 215, -820, 212, -826, 201, -820, 202, + -818, 199, -816, 198, -818, 188, -812, 192, -806 + ], + [ + 18.7, 12.2, -326, -1431, -296, -1447, -289, -1435, -282, -1438, -297, + -1466, -337, -1443, -330, -1429 + ], + [18.7, 12.2, -538, -1016, -500, -1037, -504, -1044, -543, -1023], + [18.7, 17.7, 1235, 364, 1231, 357, 1212, 368, 1215, 374], + [18.7, 7.6, 109, -1451, 101, -1465, 95, -1461, 103, -1447], + [ + 18.7, 12.2, 476, -758, 472, -766, 468, -764, 464, -771, 468, -773, 464, + -781, 451, -773, 456, -765, 454, -764, 453, -765, 450, -764, 446, -771, + 434, -764, 438, -756, 442, -759, 446, -751, 442, -749, 446, -742, 458, + -749, 455, -757, 458, -759, 464, -752 + ], + [ + 18.7, 8.2, -1186, -1033, -1185, -1034, -1198, -1059, -1204, -1056, -1191, + -1031 + ], + [ + 18.7, 9.1, -4, -1257, -14, -1276, -20, -1272, -16, -1264, -14, -1265, -10, + -1258, -12, -1257, -10, -1254 + ], + [18.7, 6.1, -1071, -584, -1080, -601, -1087, -598, -1076, -581], + [18.7, 4.3, 504, -1366, 527, -1379, 524, -1386, 497, -1371, 501, -1364], + [18.7, 11.3, -424, 1259, -411, 1282, -404, 1278, -419, 1252, -426, 1255], + [ + 18.7, 13.4, -402, 1548, -410, 1538, -415, 1525, -422, 1528, -414, 1539, + -408, 1552 + ], + [18.7, 2.4, -1510, -121, -1518, -136, -1525, -133, -1516, -118], + [ + 18.7, 9.8, -883, -1086, -906, -1128, -946, -1106, -916, -1052, -876, -1074 + ], + [ + 18.7, 10.7, -687, 676, -678, 689, -676, 696, -669, 692, -676, 681, -681, + 670, -688, 674 + ], + [ + 18.7, 11, -479, 1410, -482, 1403, -484, 1404, -483, 1402, -486, 1397, + -488, 1398, -490, 1396, -487, 1395, -491, 1387, -498, 1391, -490, 1406, + -489, 1405, -488, 1406, -490, 1407, -486, 1414 + ], + [18.7, 19.2, 694, 908, 680, 883, 674, 887, 687, 912], + [ + 18.7, 9.8, 363, -964, 353, -977, 353, -981, 350, -987, 343, -983, 349, + -974, 351, -976, 350, -972, 356, -960 + ], + [18.7, 14.9, -219, 1407, -232, 1384, -239, 1388, -226, 1411], + [ + 18.7, 15.8, 92, 1004, 77, 977, 68, 982, 53, 956, 10, 980, 7, 993, 24, + 1038, 27, 1040 + ], + [ + 18.8, 7.3, -1276, -895, -1288, -917, -1300, -910, -1296, -902, -1295, + -903, -1293, -901, -1295, -900, -1291, -894, -1290, -895, -1288, -890, + -1282, -893, -1285, -898, -1283, -898, -1279, -893 + ], + [18.8, 18.9, 81, 457, 66, 430, 61, 432, 76, 459], + [18.8, 3.7, -1450, 38, -1455, 27, -1460, 30, -1455, 40], + [18.8, 13.4, -455, -1253, -417, -1274, -422, -1282, -460, -1261], + [ + 18.8, 9.8, 33, -831, 37, -823, 53, -832, 49, -839, 46, -838, 42, -842, 42, + -845, 45, -847, 41, -854, 25, -846, 29, -838, 33, -840, 35, -836, 36, -833 + ], + [18.8, 5.5, 520, -1140, 511, -1158, 485, -1144, 494, -1126], + [18.8, 11.6, 449, -832, 436, -856, 429, -852, 442, -828], + [18.8, 14, -114, 1299, -126, 1278, -153, 1293, -141, 1314], + [18.8, 13.1, 1157, 743, 1142, 716, 1129, 723, 1144, 750], + [ + 18.8, 6.7, -1178, -453, -1162, -462, -1166, -469, -1192, -455, -1188, -448 + ], + [ + 18.8, 12.8, -356, -482, -363, -495, -367, -492, -369, -496, -372, -495, + -361, -476, -354, -479 + ], + [ + 18.8, 10.1, -506, 1317, -491, 1309, -495, 1302, -512, 1312, -512, 1313, + -516, 1315, -513, 1320 + ], + [ + 18.8, 6.4, 563, -1031, 558, -1036, 560, -1037, 554, -1048, 541, -1041, + 549, -1031, 554, -1018, 567, -1025 + ], + [18.8, 9.4, 295, -574, 275, -563, 277, -558, 298, -570], + [ + 18.8, 4.9, -1272, -395, -1279, -407, -1286, -403, -1279, -390, -1278, + -391, -1275, -387, -1276, -386, -1273, -380, -1267, -384, -1274, -394 + ], + [ + 18.8, 6.4, -1198, -434, -1206, -447, -1213, -444, -1204, -428, -1203, + -428, -1200, -424, -1197, -427, -1199, -430, -1197, -431 + ], + [ + 18.8, 9.8, 356, -960, 346, -973, 346, -977, 343, -983, 336, -980, 342, + -971, 344, -972, 343, -968, 349, -956 + ], + [18.8, 10.1, -584, -939, -592, -955, -599, -952, -590, -936], + [ + 18.8, 7.3, -803, 1347, -788, 1338, -792, 1331, -812, 1342, -807, 1349, + -804, 1346 + ], + [18.8, 18, 33, 461, 30, 456, 14, 465, 17, 470], + [ + 18.8, 7.6, 1012, -150, 1008, -155, 987, -144, 992, -136, 1012, -147, 1011, + -150 + ], + [ + 18.8, 11.9, -456, 1435, -463, 1422, -483, 1433, -476, 1445, -465, 1439, + -463, 1439, -462, 1441, -460, 1440, -461, 1437 + ], + [18.8, 10.1, -739, -1106, -747, -1121, -754, -1118, -745, -1102], + [ + 18.8, 4.9, -1257, -313, -1263, -324, -1269, -321, -1260, -305, -1254, -308 + ], + [18.8, 10.1, 300, -439, 291, -455, 286, -452, 295, -436], + [ + 18.8, 6.7, -1183, -499, -1189, -496, -1187, -493, -1189, -492, -1190, + -493, -1194, -491, -1193, -489, -1195, -488, -1196, -490, -1205, -484, + -1199, -472, -1175, -485 + ], + [18.8, 13.1, -466, -336, -483, -327, -479, -320, -462, -329], + [ + 18.8, 8.8, -917, -346, -928, -364, -927, -364, -930, -370, -936, -366, + -930, -357, -929, -353, -927, -351, -923, -343 + ], + [18.8, 21.3, 229, 105, 215, 80, 209, 84, 223, 109], + [ + 18.8, 6.1, -1191, -646, -1200, -661, -1204, -658, -1199, -651, -1200, + -650, -1196, -643 + ], + [18.8, 4.3, 895, -454, 882, -477, 876, -474, 889, -451], + [ + 18.8, 18, 434, 1052, 435, 1050, 433, 1046, 429, 1048, 427, 1044, 431, + 1042, 421, 1024, 414, 1028, 429, 1054 + ], + [ + 18.8, 13.4, -152, -269, -164, -292, -172, -288, -164, -274, -161, -275, + -157, -266 + ], + [18.8, 23.5, 470, 274, 465, 265, 438, 280, 443, 289], + [ + 18.8, 7, -1011, -576, -1024, -601, -1029, -598, -1023, -588, -1021, -589, + -1016, -574 + ], + [ + 18.8, 10.7, -148, -1307, -155, -1321, -157, -1320, -159, -1324, -164, + -1321, -154, -1304 + ], + [ + 18.8, 9.8, 452, -923, 439, -947, 431, -943, 440, -932, 439, -931, 442, + -927, 441, -926, 445, -918 + ], + [ + 18.8, 7.9, -703, 1305, -712, 1289, -725, 1296, -715, 1313, -710, 1310, + -706, 1314, -700, 1311 + ], + [18.8, 21, 180, 443, 171, 428, 164, 431, 178, 457, 183, 454, 177, 444], + [18.8, 9.4, -598, -539, -583, -547, -587, -554, -604, -545, -600, -538], + [18.8, 9.8, 603, -565, 597, -576, 592, -573, 600, -560, 605, -563], + [ + 18.8, 9.1, -996, -1008, -1000, -1015, -1001, -1015, -1011, -1031, -1018, + -1027, -1006, -1002 + ], + [18.8, 5.8, -1222, -460, -1227, -470, -1234, -466, -1228, -456], + [18.8, 21.3, 223, 109, 209, 84, 202, 87, 216, 112], + [ + 18.8, 7.3, -1262, -900, -1268, -909, -1269, -908, -1271, -912, -1269, + -913, -1271, -916, -1275, -924, -1282, -921, -1275, -909, -1273, -910, + -1268, -897 + ], + [18.9, 13.4, -444, 1520, -451, 1506, -458, 1510, -450, 1524], + [18.9, 11.3, 461, -839, 448, -863, 442, -859, 455, -835], + [18.9, 13.4, -437, 1517, -445, 1502, -452, 1505, -442, 1522, -436, 1519], + [ + 18.9, 10.4, 365, -820, 381, -831, 393, -836, 390, -843, 381, -838, 382, + -836, 378, -834, 377, -835, 360, -826 + ], + [18.9, 11.9, -417, -725, -431, -750, -438, -746, -424, -721], + [18.9, 11, -635, -1159, -645, -1178, -654, -1173, -643, -1154], + [18.9, 21.3, 237, 101, 223, 76, 215, 80, 229, 105], + [18.9, 3, -1525, -380, -1539, -403, -1547, -399, -1534, -375], + [ + 18.9, 10.1, -65, -1044, -69, -1051, -71, -1050, -79, -1064, -83, -1061, + -86, -1066, -100, -1058, -97, -1053, -114, -1044, -105, -1027, -88, -1037, + -85, -1032 + ], + [18.9, 5.5, -1285, 942, -1260, 928, -1273, 904, -1299, 918], + [18.9, 11.6, -234, -960, -244, -978, -251, -975, -238, -952, -231, -956], + [ + 18.9, 12.2, -429, 1156, -437, 1142, -440, 1144, -442, 1142, -451, 1147, + -442, 1164 + ], + [ + 18.9, 9.8, 370, -968, 360, -981, 361, -981, 360, -985, 357, -991, 350, + -987, 356, -978, 358, -979, 357, -976, 363, -964 + ], + [18.9, 9.8, 382, -1015, 370, -1036, 360, -1030, 374, -1006, 384, -1011], + [18.9, 13.4, -240, 1062, -244, 1055, -275, 1072, -271, 1079], + [ + 18.9, 6.7, -1204, -496, -1204, -498, -1201, -500, -1200, -498, -1186, + -506, -1190, -513, -1204, -505, -1204, -502, -1206, -501, -1207, -502, + -1213, -499, -1209, -493 + ], + [ + 18.9, 8.8, 82, -897, 76, -907, 74, -906, 70, -914, 72, -915, 68, -922, 51, + -913, 53, -910, 48, -908, 60, -886 + ], + [ + 18.9, 13.7, -338, -309, -351, -332, -356, -329, -354, -325, -355, -324, + -345, -305 + ], + [18.9, 3, -1534, -375, -1548, -398, -1555, -394, -1543, -370], + [ + 18.9, 6.7, -1189, -496, -1183, -499, -1186, -506, -1200, -498, -1199, + -496, -1203, -495, -1204, -496, -1209, -493, -1206, -487, -1200, -490, + -1201, -492, -1199, -493, -1197, -492 + ], + [ + 18.9, 7, 128, -1498, 119, -1514, 105, -1507, 104, -1509, 98, -1505, 114, + -1479, 118, -1481, 113, -1490, 116, -1492, 121, -1483, 127, -1486, 123, + -1495 + ], + [ + 18.9, 6.1, -1214, 100, -1214, 99, -1207, 99, -1207, 84, -1184, 85, -1183, + 69, -1205, 69, -1205, 24, -1217, 22, -1217, 23, -1224, 23, -1224, 57, + -1268, 56, -1270, 67, -1268, 68, -1269, 74, -1247, 75, -1247, 84, -1225, + 84, -1225, 98 + ], + [18.9, 13.4, -112, -119, -123, -138, -130, -134, -119, -115], + [18.9, 13.7, -197, -331, -183, -305, -178, -308, -192, -333], + [ + 18.9, 7.9, -1073, -737, -1069, -730, -1064, -733, -1061, -727, -1066, + -724, -1062, -717, -1034, -732, -1038, -740, -1043, -737, -1046, -743, + -1041, -745, -1046, -753 + ], + [18.9, 15.5, 670, -49, 662, -64, 659, -63, 667, -47], + [18.9, 12.2, -403, -183, -416, -205, -421, -202, -409, -180], + [18.9, 23.2, 470, 196, 461, 180, 455, 183, 464, 199], + [18.9, 12.8, -95, -213, -108, -236, -114, -232, -102, -209], + [18.9, 13.7, -29, -78, -38, -94, -45, -91, -33, -70, -26, -73], + [18.9, 9.4, -22, -1209, -30, -1223, -38, -1219, -30, -1205], + [ + 18.9, 4, -1464, -291, -1469, -299, -1486, -289, -1481, -281, -1476, -284, + -1473, -279, -1478, -276, -1474, -268, -1457, -278, -1461, -285, -1466, + -283, -1469, -288 + ], + [ + 19, 8.8, -801, -573, -805, -580, -812, -576, -808, -568, -805, -570, -805, + -569, -807, -567, -805, -563, -803, -564, -804, -562, -798, -553, -793, + -556, -797, -566, -799, -566, -797, -567, -802, -572 + ], + [19, 8.8, -932, -358, -933, -361, -939, -357, -929, -339, -923, -343], + [ + 19, 10.4, 638, -648, 642, -641, 643, -641, 650, -626, 656, -630, 644, -651 + ], + [ + 19, 6.7, -1026, -614, -1034, -627, -1040, -623, -1030, -606, -1024, -609, + -1027, -613 + ], + [ + 19, 7.3, -1178, -907, -1181, -911, -1182, -911, -1185, -915, -1183, -915, + -1190, -928, -1191, -927, -1193, -930, -1198, -928, -1195, -922, -1193, + -923, -1190, -918, -1192, -917, -1188, -908, -1187, -909, -1185, -904, + -1183, -904 + ], + [19, 19.5, 620, -36, 646, -50, 638, -65, 612, -50, 617, -41, 616, -40], + [19, 18.3, 298, -66, 288, -84, 282, -80, 295, -57, 301, -60], + [ + 19, 7, -1255, -904, -1264, -915, -1262, -916, -1269, -928, -1275, -924, + -1271, -919, -1269, -913, -1267, -914, -1265, -911, -1266, -910, -1265, + -906, -1262, -900 + ], + [19, 4, -1384, 299, -1371, 291, -1374, 285, -1399, 299, -1396, 305], + [19, 4.3, -1422, 433, -1436, 408, -1442, 412, -1428, 437], + [19, 11.9, -384, 1356, -398, 1331, -403, 1333, -388, 1358], + [ + 19, 7.9, -902, -100, -905, -105, -903, -106, -900, -101, -893, -104, -903, + -122, -930, -107, -920, -90 + ], + [19, 11.6, 372, -744, 369, -750, 337, -733, 340, -726], + [ + 19, 11.3, 564, -718, 561, -724, 557, -723, 556, -724, 558, -725, 550, + -739, 540, -734, 548, -720, 550, -720, 551, -719, 547, -717, 551, -710 + ], + [ + 19, 10.4, -184, -945, -194, -963, -198, -961, -201, -966, -204, -964, + -191, -941 + ], + [19, 7.3, 1020, -151, 1011, -167, 1004, -164, 1013, -148], + [19, 8.8, -805, -580, -790, -557, -782, -561, -795, -585], + [ + 19, 12.5, -964, 787, -959, 795, -958, 799, -956, 798, -954, 802, -955, + 803, -952, 809, -949, 809, -946, 806, -952, 796, -951, 795, -955, 790, + -954, 789, -957, 783 + ], + [19, 22.9, 485, 232, 475, 215, 473, 216, 470, 212, 467, 213, 479, 235], + [19, 11.3, -216, -1353, -226, -1369, -232, -1366, -223, -1349], + [19, 10.4, 330, -819, 327, -825, 307, -814, 311, -808], + [19, 16.5, -61, 267, -71, 250, -76, 253, -66, 270], + [19, 7.3, 1027, -155, 1018, -171, 1011, -167, 1020, -151], + [ + 19, 23.8, 413, 140, 403, 123, 396, 126, 410, 152, 413, 150, 409, 144, 414, + 141 + ], + [19, 12.2, -184, -414, -162, -426, -165, -433, -191, -419, -187, -412], + [ + 19, 4.6, -1516, -476, -1503, -483, -1502, -481, -1490, -488, -1497, -501, + -1509, -494, -1508, -492, -1526, -482, -1527, -484, -1539, -477, -1532, + -464, -1520, -471, -1521, -473 + ], + [19, 10.7, 1310, 731, 1303, 718, 1298, 721, 1307, 737, 1312, 735], + [ + 19, 17.7, 78, 1426, 65, 1402, 41, 1415, 47, 1425, 44, 1427, 51, 1440, 56, + 1441, 70, 1434, 68, 1431 + ], + [ + 19, 6.1, 288, -1294, 285, -1299, 283, -1297, 274, -1313, 267, -1309, 276, + -1294, 274, -1292, 276, -1287 + ], + [ + 19, 4.6, -919, 1277, -932, 1254, -932, 1256, -947, 1264, -941, 1274, -940, + 1273, -938, 1276, -940, 1277, -935, 1286 + ], + [ + 19, 9.8, 349, -956, 342, -967, 341, -967, 336, -980, 329, -976, 337, -965, + 342, -952 + ], + [19, 4.6, 472, -1340, 484, -1346, 469, -1373, 450, -1362, 465, -1336], + [ + 19, 6.1, -1207, -418, -1211, -425, -1216, -423, -1219, -429, -1215, -432, + -1219, -440, -1233, -432, -1229, -425, -1226, -427, -1224, -426, -1221, + -420, -1224, -418, -1220, -411 + ], + [19, 15.5, 673, -52, 666, -66, 663, -65, 662, -64, 670, -49, 674, -51], + [19, 9.8, -740, -1066, -749, -1083, -754, -1081, -744, -1063], + [ + 19, 11.9, -397, 1153, -392, 1161, -389, 1158, -384, 1167, -388, 1169, + -383, 1177, -372, 1170, -376, 1162, -379, 1164, -380, 1162, -379, 1162, + -387, 1147 + ], + [19, 11.9, -221, -1293, -225, -1300, -249, -1287, -245, -1280], + [19, 11, 22, -734, 14, -750, -6, -739, -2, -731, 2, -734, 6, -725], + [19, 8.2, 932, -130, 938, -120, 942, -123, 948, -112, 965, -121, 954, -142], + [19, 6.1, -1149, -548, -1152, -553, -1172, -542, -1169, -537], + [19, 11.6, -902, 222, -909, 209, -933, 222, -924, 239, -900, 226], + [19, 2.7, -1500, -178, -1506, -189, -1515, -184, -1507, -170, -1498, -174], + [ + 19.1, 10.7, 543, -795, 539, -803, 535, -801, 531, -808, 535, -809, 530, + -818, 522, -813, 532, -798, 529, -796, 533, -789 + ], + [ + 19.1, 12.2, -804, 669, -804, 668, -803, 667, -802, 668, -799, 666, -802, + 660, -807, 664, -808, 663, -814, 666, -810, 673 + ], + [ + 19.1, 8.8, -838, -583, -842, -590, -844, -589, -850, -599, -862, -593, + -861, -590, -864, -588, -859, -581, -862, -579, -858, -571 + ], + [ + 19.1, 6.7, -1077, -450, -1081, -457, -1083, -455, -1084, -457, -1082, + -458, -1084, -463, -1086, -462, -1085, -463, -1091, -472, -1095, -469, + -1091, -460, -1089, -459, -1091, -459, -1088, -454, -1086, -456, -1085, + -454, -1088, -453, -1084, -446 + ], + [19.1, 8.8, -1006, -1002, -1020, -1026, -1028, -1022, -1016, -997], + [19.1, 12.2, -249, -585, -253, -593, -278, -579, -277, -570], + [19.1, 8.8, -930, 153, -940, 135, -945, 137, -935, 156], + [ + 19.1, 4.3, 501, -1425, 496, -1423, 497, -1420, 476, -1409, 481, -1400, + 507, -1415 + ], + [ + 19.1, 10.1, -851, -293, -859, -305, -866, -321, -870, -319, -869, -317, + -872, -315, -865, -306, -858, -289 + ], + [19.1, 13.4, -285, -466, -286, -472, -309, -469, -305, -463], + [ + 19.1, 14.6, 758, 113, 754, 106, 738, 115, 743, 123, 745, 122, 754, 137, + 758, 135, 757, 133, 764, 129, 757, 116, 759, 115 + ], + [ + 19.1, 11.6, -508, -1051, -511, -1058, -534, -1045, -535, -1048, -544, + -1043, -541, -1037, -548, -1033, -545, -1028, -536, -1033, -537, -1035 + ], + [ + 19.1, 11.9, 993, 372, 985, 359, 978, 363, 980, 366, 971, 371, 969, 368, + 962, 372, 970, 385 + ], + [ + 19.1, 6.7, 192, -1240, 180, -1261, 170, -1255, 174, -1248, 177, -1249, + 181, -1243, 178, -1241, 182, -1234 + ], + [19.1, 11.6, -527, -962, -539, -985, -546, -981, -533, -959], + [19.1, 10.1, -105, -1246, -115, -1263, -121, -1259, -112, -1242], + [19.1, 9.1, 646, -545, 639, -558, 633, -556, 644, -536, 650, -538], + [ + 19.1, 10.7, 553, -800, 540, -823, 530, -818, 535, -809, 539, -811, 542, + -805, 539, -803, 543, -795 + ], + [ + 19.1, 7, -1030, -476, -1034, -482, -1035, -481, -1036, -483, -1035, -484, + -1044, -498, -1049, -496, -1043, -485, -1045, -484, -1050, -494, -1055, + -492, -1048, -477, -1047, -477, -1046, -476, -1048, -475, -1044, -468 + ], + [ + 19.1, 11.9, -1022, -1086, -1033, -1107, -1036, -1106, -1034, -1100, -1037, + -1105, -1040, -1103, -1028, -1082 + ], + [ + 19.1, 10.4, -491, 1417, -495, 1410, -497, 1411, -497, 1410, -496, 1409, + -505, 1394, -511, 1398, -507, 1405, -505, 1404, -504, 1406, -506, 1408, + -503, 1413, -501, 1412, -500, 1413, -502, 1414, -498, 1421 + ], + [ + 19.1, 7.3, -1019, -540, -1023, -549, -1031, -545, -1024, -533, -1026, + -532, -1033, -544, -1040, -540, -1035, -531, -1034, -532, -1026, -516, + -1020, -520, -1023, -525, -1021, -527, -1018, -521, -1011, -525, -1020, + -540 + ], + [ + 19.1, 6.7, -1016, -574, -1023, -584, -1024, -584, -1025, -586, -1024, + -587, -1029, -598, -1037, -594, -1030, -584, -1028, -584, -1027, -582, + -1028, -581, -1023, -570 + ], + [19.2, 13.4, -184, -307, -197, -331, -203, -327, -190, -304], + [19.2, 7.6, -1171, -790, -1177, -802, -1184, -798, -1177, -787], + [ + 19.2, 9.4, -838, -1112, -850, -1134, -837, -1141, -846, -1157, -875, + -1141, -854, -1104 + ], + [19.2, 5.2, 801, -254, 790, -272, 785, -269, 796, -251], + [19.2, 16.8, 28, 1366, 13, 1340, -8, 1352, 6, 1378], + [19.2, 18.3, 164, 929, 184, 918, 169, 892, 139, 909, 153, 935], + [ + 19.2, 7.9, 685, -485, 681, -493, 661, -482, 665, -474, 668, -476, 672, + -469, 669, -467, 672, -460, 693, -471, 689, -478, 685, -476, 681, -483 + ], + [ + 19.2, 10.4, -676, -479, -691, -505, -697, -502, -693, -495, -707, -487, + -696, -468 + ], + [ + 19.2, 6.7, 727, -410, 719, -425, 714, -422, 725, -404, 728, -405, 726, + -410 + ], + [ + 19.2, 4.3, -1349, -79, -1352, -84, -1366, -77, -1363, -71, -1361, -72, + -1351, -55, -1342, -61, -1351, -78 + ], + [ + 19.2, 7.9, 666, -455, 661, -464, 660, -463, 654, -478, 647, -475, 660, + -451 + ], + [ + 19.2, 4, -1359, -52, -1363, -60, -1366, -58, -1367, -60, -1365, -61, + -1367, -65, -1368, -64, -1373, -73, -1379, -70, -1372, -57, -1371, -58, + -1366, -48 + ], + [19.2, 2.7, -1543, -370, -1557, -393, -1564, -389, -1552, -365], + [ + 19.2, 7, -781, 1352, -784, 1345, -800, 1354, -799, 1355, -800, 1356, -797, + 1361 + ], + [19.2, 15.5, 738, 150, 746, 145, 744, 141, 724, 151, 727, 156], + [19.2, 11.9, -402, -734, -416, -759, -423, -755, -409, -729], + [19.2, 11.3, -118, -490, -122, -497, -129, -493, -115, -469, -109, -473], + [ + 19.2, 19.5, 708, 933, 703, 926, 698, 929, 695, 923, 700, 920, 694, 908, + 674, 919, 680, 931, 686, 928, 689, 933, 683, 937, 688, 944 + ], + [19.2, 10.7, -657, -896, -667, -914, -672, -911, -662, -893], + [ + 19.2, 7.9, 672, -460, 670, -464, 666, -466, 661, -482, 654, -478, 657, + -473, 661, -467, 662, -468, 663, -460, 666, -455, 673, -459 + ], + [19.2, 10.7, -624, -743, -631, -756, -657, -742, -649, -729], + [19.2, 7.9, 660, -451, 647, -475, 640, -471, 653, -448], + [19.2, 12.2, -271, -1074, -282, -1095, -295, -1087, -284, -1067], + [ + 19.3, 7, -1188, -908, -1193, -916, -1196, -915, -1198, -920, -1196, -921, + -1199, -927, -1204, -924, -1203, -921, -1204, -920, -1198, -909, -1196, + -909, -1192, -899, -1187, -902, -1189, -908 + ], + [19.3, 7.3, -988, -500, -997, -517, -1002, -514, -993, -497], + [ + 19.3, 4.3, -1313, -76, -1318, -85, -1328, -79, -1332, -85, -1322, -92, + -1326, -99, -1352, -84, -1348, -77, -1339, -81, -1336, -76, -1345, -70, + -1340, -62 + ], + [19.3, 3, -1523, -203, -1531, -219, -1537, -215, -1529, -200], + [ + 19.3, 11, 476, -892, 467, -909, 433, -891, 443, -874, 458, -882, 461, + -876, 469, -881, 466, -886 + ], + [19.3, 12.8, 1347, 440, 1339, 426, 1332, 430, 1340, 444], + [ + 19.3, 11, -484, 1373, -488, 1366, -491, 1368, -496, 1360, -492, 1358, + -496, 1351, -509, 1358, -504, 1365, -501, 1363, -497, 1371, -500, 1373, + -496, 1380 + ], + [19.3, 9.8, -657, -534, -667, -553, -683, -544, -663, -507, -646, -516], + [ + 19.3, 9.4, 301, -955, 300, -957, 314, -964, 310, -971, 286, -960, 292, + -950 + ], + [19.3, 8.2, -1096, -1091, -1106, -1110, -1112, -1107, -1101, -1088], + [ + 19.3, 9.8, -108, -1161, -119, -1181, -123, -1179, -125, -1182, -128, + -1180, -115, -1157 + ], + [19.3, 13.4, -286, -472, -287, -479, -310, -474, -309, -469], + [ + 19.3, 15.8, 1189, 110, 1176, 86, 1156, 96, 1168, 117, 1177, 112, 1180, 116 + ], + [19.3, 6.4, -1310, -880, -1321, -899, -1334, -892, -1323, -873], + [ + 19.3, 3.4, -1379, -36, -1384, -46, -1385, -46, -1387, -49, -1385, -49, + -1393, -63, -1406, -56, -1398, -42, -1397, -43, -1396, -40, -1397, -39, + -1391, -29 + ], + [19.3, 5.5, -1348, -559, -1357, -576, -1363, -572, -1354, -556], + [19.3, 5.5, -1354, -556, -1363, -572, -1369, -569, -1360, -552], + [ + 19.3, 7.9, -697, 1014, -692, 1011, -691, 1013, -682, 1008, -680, 1013, + -661, 1003, -672, 983, -712, 1005, -705, 1018 + ], + [19.3, 2.4, -1507, -170, -1515, -184, -1524, -179, -1516, -165], + [19.3, 19.2, 646, 199, 633, 175, 626, 178, 640, 203], + [19.3, 4.6, -1297, -47, -1307, -65, -1314, -62, -1304, -43], + [ + 19.3, 13.1, -998, 836, -1011, 813, -1018, 817, -1015, 823, -1011, 821, + -1005, 831, -1009, 833, -1006, 840 + ], + [19.3, 11.6, -124, -485, -129, -493, -155, -478, -151, -470], + [ + 19.3, 8.5, 844, -785, 855, -789, 826, -841, 791, -822, 809, -798, 808, + -797, 811, -791, 824, -799, 827, -794, 820, -790, 823, -785, 822, -784, + 827, -774, 844, -784 + ], + [19.3, 5.2, -1452, -671, -1465, -695, -1473, -691, -1459, -667], + [ + 19.3, 6.1, 291, -1244, 287, -1251, 283, -1249, 278, -1259, 282, -1261, + 278, -1267, 266, -1260, 269, -1254, 272, -1256, 273, -1254, 272, -1253, + 280, -1239 + ], + [19.3, 11.9, -409, -729, -423, -755, -431, -750, -417, -725], + [19.3, 23.2, 267, 141, 282, 167, 295, 159, 281, 133], + [ + 19.3, 12.5, -357, -896, -351, -899, -334, -901, -335, -908, -345, -907, + -361, -899, -359, -895 + ], + [ + 19.4, 4, 1039, -456, 1020, -446, 1017, -451, 1008, -446, 1007, -447, 983, + -433, 998, -407, 1051, -437 + ], + [19.4, 12.5, -286, -948, -289, -954, -314, -940, -313, -933], + [ + 19.4, 8.8, -702, 1382, -705, 1375, -720, 1383, -716, 1389, -715, 1388, + -709, 1398, -699, 1392, -704, 1382 + ], + [19.4, 4.3, -1311, -88, -1319, -103, -1326, -99, -1316, -81, -1309, -84], + [ + 19.4, 7, -794, 1350, -784, 1345, -788, 1338, -803, 1347, -802, 1349, -804, + 1350, -802, 1353, -800, 1352, -800, 1354 + ], + [ + 19.4, 10.4, -160, -1163, -176, -1154, -162, -1130, -149, -1137, -154, + -1146, -149, -1149, -144, -1140, -132, -1148, -144, -1166, -157, -1159 + ], + [ + 19.4, 6.7, -1268, -897, -1274, -906, -1275, -905, -1277, -908, -1275, + -909, -1278, -912, -1282, -921, -1288, -917, -1282, -909, -1282, -906, + -1280, -907, -1278, -903, -1279, -903, -1278, -899, -1275, -893 + ], + [ + 19.4, 11.6, 529, -703, 519, -720, 511, -716, 508, -721, 503, -718, 518, + -692, 531, -699 + ], + [19.4, 7.3, 569, -389, 566, -395, 539, -381, 543, -374], + [ + 19.4, 6.7, 829, -226, 820, -238, 820, -242, 816, -248, 810, -244, 818, + -234, 823, -222 + ], + [19.4, 12.5, 62, -182, 58, -189, 17, -167, 22, -159], + [ + 19.4, 9.4, -854, -663, -858, -671, -864, -668, -867, -673, -861, -676, + -865, -683, -891, -668, -888, -662, -881, -665, -878, -660, -885, -656, + -880, -648 + ], + [19.4, 14.6, -110, 102, -124, 75, -131, 79, -116, 105], + [19.4, 6.7, -1080, -539, -1089, -554, -1095, -551, -1086, -536], + [19.4, 13.1, 1183, 467, 1193, 486, 1204, 480, 1193, 461], + [19.4, 23.8, 420, 136, 410, 119, 403, 123, 413, 140], + [ + 19.4, 9.4, -762, -1336, -782, -1371, -775, -1375, -784, -1392, -818, + -1373, -804, -1348, -790, -1356, -775, -1328 + ], + [ + 19.4, 13.1, -395, -1225, -397, -1231, -399, -1232, -427, -1217, -423, + -1210 + ], + [ + 19.4, 5.5, 400, -1310, 399, -1313, 395, -1311, 390, -1320, 393, -1322, + 389, -1330, 376, -1322, 380, -1315, 384, -1316, 389, -1308, 385, -1305, + 389, -1299, 402, -1306 + ], + [ + 19.4, 11, -966, 217, -975, 205, -980, 195, -987, 199, -983, 206, -981, + 205, -980, 207, -982, 208, -975, 222 + ], + [19.4, 10.7, 690, -711, 692, -713, 681, -733, 667, -726, 678, -705], + [ + 19.4, 11.9, -887, 723, -889, 719, -891, 718, -900, 700, -907, 704, -899, + 717, -895, 727 + ], + [ + 19.4, 6.7, 835, -230, 823, -252, 816, -248, 820, -242, 822, -240, 823, + -240, 825, -237, 824, -237, 829, -226, 836, -229 + ], + [19.4, 20.7, 161, 322, 148, 300, 141, 303, 154, 327], + [19.5, 8.8, -689, 1392, -700, 1372, -705, 1375, -694, 1395], + [ + 19.5, 21.9, 856, 1108, 858, 1112, 852, 1115, 858, 1124, 876, 1114, 868, + 1100, 855, 1107 + ], + [ + 19.5, 9.8, -97, -1212, -100, -1210, -96, -1201, -105, -1196, -110, -1205, + -113, -1203, -93, -1169, -78, -1178 + ], + [ + 19.5, 10.7, -637, 1407, -649, 1386, -653, 1388, -660, 1374, -658, 1373, + -668, 1355, -673, 1358, -655, 1390, -675, 1401, -664, 1422 + ], + [19.5, 13.1, -441, -291, -444, -297, -457, -289, -454, -284], + [ + 19.5, 7, -1258, -862, -1272, -886, -1276, -883, -1273, -878, -1268, -873, + -1269, -872, -1267, -866, -1263, -860 + ], + [19.5, 11.3, 552, -756, 543, -772, 516, -758, 525, -741], + [ + 19.5, 12.8, -231, 1272, -206, 1258, -217, 1239, -235, 1249, -229, 1258, + -232, 1260, -234, 1255, -243, 1260, -235, 1274 + ], + [19.5, 11.6, 91, -298, 88, -303, 63, -290, 66, -284], + [ + 19.5, 6.7, 1029, -157, 1026, -163, 1028, -164, 1024, -169, 1021, -168, + 1020, -171, 1018, -170, 1027, -155 + ], + [19.5, 8.8, -902, -805, -916, -832, -924, -828, -910, -801], + [19.5, 2.1, -1516, -118, -1525, -133, -1530, -130, -1522, -115], + [ + 19.5, 7.6, -953, -382, -958, -391, -974, -382, -974, -381, -983, -375, + -977, -363, -965, -370, -964, -368, -967, -367, -963, -360, -948, -368, + -953, -378, -955, -377, -957, -380 + ], + [ + 19.5, 10.1, -696, -468, -706, -485, -708, -486, -710, -485, -713, -489, + -722, -484, -709, -461 + ], + [ + 19.5, 10.1, -661, 1381, -665, 1373, -668, 1375, -673, 1366, -670, 1364, + -673, 1358, -687, 1365, -683, 1372, -679, 1370, -675, 1379, -675, 1380, + -678, 1381, -674, 1388 + ], + [19.5, 12.2, -372, -559, -387, -587, -394, -583, -379, -555], + [19.5, 13.1, -444, -297, -446, -302, -460, -294, -457, -289], + [ + 19.5, 6.7, 208, -1470, 214, -1474, 209, -1483, 185, -1470, 190, -1463, + 207, -1473 + ], + [19.5, 13.4, 20, 1155, -6, 1170, 0, 1182, 24, 1169], + [ + 19.5, 9.1, -596, 1246, -598, 1245, -600, 1247, -605, 1238, -601, 1236, + -606, 1229, -619, 1236, -615, 1243, -611, 1242, -606, 1251, -610, 1253, + -606, 1260, -592, 1252 + ], + [ + 19.5, 7, -1263, -860, -1273, -873, -1273, -878, -1276, -883, -1283, -880, + -1275, -868, -1276, -868, -1270, -856 + ], + [ + 19.5, 10.7, 1271, 624, 1266, 615, 1262, 616, 1259, 610, 1262, 608, 1258, + 601, 1250, 605, 1259, 622, 1257, 623, 1261, 629 + ], + [ + 19.5, 7, 139, -1072, 134, -1081, 129, -1078, 127, -1078, 126, -1079, 128, + -1080, 126, -1083, 131, -1086, 127, -1094, 107, -1083, 112, -1075, 117, + -1078, 120, -1073, 115, -1070, 119, -1061 + ], + [19.6, 11.9, -402, -860, -406, -867, -433, -853, -429, -845], + [ + 19.6, 9.8, 397, -982, 382, -1004, 381, -1005, 376, -1003, 377, -1001, 375, + -1000, 385, -984, 383, -982, 386, -977 + ], + [ + 19.6, 6.7, 779, -287, 775, -294, 769, -292, 765, -296, 772, -300, 767, + -309, 740, -294, 744, -287, 746, -288, 746, -286, 750, -288, 753, -285, + 753, -283, 748, -280, 752, -272 + ], + [ + 19.6, 11.3, -506, 1454, -510, 1448, -520, 1453, -516, 1460, -514, 1459, + -506, 1473, -507, 1474, -505, 1475, -499, 1472, -506, 1460, -504, 1459 + ], + [19.6, 8.8, 387, -564, 402, -538, 408, -541, 393, -568], + [ + 19.6, 3.7, -1404, 229, -1420, 239, -1421, 239, -1428, 242, -1424, 248, + -1401, 236 + ], + [ + 19.6, 9.8, 386, -977, 383, -982, 380, -981, 372, -998, 369, -999, 364, + -996, 374, -978, 372, -977, 375, -971 + ], + [19.6, 10.1, 42, -803, 45, -804, 37, -818, 17, -807, 25, -793], + [19.6, 11.3, 242, -453, 234, -467, 229, -464, 237, -450], + [ + 19.6, 4.9, 463, -1339, 459, -1346, 456, -1344, 450, -1353, 454, -1355, + 450, -1362, 436, -1355, 440, -1348, 444, -1350, 449, -1340, 445, -1338, + 449, -1331 + ], + [19.6, 23.5, 423, 112, 432, 128, 439, 124, 430, 108], + [ + 19.6, 13.1, -96, 1198, -111, 1172, -127, 1181, -142, 1154, -148, 1157, + -133, 1184, -141, 1188, -126, 1215 + ], + [ + 19.6, 9.1, 296, -965, 295, -967, 308, -974, 305, -981, 289, -971, 287, + -974, 281, -970, 286, -960 + ], + [ + 19.6, 5.2, -1305, -235, -1315, -253, -1321, -250, -1320, -248, -1323, + -246, -1313, -229, -1311, -229, -1304, -232 + ], + [ + 19.6, 8.5, -930, -341, -934, -348, -938, -346, -940, -349, -938, -350, + -943, -360, -958, -352, -955, -345, -952, -347, -951, -345, -963, -338, + -957, -327, -952, -329, -951, -327, -929, -339 + ], + [ + 19.6, 8.2, -888, -498, -883, -501, -883, -503, -874, -506, -878, -513, + -901, -501, -898, -495, -889, -500 + ], + [19.6, 11.3, 113, -672, 112, -673, 96, -664, 100, -658, 116, -667], + [ + 19.6, 11.9, -255, -936, -257, -940, -255, -941, -268, -964, -276, -960, + -271, -952, -269, -953, -258, -934 + ], + [ + 19.6, 3.7, -1374, -44, -1377, -50, -1379, -49, -1380, -52, -1379, -53, + -1386, -66, -1393, -62, -1389, -56, -1388, -56, -1385, -49, -1384, -50, + -1379, -40 + ], + [ + 19.6, 14.6, -288, 1395, -297, 1378, -298, 1379, -301, 1374, -306, 1377, + -295, 1399 + ], + [19.6, 17.7, 314, -133, 305, -149, 300, -146, 309, -130], + [ + 19.6, 10.4, -73, -1433, -81, -1444, -80, -1444, -84, -1454, -91, -1450, + -88, -1445, -85, -1442, -84, -1442, -80, -1429 + ], + [ + 19.7, 8.2, -916, -582, -924, -578, -923, -575, -937, -567, -934, -563, + -940, -560, -936, -553, -928, -558, -926, -554, -935, -548, -927, -533, + -898, -549 + ], + [19.7, 13.4, -172, -257, -185, -280, -192, -277, -179, -254], + [19.7, 17.4, 298, -125, 286, -147, 281, -145, 293, -123], + [ + 19.7, 8.5, 56, -1298, 62, -1301, 56, -1313, 43, -1306, 48, -1296, 53, + -1298, 52, -1300, 54, -1301 + ], + [19.7, 8.2, -832, 28, -825, 24, -828, 18, -853, 32, -850, 38], + [19.7, 23.5, 426, 132, 417, 115, 410, 119, 422, 140, 424, 139, 422, 135], + [ + 19.7, 10.4, -80, -1429, -85, -1438, -86, -1437, -91, -1450, -98, -1446, + -95, -1441, -92, -1438, -91, -1438, -86, -1426 + ], + [19.7, 6.1, -1191, -389, -1200, -404, -1206, -400, -1198, -385], + [ + 19.7, 6.4, -818, 1347, -810, 1362, -808, 1361, -808, 1363, -804, 1361, + -805, 1359, -803, 1358, -812, 1343 + ], + [ + 19.7, 4.9, 225, -1208, 217, -1219, 212, -1231, 205, -1227, 209, -1220, + 211, -1220, 218, -1204 + ], + [ + 19.7, 11, -358, 1282, -362, 1276, -374, 1282, -368, 1292, -372, 1294, + -378, 1284, -389, 1290, -385, 1297, -383, 1296, -374, 1313, -364, 1307, + -368, 1301, -364, 1298, -361, 1305, -351, 1300, -360, 1283 + ], + [ + 19.7, 9.8, 305, -940, 304, -944, 313, -949, 315, -946, 322, -950, 315, + -963, 308, -959, 310, -955, 303, -952, 301, -955, 292, -950, 299, -937 + ], + [ + 19.7, 5.5, 339, -1491, 336, -1497, 333, -1496, 333, -1497, 326, -1511, + 318, -1507, 326, -1493, 327, -1493, 325, -1491, 328, -1485 + ], + [19.7, 3.4, -1393, -232, -1401, -247, -1406, -245, -1398, -229], + [19.7, 17.4, 303, -128, 291, -150, 286, -147, 298, -125], + [19.7, 3.4, -1406, -223, -1416, -239, -1420, -237, -1411, -220], + [ + 19.7, 5.2, -1437, -596, -1448, -615, -1452, -613, -1445, -600, -1444, + -600, -1443, -599, -1446, -597, -1443, -592 + ], + [19.7, 2.4, -1516, -165, -1524, -179, -1533, -174, -1525, -160], + [ + 19.7, 6.7, 215, -1456, 222, -1460, 216, -1469, 211, -1466, 211, -1463, + 195, -1455, 198, -1449, 214, -1458 + ], + [ + 19.7, 9.1, -856, -699, -867, -719, -881, -711, -877, -704, -882, -701, + -886, -708, -899, -701, -896, -693, -898, -692, -895, -686, -892, -687, + -889, -681, -874, -689, -877, -694, -875, -695, -876, -697, -875, -698, + -874, -697, -873, -697, -870, -691 + ], + [ + 19.7, 9.1, 245, -729, 243, -734, 248, -736, 250, -736, 252, -732, 258, + -736, 251, -749, 241, -744, 240, -746, 242, -747, 240, -749, 249, -754, + 249, -755, 246, -762, 241, -759, 236, -767, 228, -763, 227, -764, 218, + -760, 225, -747, 231, -750, 233, -745, 228, -742, 237, -724 + ], + [ + 19.7, 11, -547, 1318, -551, 1311, -555, 1313, -560, 1304, -559, 1302, + -556, 1302, -560, 1295, -573, 1302, -569, 1309, -566, 1307, -561, 1316, + -562, 1318, -564, 1318, -561, 1325 + ], + [ + 19.7, 8.8, 434, -1003, 431, -1009, 428, -1008, 420, -1025, 412, -1021, + 422, -1005, 420, -1003, 423, -997 + ], + [19.7, 9.8, -47, -1404, -56, -1419, -72, -1410, -63, -1395], + [ + 19.7, 4.9, 450, -1468, 443, -1480, 439, -1477, 438, -1479, 442, -1482, + 438, -1489, 423, -1480, 426, -1474, 431, -1475, 434, -1469, 431, -1465, + 434, -1459 + ], + [19.7, 15.8, 1140, 300, 1125, 273, 1103, 285, 1117, 312], + [ + 19.7, 5.5, 350, -1497, 347, -1503, 344, -1502, 337, -1517, 329, -1513, + 338, -1499, 336, -1497, 339, -1491 + ], + [ + 19.7, 8.5, -1021, -852, -1023, -857, -1018, -860, -1016, -860, -1014, + -856, -1007, -860, -1012, -870, -1012, -872, -1021, -866, -1025, -869, + -1015, -875, -1020, -888, -1043, -875, -1028, -848 + ], + [19.8, 21.9, 258, 141, 246, 119, 237, 123, 250, 145], + [ + 19.8, 7, 89, -1160, 98, -1143, 100, -1145, 102, -1141, 105, -1143, 103, + -1146, 105, -1147, 95, -1166, 88, -1162 + ], + [ + 19.8, 9.4, -916, -1052, -920, -1060, -926, -1056, -930, -1063, -930, + -1065, -925, -1068, -929, -1075, -949, -1064, -945, -1057, -939, -1060, + -935, -1055, -934, -1052, -940, -1049, -936, -1041 + ], + [ + 19.8, 7.6, -1002, -550, -1007, -558, -1014, -554, -1008, -542, -1010, + -541, -1016, -553, -1023, -549, -1010, -526, -1003, -529, -1006, -535, + -1004, -536, -1001, -530, -994, -534, -1003, -549 + ], + [19.8, 16.5, -191, 785, -203, 763, -210, 766, -198, 789], + [19.8, 19.5, 575, -44, 567, -58, 562, -55, 570, -40, 576, -42], + [ + 19.8, 9.8, -93, -1169, -105, -1190, -110, -1187, -111, -1190, -114, -1189, + -101, -1165 + ], + [19.8, 11.3, -404, 1278, -391, 1271, -404, 1248, -417, 1255], + [ + 19.8, 10.4, -665, -501, -659, -489, -649, -494, -657, -509, -662, -506, + -661, -503 + ], + [ + 19.8, 11.6, -562, -1491, -547, -1499, -560, -1518, -589, -1503, -582, + -1489, -565, -1498 + ], + [19.8, 9.1, 27, -1490, 20, -1503, -7, -1490, 1, -1475], + [ + 19.8, 5.2, 360, -1505, 358, -1509, 354, -1508, 347, -1523, 340, -1519, + 349, -1506, 347, -1503, 350, -1497, 361, -1503 + ], + [19.8, 11, 885, 11, 872, -12, 868, -9, 881, 14], + [19.8, 15.2, -278, 1442, -292, 1417, -299, 1421, -284, 1447, -277, 1443], + [ + 19.8, 7.9, 932, -136, 935, -138, 936, -136, 952, -145, 939, -166, 940, + -167, 936, -173, 915, -162, 921, -150, 933, -157, 935, -154, 932, -152, + 934, -149, 927, -146 + ], + [19.8, 17.1, 15, 1408, 2, 1385, -24, 1399, -11, 1422], + [19.8, 12.2, 944, 408, 970, 394, 967, 388, 965, 390, 953, 368, 928, 382], + [19.8, 19.2, 314, -32, 302, -54, 299, -52, 299, -51, 297, -50, 309, -29], + [19.8, 0, -231, 1329, -222, 1324, -236, 1298, -246, 1304], + [ + 19.8, 9.8, -674, 1388, -678, 1380, -682, 1382, -686, 1374, -683, 1372, + -687, 1365, -700, 1372, -696, 1379, -693, 1377, -687, 1387, -691, 1389, + -687, 1395 + ], + [ + 19.8, 5.8, -1246, -559, -1239, -562, -1242, -566, -1232, -571, -1230, + -567, -1223, -571, -1238, -599, -1252, -591, -1248, -584, -1243, -587, + -1238, -578, -1251, -571, -1256, -580, -1252, -582, -1256, -589, -1271, + -581, -1267, -574, -1263, -576, -1259, -569, -1260, -567, -1273, -561, + -1277, -567, -1271, -571, -1275, -578, -1288, -571, -1275, -549, -1253, + -561, -1254, -562, -1249, -565 + ], + [ + 19.8, 6.4, -1200, -451, -1192, -437, -1189, -438, -1188, -435, -1189, + -434, -1186, -428, -1180, -431, -1193, -455 + ], + [ + 19.8, 8.8, 51, -1503, 48, -1507, 45, -1507, 38, -1521, 30, -1517, 38, + -1503, 37, -1500, 40, -1495, 51, -1501 + ], + [ + 19.8, 14.6, -295, 1399, -304, 1382, -305, 1383, -308, 1378, -313, 1381, + -302, 1403 + ], + [ + 19.8, 2.1, 1060, -1106, 1073, -1113, 1051, -1153, 1034, -1143, 1056, -1104 + ], + [19.8, 11, 872, -12, 885, 11, 889, 9, 877, -14], + [19.8, 12.2, -981, 757, -973, 771, -966, 768, -974, 753], + [19.8, 11, -557, -738, -570, -762, -577, -758, -563, -734], + [ + 19.8, 7.3, -977, -363, -983, -375, -994, -371, -1011, -362, -1006, -353, + -1002, -356, -1000, -352, -1002, -351, -997, -341, -981, -350, -985, -357, + -988, -355, -989, -357 + ], + [19.9, 18.6, 568, 651, 554, 627, 548, 630, 561, 654], + [ + 19.9, 11.3, 953, 17, 973, 53, 984, 47, 977, 34, 974, 35, 965, 20, 970, 17, + 966, 10 + ], + [ + 19.9, 6.4, 816, -218, 806, -232, 808, -233, 804, -240, 793, -234, 797, + -227, 799, -228, 801, -225, 800, -223, 806, -212 + ], + [19.9, 22.6, 479, 235, 467, 213, 461, 217, 473, 239], + [ + 19.9, 6.7, -1012, -488, -1023, -508, -1030, -505, -1025, -498, -1017, + -483, -1011, -487 + ], + [ + 19.9, 12.2, -525, -333, -538, -356, -550, -349, -546, -343, -539, -330, + -534, -333, -532, -330 + ], + [19.9, 8.5, -859, -950, -871, -971, -876, -968, -864, -947], + [ + 19.9, 5.8, -1307, -687, -1291, -695, -1297, -706, -1318, -694, -1315, + -689, -1312, -691, -1309, -686 + ], + [ + 19.9, 9.8, -882, -1022, -886, -1029, -890, -1028, -893, -1034, -890, + -1036, -894, -1043, -904, -1037, -899, -1028, -904, -1025, -909, -1034, + -920, -1028, -916, -1021, -912, -1023, -909, -1017, -912, -1014, -909, + -1008, -898, -1014, -899, -1017, -896, -1019, -893, -1016 + ], + [ + 19.9, 7.9, -878, -513, -881, -520, -894, -513, -893, -512, -904, -507, + -901, -501 + ], + [ + 19.9, 8.8, 60, -887, 55, -896, 52, -895, 47, -904, 25, -892, 31, -882, 28, + -880, 33, -872, 36, -874, 37, -873 + ], + [19.9, 11.6, -204, -844, -219, -871, -226, -867, -210, -840], + [ + 19.9, 9.4, 381, -587, 377, -594, 365, -587, 370, -579, 372, -580, 380, + -565, 388, -570, 379, -586 + ], + [ + 19.9, 4.6, -1470, -608, -1465, -613, -1476, -636, -1490, -629, -1480, + -610, -1478, -611, -1475, -607 + ], + [ + 19.9, 11.9, -396, 42, -389, 37, -402, 13, -404, 14, -402, 17, -414, 22, + -414, 24, -407, 35, -405, 34, -400, 44 + ], + [19.9, 8.8, 421, -551, 408, -573, 395, -566, 408, -542, 421, -549], + [ + 19.9, 11.6, 512, -661, 509, -667, 497, -660, 500, -654, 504, -655, 510, + -645, 506, -643, 510, -637, 520, -643, 510, -659 + ], + [ + 19.9, 10.1, 249, -782, 245, -789, 233, -782, 237, -776, 240, -777, 241, + -775, 239, -774, 244, -765, 249, -768, 252, -762, 256, -765, 248, -779, + 247, -779, 246, -781 + ], + [19.9, 11.3, -493, 820, -504, 801, -511, 804, -500, 824], + [19.9, 3, -1432, -165, -1440, -179, -1446, -176, -1438, -161], + [19.9, 20.4, 528, -13, 518, -31, 511, -27, 521, -9], + [19.9, 7.9, -1221, -1023, -1231, -1040, -1238, -1036, -1228, -1019], + [19.9, 13.1, -103, 1164, -116, 1140, -142, 1154, -129, 1178], + [19.9, 7.3, 155, -1476, 147, -1490, 141, -1487, 149, -1472], + [ + 19.9, 8.8, -1021, -964, -1023, -969, -1052, -953, -1048, -944, -1044, + -946, -1041, -941, -1034, -944, -1033, -943, -1021, -950, -1022, -951, + -1015, -955 + ], + [ + 19.9, 7.9, 573, -382, 563, -377, 565, -374, 560, -370, 558, -369, 556, + -373, 549, -369, 557, -356, 580, -369 + ], + [19.9, 11, -500, 1045, -529, 993, -554, 1007, -526, 1060], + [ + 19.9, 12.5, -343, 230, -372, 178, -405, 196, -390, 222, -377, 215, -363, + 241 + ], + [ + 19.9, 5.2, -1252, -781, -1255, -788, -1258, -786, -1259, -788, -1256, + -789, -1262, -798, -1269, -794, -1265, -784, -1262, -786, -1262, -784, + -1265, -783, -1261, -776 + ], + [19.9, 8.5, 95, -933, 92, -938, 79, -931, 82, -926], + [20, 9.8, -744, -1063, -754, -1081, -759, -1078, -749, -1061], + [ + 20, 11, -514, 1363, -516, 1361, -522, 1364, -509, 1387, -504, 1385, -512, + 1371, -510, 1370 + ], + [ + 20, 10.4, 269, -776, 267, -780, 264, -778, 259, -787, 262, -789, 258, + -796, 245, -789, 249, -782, 253, -784, 257, -775, 254, -773, 258, -766, + 271, -773 + ], + [20, 4.9, 427, -1325, 417, -1342, 390, -1327, 400, -1310], + [20, 14, -88, 1284, -103, 1257, -129, 1272, -114, 1299], + [20, 14.6, -226, 1411, -239, 1388, -246, 1392, -233, 1415], + [ + 20, 10.7, 292, -390, 282, -407, 279, -406, 276, -410, 273, -409, 286, -385 + ], + [ + 20, 11.6, 497, -642, 493, -649, 482, -642, 483, -641, 480, -639, 479, + -641, 468, -635, 472, -628 + ], + [ + 20, 10.1, -38, -1573, -23, -1581, -38, -1607, -47, -1601, -47, -1600, -64, + -1592, -55, -1578, -56, -1577, -51, -1569, -40, -1575 + ], + [ + 20, 4, 998, -407, 994, -414, 992, -413, 989, -417, 983, -428, 978, -425, + 986, -410, 984, -409, 988, -402 + ], + [ + 20, 10.1, 538, -559, 540, -560, 526, -586, 502, -573, 516, -549, 533, + -558, 534, -556 + ], + [20, 13.7, -1044, 721, -1052, 707, -1059, 711, -1051, 725], + [20, 12.8, -328, -527, -342, -552, -349, -548, -337, -525, -333, -524], + [20, 8.2, 1478, 441, 1451, 455, 1466, 481, 1492, 467], + [20, 9.8, 378, -943, 374, -950, 368, -946, 381, -922, 387, -926], + [20, 18.6, 27, 435, 20, 422, -3, 434, 4, 447], + [ + 20, 23.2, 437, 137, 423, 112, 417, 115, 426, 132, 430, 129, 430, 133, 433, + 139 + ], + [ + 20, 4, 988, -402, 984, -409, 981, -408, 973, -423, 968, -419, 976, -404, + 974, -403, 978, -396 + ], + [20, 10.1, -752, -1100, -761, -1115, -766, -1111, -758, -1096], + [20, 10.7, -483, 1364, -466, 1354, -469, 1349, -490, 1361, -487, 1366], + [20.1, 2.7, -1489, -179, -1498, -194, -1506, -189, -1498, -174], + [20.1, 12.2, -356, 1161, -365, 1145, -381, 1154, -372, 1170], + [20.1, 8.8, 659, -548, 649, -564, 644, -561, 658, -536, 663, -539], + [20.1, 11, -450, 1212, -429, 1201, -444, 1174, -464, 1186], + [20.1, 13.1, -386, 1108, -392, 1111, -383, 1129, -376, 1125], + [20.1, 12.8, -403, -1033, -414, -1054, -421, -1050, -409, -1029], + [20.1, 9.4, 434, -558, 425, -575, 411, -567, 421, -551], + [ + 20.1, 8.8, -996, -978, -1000, -984, -1010, -979, -1006, -972, -1011, -970, + -1014, -976, -1024, -971, -1021, -964, -1018, -966, -1010, -951, -1003, + -956, -1007, -964, -1003, -966, -999, -958, -990, -962, -998, -977 + ], + [ + 20.1, 6.4, 1001, -198, 995, -206, 982, -199, 988, -187, 983, -184, 976, + -195, 963, -188, 969, -178, 970, -178, 979, -159, 993, -166, 987, -177, + 992, -180, 997, -170, 1013, -179, 1008, -185, 1010, -187, 1005, -193, 998, + -188, 996, -191, 998, -191, 996, -195 + ], + [ + 20.1, 7.6, 630, -357, 627, -363, 633, -367, 637, -361, 643, -365, 635, + -379, 615, -368, 623, -354 + ], + [20.1, 11.6, -515, 1361, -505, 1379, -499, 1376, -509, 1358], + [20.1, 12.8, 1234, 1006, 1226, 993, 1200, 1008, 1207, 1021], + [ + 20.1, 10.1, -968, 214, -966, 217, -957, 213, -959, 209, -961, 209, -963, + 205, -962, 204, -965, 202, -971, 190, -978, 194, -971, 209, -969, 209, + -967, 213 + ], + [20.1, 23.5, 458, 158, 444, 133, 437, 136, 451, 162], + [ + 20.1, 16.5, -293, 1515, -280, 1536, -277, 1534, -282, 1525, -274, 1521, + -269, 1530, -265, 1528, -279, 1503, -294, 1511 + ], + [ + 20.1, 8.5, 17, -1345, 33, -1354, 21, -1377, 10, -1371, 13, -1364, 9, + -1362, 5, -1368, -6, -1362, -1, -1353, 3, -1353, 7, -1345, 15, -1349, 16, + -1348, 14, -1347, 15, -1344 + ], + [20.1, 6.7, 149, -1472, 141, -1487, 120, -1476, 129, -1461], + [ + 20.1, 8.8, -786, -522, -800, -548, -797, -549, -812, -576, -824, -569, + -809, -543, -814, -540, -816, -542, -822, -539, -836, -563, -846, -557, + -839, -543, -854, -535, -833, -496 + ], + [20.1, 11, -140, -1482, -150, -1500, -163, -1494, -152, -1474], + [ + 20.1, 6.1, 276, -1287, 273, -1293, 270, -1292, 270, -1294, 263, -1307, + 256, -1303, 263, -1290, 265, -1289, 262, -1287, 265, -1281 + ], + [20.1, 12.2, -750, 766, -731, 756, -734, 749, -760, 763, -756, 770], + [20.1, 17.1, -204, 1558, -207, 1552, -220, 1560, -211, 1576, -198, 1569], + [ + 20.1, 11.3, 1225, 580, 1229, 589, 1235, 585, 1238, 591, 1232, 594, 1237, + 602, 1257, 591, 1254, 587, 1258, 585, 1257, 584, 1258, 583, 1253, 574, + 1256, 573, 1251, 565 + ], + [ + 20.1, 11.3, -619, 1440, -627, 1425, -639, 1431, -645, 1435, -637, 1451, + -622, 1444, -622, 1442 + ], + [ + 20.1, 10.4, 436, -917, 422, -941, 391, -924, 395, -916, 393, -915, 403, + -898 + ], + [ + 20.1, 9.1, -976, -1019, -980, -1026, -986, -1024, -990, -1032, -984, + -1035, -989, -1043, -1009, -1032, -1004, -1023, -997, -1028, -996, -1024, + -994, -1025, -992, -1023, -994, -1022, -993, -1020, -1000, -1016, -996, + -1008 + ], + [ + 20.1, 8.8, 40, -1495, 37, -1500, 33, -1500, 34, -1501, 26, -1515, 18, + -1510, 26, -1497, 28, -1496, 25, -1494, 28, -1489 + ], + [ + 20.1, 8.8, -907, -665, -913, -677, -912, -678, -911, -676, -908, -677, + -905, -672, -893, -678, -897, -685, -895, -686, -898, -692, -900, -691, + -905, -698, -918, -691, -914, -683, -919, -681, -923, -688, -936, -681, + -922, -657 + ], + [20.2, 6.7, -1297, -934, -1307, -952, -1332, -938, -1323, -920], + [20.2, 7.6, -1214, -1027, -1224, -1044, -1231, -1040, -1221, -1023], + [20.2, 8.8, -627, 1262, -635, 1247, -652, 1256, -643, 1271, -632, 1266], + [ + 20.2, 10.7, -537, -198, -550, -222, -556, -219, -552, -212, -549, -214, + -548, -213, -550, -212, -544, -202, -546, -201, -549, -207, -552, -205, + -549, -199, -555, -209, -557, -208, -558, -209, -554, -211, -558, -218, + -564, -215, -551, -191 + ], + [ + 20.2, 5.2, -1297, -390, -1299, -396, -1312, -388, -1309, -382, -1307, + -383, -1298, -367, -1289, -372, -1296, -383, -1297, -388, -1296, -389 + ], + [20.2, 8.5, -917, -797, -928, -818, -940, -812, -928, -791], + [20.2, 14.3, -208, 1349, -218, 1332, -244, 1346, -235, 1364], + [ + 20.2, 13.4, -164, -274, -172, -288, -179, -284, -170, -268, -166, -268, + -164, -265, -161, -267 + ], + [20.2, 12.5, -416, 319, -422, 309, -437, 317, -431, 328], + [20.2, 19.2, 572, -61, 582, -44, 585, -45, 583, -49, 586, -50, 578, -64], + [ + 20.2, 18.3, 513, -107, 509, -115, 500, -110, 514, -85, 518, -87, 515, -92, + 519, -94, 511, -106 + ], + [20.2, 6.1, 127, -1138, 122, -1136, 132, -1118, 137, -1121], + [ + 20.2, 7.3, -1035, -531, -1039, -539, -1053, -531, -1049, -525, -1046, + -527, -1042, -519, -1045, -517, -1041, -510, -1028, -517, -1031, -524, + -1035, -522, -1039, -529 + ], + [ + 20.2, 7.3, -1041, -510, -1042, -512, -1043, -511, -1044, -513, -1043, + -514, -1053, -531, -1062, -527, -1049, -504, -1040, -509 + ], + [20.2, 21.9, 548, 415, 545, 409, 519, 423, 523, 429], + [ + 20.2, 11.3, 561, -724, 564, -718, 575, -723, 570, -732, 568, -731, 560, + -745, 552, -740, 556, -733, 558, -735, 559, -733, 560, -733, 564, -727 + ], + [ + 20.2, 6.7, -1044, -468, -1053, -482, -1052, -483, -1054, -486, -1055, + -486, -1058, -490, -1065, -486, -1063, -481, -1065, -480, -1068, -485, + -1075, -481, -1064, -457 + ], + [ + 20.2, 9.4, -909, -1008, -912, -1014, -916, -1012, -920, -1019, -916, + -1021, -920, -1028, -931, -1022, -927, -1016, -933, -1013, -936, -1019, + -947, -1013, -943, -1007, -939, -1008, -936, -1002, -939, -1000, -935, + -993, -925, -999, -928, -1004, -922, -1007, -919, -1002 + ], + [ + 20.3, 8.8, 1391, 738, 1387, 732, 1386, 733, 1376, 716, 1370, 720, 1379, + 736, 1378, 738, 1381, 744 + ], + [ + 20.3, 6.4, -835, 1333, -863, 1281, -897, 1300, -882, 1326, -877, 1324, + -863, 1350, -834, 1335 + ], + [20.3, 3.4, -1416, -220, -1424, -235, -1429, -232, -1420, -217], + [20.3, 9.8, -735, -1068, -745, -1086, -749, -1083, -739, -1065], + [ + 20.3, 13.7, -395, 1545, -403, 1530, -400, 1527, -404, 1520, -414, 1526, + -411, 1532, -409, 1531, -408, 1533, -410, 1534, -401, 1549 + ], + [20.3, 10.4, -130, -883, -143, -908, -150, -905, -136, -880], + [ + 20.3, 6.4, -1290, -646, -1271, -657, -1274, -664, -1295, -652, -1291, -645 + ], + [ + 20.3, 3.4, 943, -482, 937, -490, 936, -491, 930, -504, 924, -501, 932, + -488, 936, -476, 943, -480 + ], + [ + 20.3, 7, -1023, -450, -1027, -457, -1042, -448, -1038, -442, -1034, -444, + -1030, -436, -1033, -432, -1027, -422, -1012, -430, -1018, -441, -1022, + -439, -1026, -448 + ], + [ + 20.3, 5.8, -1201, 140, -1194, 152, -1186, 147, -1188, 144, -1176, 138, + -1191, 111, -1207, 120, -1199, 134, -1203, 136 + ], + [20.3, 21.6, 854, 1075, 846, 1060, 829, 1070, 837, 1084], + [20.3, 19.2, 597, -24, 594, -23, 602, -10, 606, -12, 600, -24], + [ + 20.3, 6.7, -1179, -674, -1178, -672, -1174, -674, -1170, -666, -1174, + -664, -1170, -657, -1155, -665, -1159, -672, -1163, -670, -1167, -678, + -1163, -680, -1167, -686, -1182, -678 + ], + [ + 20.3, 5.2, 209, -1221, 205, -1227, 199, -1223, 212, -1201, 216, -1203, + 208, -1219, 206, -1220 + ], + [ + 20.3, 15.8, -250, 1555, -263, 1533, -270, 1536, -265, 1543, -272, 1546, + -270, 1550, -272, 1549, -276, 1540, -283, 1544, -270, 1566 + ], + [20.3, 13.4, -128, 1121, -140, 1098, -166, 1112, -151, 1138, -128, 1125], + [ + 20.3, 9.1, 423, -997, 420, -1003, 417, -1002, 409, -1019, 400, -1014, 404, + -1007, 408, -1007, 412, -1000, 409, -998, 413, -991 + ], + [20.3, 14.3, -978, 581, -987, 566, -998, 573, -990, 588], + [20.3, 19.5, 80, 241, 67, 217, 62, 219, 76, 244], + [20.3, 9.4, 198, -818, 204, -821, 198, -831, 182, -823, 188, -812], + [20.4, 3.7, -1354, -208, -1362, -224, -1388, -210, -1379, -194], + [20.4, 12.8, -68, -321, -65, -314, -38, -329, -41, -336], + [20.4, 8.5, -910, -801, -920, -820, -927, -816, -917, -797], + [20.4, 8.5, -1172, -1041, -1185, -1065, -1191, -1062, -1177, -1038], + [20.4, 17.7, 412, 1006, 398, 981, 393, 984, 407, 1009], + [20.4, 10.1, -625, -544, -639, -568, -652, -561, -639, -537], + [ + 20.4, 8.8, -776, -1330, -790, -1356, -809, -1345, -814, -1353, -809, + -1356, -818, -1374, -845, -1359, -816, -1307 + ], + [20.4, 7, 98, -1143, 89, -1160, 83, -1157, 92, -1140], + [ + 20.4, 15.2, 1255, 400, 1246, 405, 1247, 408, 1234, 414, 1243, 430, 1250, + 426, 1255, 434, 1253, 432, 1245, 438, 1253, 453, 1264, 447, 1263, 446, + 1266, 444, 1266, 446, 1277, 440, 1272, 431, 1271, 432, 1267, 422, 1266, + 423, 1265, 420, 1266, 419, 1262, 412, 1261, 412 + ], + [ + 20.4, 5.8, -1264, -520, -1268, -527, -1271, -525, -1275, -533, -1272, + -535, -1276, -541, -1289, -534, -1285, -528, -1281, -529, -1277, -522, + -1281, -520, -1277, -513 + ], + [ + 20.4, 7, -1273, -947, -1277, -953, -1279, -952, -1288, -970, -1295, -966, + -1285, -949, -1288, -947, -1284, -941 + ], + [20.4, 18, 30, 440, 27, 435, 4, 447, 7, 453], + [20.4, 12.5, -260, 1163, -274, 1137, -300, 1151, -286, 1178], + [20.4, 11.9, 31, -287, 20, -306, 14, -303, 26, -282, 32, -285], + [ + 20.4, 7, -1284, -941, -1288, -948, -1291, -946, -1297, -956, -1293, -958, + -1297, -965, -1310, -957, -1306, -951, -1303, -952, -1297, -942, -1301, + -940, -1297, -934 + ], + [ + 20.4, 6.7, 132, -1118, 129, -1124, 125, -1123, 120, -1132, 123, -1134, + 120, -1141, 104, -1132, 108, -1126, 112, -1127, 117, -1118, 114, -1115, + 117, -1110 + ], + [ + 20.4, 7.6, -1017, -760, -1036, -795, -1058, -783, -1051, -771, -1046, + -774, -1032, -749, -1037, -746, -1031, -734, -1009, -746 + ], + [ + 20.4, 2.7, 915, -509, 911, -514, 905, -527, 898, -524, 911, -502, 917, + -505 + ], + [ + 20.4, 9.1, -962, -978, -966, -985, -969, -983, -973, -990, -969, -992, + -973, -999, -984, -993, -980, -987, -986, -984, -990, -990, -1000, -984, + -996, -977, -993, -979, -989, -972, -992, -970, -988, -964, -978, -969, + -981, -975, -976, -978, -973, -972 + ], + [20.5, 18.6, 832, 931, 828, 924, 805, 936, 809, 944], + [20.5, 3.4, -1419, -172, -1429, -191, -1434, -188, -1423, -170], + [20.5, 18, 40, 450, 37, 444, 33, 446, 30, 440, 7, 453, 14, 465], + [20.5, 12.2, -358, -781, -362, -788, -389, -773, -384, -766], + [ + 20.5, 9.1, -935, -993, -939, -1000, -943, -998, -946, -1005, -943, -1007, + -947, -1013, -957, -1008, -954, -1001, -956, -1001, -959, -998, -963, + -1005, -973, -999, -969, -992, -966, -994, -962, -987, -966, -985, -962, + -978, -951, -984, -954, -990, -949, -993, -946, -987 + ], + [ + 20.5, 5.5, 305, -1528, 302, -1534, 291, -1528, 295, -1523, 297, -1523, + 305, -1509, 312, -1512, 303, -1526 + ], + [ + 20.5, 8.8, -880, -232, -882, -236, -887, -233, -890, -238, -885, -242, + -890, -250, -902, -244, -900, -240, -903, -238, -904, -239, -913, -234, + -912, -233, -916, -231, -918, -235, -930, -228, -925, -219, -920, -222, + -917, -217, -922, -214, -918, -207, -907, -213, -910, -219, -906, -222, + -902, -215, -894, -220, -897, -226, -893, -229, -889, -222, -878, -229 + ], + [20.5, 16.2, -293, 1516, -296, 1511, -300, 1513, -287, 1536, -284, 1534], + [20.5, 13.4, -304, -327, -318, -351, -324, -348, -310, -323], + [20.5, 9.4, -526, 1247, -553, 1261, -549, 1268, -523, 1253], + [20.5, 10.4, 309, -779, 305, -786, 280, -772, 293, -749, 318, -763], + [20.5, 20.1, 624, 109, 616, 94, 611, 97, 622, 115, 626, 113], + [20.5, 18, 42, 478, 33, 461, 17, 470, 26, 487], + [ + 20.5, 8.8, 509, -330, 505, -336, 503, -335, 500, -337, 492, -350, 478, + -342, 480, -338, 478, -337, 481, -332, 490, -337, 494, -330, 490, -328, + 493, -322 + ], + [ + 20.5, 4, -1303, -278, -1306, -283, -1312, -279, -1313, -282, -1333, -271, + -1329, -264 + ], + [ + 20.5, 7.3, -1008, -459, -1012, -465, -1022, -460, -1018, -453, -1016, + -454, -1007, -438, -1001, -441, -1010, -458 + ], + [20.5, 14, -789, 542, -802, 519, -812, 524, -799, 548], + [20.5, 12.2, -280, -949, -273, -937, -265, -941, -276, -961, -284, -957], + [ + 20.5, 5.5, -1245, -358, -1249, -364, -1250, -363, -1259, -379, -1267, + -374, -1259, -359, -1261, -358, -1257, -352 + ], + [20.5, 3.4, -1402, -225, -1411, -242, -1416, -239, -1406, -223], + [20.5, 22.6, 463, 198, 455, 183, 448, 187, 461, 211, 466, 208, 461, 199], + [ + 20.5, 4.6, -1345, -400, -1341, -393, -1328, -400, -1332, -407, -1335, + -406, -1339, -413, -1336, -414, -1339, -421, -1351, -415, -1343, -401 + ], + [20.5, 13.4, -27, -123, -40, -146, -54, -139, -41, -115], + [ + 20.6, 8.5, -1055, -1067, -1070, -1093, -1080, -1088, -1069, -1067, -1071, + -1066, -1068, -1060 + ], + [ + 20.6, 6.4, -1263, -718, -1245, -728, -1248, -734, -1272, -722, -1268, -715 + ], + [20.6, 23.2, 464, 154, 450, 129, 444, 133, 458, 158], + [20.6, 18, 1253, 225, 1243, 208, 1238, 211, 1247, 228], + [20.6, 12.8, -89, -217, -101, -240, -108, -236, -95, -213], + [ + 20.6, 10.1, -52, -1445, -56, -1452, -57, -1451, -65, -1464, -83, -1455, + -75, -1441, -77, -1440, -73, -1433 + ], + [20.6, 9.8, -853, -247, -862, -264, -889, -249, -880, -232], + [20.6, 9.1, -30, -1223, -37, -1235, -44, -1231, -38, -1219], + [ + 20.6, 11.3, -579, -900, -592, -923, -597, -921, -596, -920, -599, -918, + -586, -895 + ], + [ + 20.6, 9.1, 1380, 743, 1377, 737, 1374, 738, 1374, 736, 1366, 722, 1359, + 726, 1367, 740, 1369, 740, 1366, 743, 1369, 749 + ], + [ + 20.6, 10.1, -549, 1268, -553, 1261, -556, 1263, -562, 1253, -558, 1251, + -562, 1245, -575, 1252, -571, 1259, -568, 1257, -563, 1266, -567, 1267, + -563, 1275 + ], + [ + 20.6, 5.8, -1131, -370, -1134, -376, -1128, -380, -1124, -374, -1116, + -378, -1128, -401, -1138, -395, -1131, -383, -1135, -381, -1142, -393, + -1151, -388, -1139, -366 + ], + [ + 20.6, 10.4, 650, -626, 647, -632, 643, -630, 638, -641, 641, -642, 638, + -648, 624, -641, 637, -618 + ], + [ + 20.6, 11, -472, 1407, -475, 1401, -478, 1402, -487, 1384, -492, 1387, + -479, 1410 + ], + [20.6, 2.7, -1534, -108, -1542, -123, -1548, -120, -1540, -105], + [ + 20.6, 11.6, -277, 1259, -252, 1245, -262, 1227, -261, 1226, -264, 1221, + -294, 1238, -291, 1244, -288, 1241 + ], + [20.6, 8.5, -872, 115, -878, 105, -884, 108, -876, 123, -870, 119], + [20.6, 8.5, -1085, -1052, -1095, -1070, -1100, -1068, -1090, -1049], + [ + 20.6, 13.4, 625, -202, 621, -209, 616, -207, 611, -214, 616, -217, 612, + -224, 595, -214, 599, -207, 604, -210, 608, -202, 603, -199, 607, -192 + ], + [ + 20.6, 10.1, -563, 1275, -566, 1268, -569, 1270, -572, 1266, -575, 1261, + -572, 1259, -575, 1252, -589, 1259, -585, 1266, -582, 1264, -576, 1274, + -580, 1276, -576, 1283 + ], + [ + 20.6, 5.8, -1261, -833, -1264, -838, -1287, -826, -1283, -819, -1279, + -822, -1276, -816, -1273, -818, -1271, -814, -1278, -810, -1273, -801, + -1257, -810, -1261, -818, -1254, -821, -1257, -826, -1261, -824, -1265, + -831 + ], + [20.6, 11.9, -396, -737, -410, -762, -416, -759, -402, -734], + [ + 20.6, 9.8, -815, -264, -819, -271, -827, -267, -829, -272, -824, -275, + -829, -284, -843, -276, -839, -268, -843, -266, -848, -274, -863, -265, + -858, -256, -854, -259, -851, -255, -850, -253, -855, -250, -851, -243, + -834, -253, -838, -258, -837, -260, -838, -262, -836, -263, -834, -261, + -830, -255 + ], + [20.6, 12.5, -333, 1328, -340, 1314, -346, 1317, -338, 1331], + [20.7, 23.5, 338, 314, 329, 298, 322, 302, 331, 318], + [ + 20.7, 7.9, -1074, -811, -1068, -800, -1044, -813, -1055, -833, -1071, + -824, -1070, -821, -1072, -820, -1069, -814 + ], + [ + 20.7, 3.4, -1398, -229, -1406, -245, -1411, -242, -1402, -225, -1397, -228 + ], + [20.7, 13.1, -298, -379, -306, -392, -312, -389, -303, -371, -297, -375], + [20.7, 2.7, -1540, -105, -1549, -122, -1555, -119, -1545, -102], + [20.7, 16.5, -223, 1583, -232, 1566, -246, 1574, -236, 1590], + [20.7, 9.8, 297, -703, 287, -720, 277, -715, 286, -698], + [20.7, 11.3, -574, -217, -587, -239, -593, -236, -580, -213], + [ + 20.7, 14.9, -82, 1345, -70, 1333, -85, 1306, -87, 1307, -88, 1306, -105, + 1315, -89, 1346, -85, 1342, -83, 1346 + ], + [ + 20.7, 13.1, -151, 1138, -166, 1112, -169, 1113, -171, 1109, -192, 1121, + -185, 1138, -175, 1151 + ], + [ + 20.7, 4.9, -1307, -268, -1300, -272, -1303, -278, -1329, -264, -1326, -258 + ], + [ + 20.7, 11.6, -190, -1367, -194, -1376, -196, -1375, -204, -1388, -214, + -1383, -206, -1369, -208, -1368, -203, -1360 + ], + [ + 20.7, 5.8, -1336, -620, -1340, -627, -1363, -614, -1359, -607, -1351, + -612, -1347, -605, -1355, -600, -1351, -593, -1328, -606, -1332, -613, + -1339, -610, -1343, -616 + ], + [20.7, 10.4, 406, -592, 399, -604, 389, -598, 399, -581, 409, -587], + [ + 20.7, 7.3, 676, -394, 672, -401, 663, -396, 668, -386, 671, -389, 675, + -383, 675, -380, 673, -378, 676, -372, 684, -376, 675, -391 + ], + [ + 20.7, 11.6, -448, 1121, -456, 1107, -463, 1111, -463, 1110, -490, 1124, + -481, 1140 + ], + [20.7, 6.7, 116, -1062, 104, -1082, 83, -1070, 94, -1050], + [20.7, 14.3, -322, 1413, -331, 1397, -336, 1400, -327, 1416], + [20.7, 13.4, -113, -75, -128, -99, -133, -96, -119, -72], + [20.8, 10.7, 385, -849, 382, -855, 353, -840, 357, -833], + [20.8, 14, -115, -19, -130, -45, -137, -41, -123, -15], + [ + 20.8, 18.9, 645, 104, 634, 84, 630, 87, 643, 111, 645, 110, 643, 107, 646, + 106 + ], + [20.8, 6.1, -1261, -639, -1264, -645, -1285, -633, -1282, -627], + [ + 20.8, 6.4, -1318, -716, -1306, -722, -1309, -728, -1336, -714, -1333, -707 + ], + [20.8, 2.7, -1516, 217, -1530, 193, -1552, 205, -1539, 229], + [ + 20.8, 10.1, -516, 1460, -520, 1453, -530, 1459, -526, 1465, -524, 1464, + -515, 1481, -509, 1477, -518, 1462 + ], + [20.8, 6.1, -1257, -633, -1261, -639, -1286, -625, -1283, -619], + [ + 20.8, 7.3, -986, -590, -989, -597, -993, -595, -994, -596, -992, -597, + -1001, -613, -1011, -607, -1008, -600, -1004, -603, -1002, -598, -998, + -592, -1002, -590, -998, -583 + ], + [20.8, 10.4, -469, 1349, -475, 1338, -495, 1349, -490, 1361], + [ + 20.8, 5.8, 253, -1164, 257, -1158, 261, -1160, 262, -1159, 261, -1158, + 264, -1153, 260, -1151, 262, -1148, 277, -1156, 275, -1159, 271, -1158, + 268, -1163, 271, -1166, 268, -1172 + ], + [20.8, 7.9, -1177, -1038, -1191, -1062, -1198, -1058, -1183, -1035], + [20.9, 12.8, -175, 1151, -185, 1138, -192, 1121, -208, 1130, -191, 1160], + [ + 20.9, 13.1, 1267, 484, 1262, 487, 1258, 482, 1264, 479, 1259, 470, 1232, + 486, 1237, 494, 1242, 491, 1245, 497, 1240, 499, 1244, 508, 1272, 492 + ], + [ + 20.9, 9.1, -4, -1358, -7, -1364, -18, -1357, -15, -1352, -12, -1353, -13, + -1351, -5, -1338, 3, -1342, -6, -1356 + ], + [20.9, 13.4, -219, -336, -223, -343, -243, -331, -242, -323], + [ + 20.9, 10.1, -581, 1285, -585, 1278, -591, 1281, -594, 1274, -589, 1271, + -594, 1263, -615, 1275, -610, 1283, -604, 1279, -601, 1284, -600, 1283, + -599, 1285, -606, 1289, -602, 1297 + ], + [20.9, 13.1, -292, -380, -293, -385, -299, -397, -306, -393, -298, -379], + [ + 20.9, 7.3, -950, -479, -957, -493, -991, -475, -992, -476, -995, -474, + -997, -473, -997, -472, -1011, -464, -997, -439, -987, -445, -989, -447, + -982, -451, -981, -448, -944, -469 + ], + [20.9, 13.4, -150, -234, -164, -258, -170, -255, -156, -230], + [20.9, 12.2, -338, 1331, -346, 1317, -350, 1320, -342, 1333], + [20.9, 10.7, 348, -665, 347, -666, 323, -652, 332, -637, 356, -650], + [20.9, 18, 197, 1419, 157, 1441, 177, 1486, 218, 1458], + [20.9, 12.8, -245, -578, -249, -585, -277, -570, -276, -561], + [20.9, 2.7, -1420, -217, -1429, -232, -1433, -230, -1425, -215], + [ + 20.9, 5.8, 268, -1255, 266, -1260, 254, -1253, 256, -1249, 258, -1249, + 268, -1232, 277, -1237, 267, -1254 + ], + [20.9, 7.6, 190, -1071, 171, -1061, 176, -1053, 195, -1063], + [ + 20.9, 10.7, -671, -807, -670, -805, -662, -809, -665, -814, -658, -818, + -663, -826, -668, -823, -670, -827, -680, -822, -678, -818, -687, -813, + -689, -816, -693, -814, -686, -801, -672, -809 + ], + [20.9, 12.2, -388, 1358, -400, 1337, -404, 1339, -392, 1362], + [20.9, 21, 702, 1002, 699, 996, 672, 1011, 675, 1017], + [20.9, 13.4, -163, -227, -177, -252, -184, -248, -170, -223], + [20.9, 13.4, -156, -230, -170, -255, -172, -256, -177, -253, -163, -227], + [ + 20.9, 3, 936, -476, 933, -482, 928, -486, 922, -500, 916, -496, 924, -483, + 923, -482, 928, -472 + ], + [20.9, 2.4, -1554, -116, -1559, -127, -1566, -123, -1560, -113], + [ + 20.9, 3, 928, -472, 925, -477, 920, -481, 914, -495, 908, -492, 914, -482, + 915, -482, 917, -479, 916, -478, 921, -468 + ], + [ + 20.9, 10.1, 1373, 779, 1369, 772, 1362, 776, 1375, 799, 1382, 795, 1378, + 790 + ], + [ + 21, 7.3, 134, -1504, 126, -1519, 118, -1515, 132, -1491, 137, -1494, 132, + -1503 + ], + [21, 6.1, -1305, -680, -1300, -671, -1284, -679, -1289, -689], + [ + 21, 12.5, -271, -370, -271, -370, -276, -411, -300, -398, -296, -390, + -288, -391, -287, -386, -293, -385, -292, -380, -287, -381, -286, -377, + -296, -375, -295, -371, -292, -372, -291, -368 + ], + [21, 4, 948, -428, 939, -444, 929, -438, 942, -414, 952, -420], + [ + 21, 11, 548, -777, 552, -771, 557, -767, 561, -754, 568, -758, 564, -764, + 561, -767, 555, -781 + ], + [ + 21, 13.4, -109, 1083, -139, 1100, -127, 1121, -124, 1119, -122, 1122, -97, + 1107, -96, 1106 + ], + [ + 21, 13.7, -457, 1528, -464, 1515, -474, 1521, -475, 1519, -481, 1523, + -467, 1549, -450, 1540 + ], + [ + 21, 9.4, -911, -260, -914, -266, -918, -265, -917, -267, -927, -284, -935, + -280, -925, -261, -926, -260, -923, -254 + ], + [21, 11.9, -260, -992, -269, -1008, -276, -1004, -267, -988], + [ + 21, 5.5, 650, -1091, 653, -1093, 656, -1088, 681, -1102, 674, -1115, 646, + -1099 + ], + [ + 21, 15.8, 231, 1172, 228, 1166, 204, 1179, 209, 1188, 210, 1187, 220, + 1205, 239, 1194, 228, 1174 + ], + [ + 21, 3.7, 968, -398, 961, -410, 957, -407, 954, -412, 944, -406, 946, -402, + 942, -399, 948, -387, 951, -389, 953, -385, 967, -393, 965, -396 + ], + [ + 21, 9.1, 198, -831, 201, -833, 195, -843, 198, -845, 195, -850, 174, -839, + 182, -823 + ], + [ + 21, 9.4, 481, -510, 479, -513, 488, -519, 490, -515, 498, -520, 490, -532, + 483, -528, 485, -525, 476, -519, 474, -523, 467, -519, 474, -506 + ], + [ + 21, 10.1, 1374, 798, 1372, 797, 1364, 782, 1365, 781, 1362, 776, 1353, + 780, 1356, 786, 1358, 786, 1366, 801, 1366, 802, 1368, 806, 1372, 805, + 1376, 803 + ], + [ + 21, 9.1, 422, -977, 426, -970, 429, -970, 429, -968, 437, -954, 444, -958, + 435, -974, 434, -974, 436, -976, 433, -982 + ], + [21, 10.1, 157, -671, 142, -697, 136, -694, 151, -668], + [21, 8.2, -881, -520, -889, -534, -894, -531, -886, -517], + [21, 11.9, -391, -739, -405, -764, -410, -761, -396, -737], + [21, 13.4, -223, -350, -211, -328, -206, -331, -218, -352], + [21, 12.2, -375, -749, -387, -770, -396, -765, -384, -744], + [ + 21, 6.7, -1052, -509, -1055, -514, -1056, -513, -1062, -527, -1071, -522, + -1057, -499, -1050, -504, -1053, -508 + ], + [21, 19.2, 659, 83, 656, 78, 638, 88, 639, 90, 640, 93], + [ + 21.1, 4.3, -1363, -71, -1366, -77, -1373, -73, -1359, -52, -1354, -54, + -1360, -63, -1359, -64, -1361, -68, -1362, -68 + ], + [ + 21.1, 6.7, -1061, -504, -1064, -509, -1071, -522, -1079, -517, -1066, + -494, -1059, -499, -1062, -503 + ], + [ + 21.1, 9.1, 101, -870, 94, -883, 83, -877, 92, -863, 91, -862, 95, -854, + 107, -861 + ], + [ + 21.1, 13.7, -405, 1495, -408, 1492, -400, 1488, -398, 1492, -392, 1488, + -398, 1477, -421, 1489, -414, 1500 + ], + [ + 21.1, 7, -957, -327, -963, -338, -975, -331, -976, -333, -973, -335, -977, + -341, -992, -333, -987, -323, -985, -325, -983, -321, -987, -319, -982, + -310, -960, -322, -961, -324 + ], + [ + 21.1, 21.3, 1222, 38, 1217, 29, 1208, 33, 1209, 36, 1199, 42, 1203, 49, + 1210, 45, 1213, 52, 1207, 56, 1210, 62, 1229, 51, 1226, 45, 1221, 46, + 1218, 40 + ], + [21.1, 12.2, 87, -232, 78, -249, 71, -245, 81, -229], + [21.1, 13.7, 988, 565, 982, 554, 956, 568, 962, 579], + [ + 21.1, 9.8, -850, -1027, -877, -1013, -878, -1016, -891, -1009, -880, -987, + -867, -994, -873, -1007, -847, -1021 + ], + [21.1, 9.1, -857, -780, -870, -802, -875, -799, -862, -775, -856, -778], + [ + 21.1, 13.4, -119, -72, -133, -97, -138, -94, -138, -93, -139, -92, -126, + -68 + ], + [21.1, 6.1, 117, -1110, 103, -1134, 98, -1131, 111, -1107], + [21.1, 2.4, -1438, -161, -1446, -176, -1453, -172, -1445, -157], + [21.1, 15.8, -140, 916, -131, 911, -146, 885, -165, 895, -150, 921], + [ + 21.1, 11.6, 469, -873, 473, -867, 476, -869, 481, -860, 478, -858, 482, + -850, 494, -856, 490, -864, 488, -863, 479, -879 + ], + [21.1, 3, -1457, -197, -1465, -212, -1476, -206, -1468, -191], + [21.2, 7.3, 1438, 587, 1430, 591, 1445, 618, 1452, 614], + [21.2, 23.2, 284, 311, 306, 298, 303, 292, 280, 305], + [21.2, 23.2, 488, 276, 479, 260, 473, 263, 486, 288, 493, 284], + [21.2, 3.7, -1419, 21, -1428, 5, -1433, 7, -1424, 23], + [ + 21.2, 8.8, -867, -374, -871, -381, -874, -380, -882, -395, -896, -388, + -890, -379, -895, -377, -899, -386, -913, -378, -904, -363, -906, -362, + -902, -354, -889, -362, -892, -367, -890, -368, -892, -371, -888, -374, + -886, -370, -884, -371, -881, -366 + ], + [ + 21.2, 11, 777, -132, 773, -139, 768, -136, 765, -132, 750, -126, 754, -120 + ], + [ + 21.2, 21.6, 515, 10, 515, 11, 519, 9, 521, 13, 517, 15, 526, 30, 539, 23, + 530, 7, 523, 11, 520, 5, 514, 8 + ], + [21.2, 8.2, -1053, -638, -1064, -658, -1071, -654, -1059, -634], + [21.2, 13.4, -223, -343, -220, -344, -224, -350, -244, -339, -243, -331], + [21.2, 13.1, -283, 197, -299, 168, -306, 172, -290, 201], + [ + 21.2, 6.7, -1152, -583, -1159, -595, -1160, -594, -1162, -603, -1165, + -601, -1166, -603, -1170, -600, -1167, -595, -1165, -596, -1158, -580 + ], + [ + 21.2, 6.7, -1114, -446, -1112, -448, -1113, -449, -1095, -459, -1099, + -465, -1116, -456, -1118, -458, -1123, -455, -1117, -444 + ], + [21.2, 16.2, -2, 1327, -17, 1301, -41, 1315, -26, 1340], + [21.2, 9.1, 653, -589, 639, -615, 627, -608, 640, -581], + [ + 21.2, 9.4, 420, -520, 417, -526, 406, -520, 410, -513, 412, -513, 421, + -499, 428, -502, 419, -517, 421, -519 + ], + [21.3, 11, -588, -722, -600, -744, -607, -741, -594, -717, -588, -721], + [ + 21.3, 6.7, -1190, -608, -1193, -614, -1191, -615, -1187, -610, -1181, + -613, -1188, -626, -1212, -613, -1204, -600 + ], + [ + 21.3, 11.6, -227, -922, -236, -940, -241, -937, -242, -939, -244, -938, + -233, -918 + ], + [21.3, 12.2, -69, -402, -76, -415, -110, -396, -103, -384], + [21.3, 18.6, 495, 1051, 480, 1026, 474, 1029, 488, 1054], + [21.3, 7, -1018, -453, -1022, -460, -1027, -457, -1017, -440, -1012, -442], + [21.3, 3, -1432, -185, -1434, -188, -1443, -183, -1432, -165, -1423, -170], + [21.3, 8.5, 323, -1031, 309, -1058, 276, -1039, 291, -1013], + [21.3, 20.7, 608, 77, 592, 49, 591, 50, 592, 53, 590, 55, 604, 79], + [21.3, 5.2, 247, -1223, 235, -1243, 226, -1238, 238, -1218], + [21.3, 11.3, -625, -1163, -638, -1186, -647, -1181, -634, -1158], + [ + 21.3, 11.6, -243, -1368, -256, -1393, -296, -1371, -281, -1345, -248, + -1363, -249, -1364 + ], + [ + 21.3, 4.9, -1224, -797, -1228, -803, -1230, -802, -1239, -820, -1253, + -812, -1250, -807, -1248, -808, -1246, -803, -1243, -805, -1239, -798, + -1242, -796, -1238, -789 + ], + [ + 21.3, 8.5, 1404, 731, 1400, 724, 1397, 726, 1392, 717, 1396, 716, 1392, + 708, 1379, 716, 1382, 722, 1385, 720, 1390, 729, 1387, 732, 1391, 738 + ], + [21.4, 12.2, -165, -433, -170, -441, -192, -429, -187, -421], + [21.4, 11, -570, -732, -583, -755, -589, -752, -576, -728, -570, -731], + [ + 21.4, 11, -700, 863, -700, 862, -696, 859, -692, 859, -693, 857, -690, + 856, -681, 852, -684, 845, -695, 854, -696, 852, -707, 858, -704, 865 + ], + [21.4, 16.2, 301, -160, 305, -163, 291, -188, 278, -181, 292, -155], + [21.4, 9.1, -834, -1230, -848, -1254, -861, -1247, -847, -1223], + [21.4, 12.5, -391, -839, -398, -853, -427, -837, -420, -823], + [21.4, 3, -1445, -157, -1453, -172, -1460, -168, -1451, -154], + [ + 21.4, 11.6, 917, 298, 903, 305, 904, 307, 896, 309, 898, 311, 891, 314, + 905, 339, 926, 327, 918, 313, 923, 310 + ], + [ + 21.4, 12.2, -556, -1450, -569, -1473, -575, -1469, -562, -1446, -555, + -1449 + ], + [ + 21.4, 9.8, 3, -888, 18, -897, 20, -894, 22, -895, 7, -924, -35, -901, -21, + -875 + ], + [21.4, 16.2, -179, 869, -193, 845, -198, 847, -185, 872], + [ + 21.4, 6.7, -1201, -965, -1196, -957, -1193, -958, -1186, -943, -1173, + -951, -1177, -959, -1176, -959, -1174, -957, -1172, -959, -1169, -953, + -1153, -961, -1157, -967, -1156, -968, -1157, -970, -1155, -971, -1155, + -969, -1153, -970, -1148, -963, -1132, -971, -1138, -982, -1139, -981, + -1146, -996, -1163, -986, -1157, -976, -1162, -973, -1169, -983, -1182, + -976, -1176, -965, -1181, -963, -1187, -973 + ], + [ + 21.4, 12.2, 431, -778, 430, -780, 426, -778, 421, -788, 424, -790, 421, + -796, 407, -788, 410, -782, 413, -784, 419, -774, 416, -772, 419, -766, + 433, -774 + ], + [21.4, 14, 710, -47, 718, -34, 722, -36, 715, -50], + [21.4, 9.4, -882, 169, -896, 144, -925, 160, -911, 185], + [ + 21.4, 10.4, -975, 222, -979, 216, -982, 217, -985, 211, -985, 209, -983, + 207, -988, 200, -995, 204, -987, 220, -988, 221, -985, 227 + ], + [ + 21.4, 6.7, -1123, -455, -1118, -458, -1119, -460, -1101, -469, -1105, + -476, -1122, -467, -1124, -469, -1130, -465 + ], + [ + 21.4, 4, -1372, -57, -1379, -70, -1386, -66, -1379, -53, -1377, -54, + -1376, -51, -1377, -50, -1374, -44, -1367, -47, -1374, -56 + ], + [21.4, 4, 907, -461, 894, -484, 888, -481, 897, -469, 895, -469, 901, -457], + [ + 21.5, 12.2, 469, -793, 467, -797, 465, -796, 458, -809, 460, -810, 456, + -816, 445, -811, 449, -804, 450, -805, 458, -792, 456, -791, 458, -787 + ], + [21.5, 12.8, -389, -1196, -391, -1203, -421, -1195, -419, -1187], + [21.5, 2.7, -1472, -143, -1480, -157, -1486, -153, -1478, -139], + [21.5, 9.1, -848, -1288, -864, -1315, -871, -1311, -855, -1284], + [ + 21.5, 10.1, -653, -262, -666, -285, -678, -279, -665, -255, -660, -258, + -661, -259 + ], + [21.5, 23.8, 424, 392, 418, 381, 411, 385, 425, 409, 432, 406], + [21.5, 5.5, -1367, -549, -1380, -570, -1385, -567, -1374, -545], + [21.5, 9.8, -426, 1239, -425, 1241, -412, 1234, -421, 1218, -434, 1225], + [ + 21.6, 3.7, 913, -464, 904, -478, 903, -482, 900, -487, 894, -484, 907, + -461 + ], + [21.6, 9.1, -826, -1232, -840, -1257, -847, -1253, -833, -1228], + [ + 21.6, 11.9, -346, 1336, -350, 1329, -356, 1332, -357, 1327, -360, 1324, + -354, 1321, -359, 1313, -379, 1324, -375, 1332, -369, 1329, -365, 1333, + -364, 1337, -370, 1340, -365, 1348 + ], + [21.6, 21, 606, 128, 593, 105, 587, 108, 597, 127, 601, 125, 603, 129], + [21.6, 12.8, 1042, 569, 1027, 543, 1019, 548, 1033, 573], + [21.6, 18.9, 438, 959, 424, 934, 419, 937, 433, 962], + [ + 21.6, 10.4, 293, -661, 291, -664, 275, -656, 279, -649, 288, -654, 286, + -657 + ], + [ + 21.6, 10.7, -122, -1375, -96, -1390, -100, -1397, -128, -1381, -124, -1374 + ], + [21.6, 14.3, 764, 147, 762, 143, 753, 149, 763, 169, 773, 163], + [ + 21.6, 9.1, -801, -1249, -814, -1272, -840, -1258, -826, -1232, -813, + -1239, -814, -1242 + ], + [21.6, 3, -1465, -146, -1473, -161, -1480, -157, -1472, -143], + [ + 21.6, 9.8, -1026, 212, -1039, 190, -1045, 192, -1037, 207, -1034, 206, + -1030, 214 + ], + [ + 21.6, 16.8, 196, 996, 184, 974, 177, 978, 181, 986, 183, 985, 184, 987, + 183, 988, 184, 990, 185, 989, 186, 991, 185, 992, 189, 999 + ], + [21.7, 15.5, -209, 689, -216, 676, -243, 691, -236, 704], + [21.7, 22.6, 511, 70, 533, 58, 530, 53, 527, 54, 525, 56, 523, 54, 507, 63], + [ + 21.7, 12.5, -200, -496, -203, -502, -235, -484, -234, -481, -228, -484, + -227, -481 + ], + [21.7, 2.7, -1486, -135, -1493, -149, -1500, -145, -1492, -131], + [ + 21.7, 14.6, -342, 1453, -345, 1447, -353, 1451, -349, 1458, -344, 1469, + -336, 1465 + ], + [21.7, 20.4, 460, -72, 453, -86, 431, -74, 439, -61], + [ + 21.7, 6.7, -1170, -657, -1179, -674, -1183, -672, -1186, -678, -1193, + -674, -1181, -651 + ], + [21.8, 14.3, 78, -101, 61, -91, 65, -84, 82, -94], + [ + 21.8, 7, -1124, -469, -1125, -471, -1107, -480, -1116, -497, -1140, -484, + -1130, -465 + ], + [21.8, 4, 1020, -617, 1017, -635, 1006, -633, 1010, -612, 1021, -614], + [21.8, 10.4, -449, 351, -461, 331, -499, 351, -487, 372], + [21.8, 12.8, -166, 1112, -140, 1098, -155, 1072, -183, 1087, -169, 1113], + [21.8, 11, -526, -755, -540, -779, -546, -776, -533, -751], + [21.8, 12.5, 112, -201, 99, -224, 93, -221, 106, -197], + [21.8, 23.2, 436, 169, 426, 152, 421, 155, 430, 172], + [ + 21.8, 10.4, 763, -116, 768, -121, 780, -126, 777, -132, 754, -120, 758, + -113 + ], + [ + 21.8, 5.2, 236, -1176, 226, -1194, 206, -1183, 208, -1180, 201, -1176, + 209, -1161 + ], + [ + 21.9, 12.5, -203, -502, -207, -509, -236, -493, -234, -489, -237, -488, + -235, -484 + ], + [ + 21.9, 12.5, -207, -509, -212, -517, -227, -508, -228, -510, -246, -500, + -245, -497, -240, -500, -236, -493 + ], + [21.9, 14.6, -96, 94, -111, 68, -124, 75, -110, 102], + [ + 21.9, 9.1, 730, -196, 729, -197, 747, -206, 744, -212, 713, -194, 716, + -188 + ], + [21.9, 15.5, -170, 402, -192, 414, -187, 425, -169, 415, -168, 413], + [21.9, 10.4, -636, -501, -643, -514, -654, -507, -647, -495], + [ + 21.9, 5.2, 299, -1471, 295, -1474, 289, -1484, 288, -1487, 289, -1488, + 288, -1491, 277, -1485, 285, -1475, 289, -1464, 300, -1469 + ], + [21.9, 12.2, -362, -788, -368, -798, -393, -784, -388, -774], + [21.9, 10.4, -593, 918, -607, 892, -616, 897, -602, 923], + [ + 21.9, 9.4, -681, -66, -689, -78, -688, -79, -694, -91, -701, -87, -687, + -62 + ], + [21.9, 18.9, 713, 897, 714, 897, 700, 872, 693, 876, 707, 901], + [21.9, 19.2, 541, 837, 514, 852, 518, 859, 545, 844], + [21.9, 11.9, -366, 580, -380, 554, -390, 559, -375, 585], + [21.9, 18, 1358, 153, 1374, 144, 1370, 137, 1350, 148, 1354, 155], + [21.9, 7.6, 1369, 749, 1359, 730, 1353, 734, 1363, 752], + [ + 21.9, 13.7, -109, 1083, -125, 1055, -152, 1069, -150, 1071, -154, 1073, + -139, 1100 + ], + [ + 21.9, 7.3, -1080, -586, -1087, -598, -1094, -594, -1084, -578, -1078, -581 + ], + [21.9, 3.4, -1436, 230, -1432, 236, -1408, 223, -1411, 216], + [ + 22, 6.7, -1181, -651, -1184, -658, -1186, -658, -1193, -671, -1192, -671, + -1196, -678, -1201, -675, -1202, -679, -1208, -676, -1204, -669, -1203, + -669, -1194, -653, -1195, -652, -1191, -646 + ], + [22, 2.4, -1458, -150, -1466, -165, -1473, -161, -1465, -146], + [22, 18.6, 515, 1007, 500, 980, 492, 985, 507, 1011], + [ + 22, 7.3, -1017, -483, -1023, -494, -1025, -493, -1030, -505, -1036, -502, + -1030, -494, -1028, -491, -1030, -490, -1024, -479 + ], + [22, 11.9, -445, -1142, -457, -1163, -464, -1160, -452, -1139], + [ + 22, 4.9, -1292, -101, -1279, -108, -1286, -121, -1312, -106, -1307, -98, + -1305, -99, -1303, -95 + ], + [22, 21, 553, 16, 543, -2, 539, 0, 537, -4, 534, -2, 546, 20], + [ + 22, 13.1, 700, -104, 688, -124, 683, -122, 691, -108, 693, -109, 696, + -105, 697, -105, 698, -103 + ], + [ + 22, 8.8, 404, -1024, 401, -1030, 394, -1037, 396, -1037, 391, -1044, 393, + -1044, 391, -1048, 383, -1043, 390, -1031, 393, -1030, 393, -1025, 396, + -1020 + ], + [22, 11.6, 94, -290, 91, -298, 66, -284, 70, -276], + [22, 2.7, -1498, -128, -1507, -143, -1513, -140, -1504, -125], + [22, 20.1, 468, -73, 460, -88, 454, -84, 462, -70], + [22, 2.4, -1451, -154, -1460, -168, -1466, -165, -1458, -150], + [22, 15.5, 292, -155, 278, -181, 269, -176, 283, -150], + [ + 22.1, 14, -171, 1417, -173, 1413, -176, 1414, -181, 1406, -178, 1404, + -182, 1397, -195, 1405, -191, 1411, -187, 1409, -186, 1412, -183, 1418, + -186, 1420, -182, 1427, -169, 1419 + ], + [22.1, 4.6, -1402, 390, -1389, 414, -1376, 407, -1389, 383], + [22.1, 23.8, 410, 152, 396, 126, 390, 130, 401, 149, 405, 147, 408, 153], + [22.1, 7.6, -753, 1328, -740, 1320, -743, 1314, -761, 1324, -758, 1331], + [22.1, 10.1, 269, -466, 255, -491, 245, -485, 259, -460], + [ + 22.1, 9.4, -953, -1072, -962, -1083, -960, -1084, -962, -1087, -963, + -1087, -966, -1095, -972, -1092, -967, -1084, -966, -1081, -965, -1081, + -963, -1078, -960, -1069 + ], + [ + 22.1, 11.6, -411, -89, -423, -116, -430, -113, -431, -115, -444, -109, + -448, -117, -455, -114, -450, -102, -457, -99, -443, -72 + ], + [22.1, 14, -199, 196, -200, 186, -215, 194, -212, 199], + [22.1, 19.2, 514, -53, 501, -77, 498, -75, 504, -67, 500, -64, 508, -50], + [22.1, 12.2, -223, -832, -235, -853, -248, -846, -237, -825], + [22.1, 9.4, -694, -91, -666, -38, -652, -46, -681, -98], + [22.1, 15.5, -232, 774, -225, 770, -240, 744, -247, 748], + [22.1, 12.2, -359, -425, -371, -448, -378, -444, -365, -422], + [22.1, 15.2, -43, 1316, -17, 1301, -32, 1275, -58, 1289], + [ + 22.2, 10.1, -77, -1388, -86, -1404, -93, -1401, -87, -1390, -85, -1391, + -81, -1385, -83, -1384, -81, -1379, -79, -1379, -78, -1377, -75, -1379, + -76, -1381, -74, -1382 + ], + [ + 22.2, 7.9, -892, -418, -896, -426, -931, -406, -927, -399, -925, -400, + -917, -385, -903, -392, -908, -400, -903, -403, -899, -394, -885, -402, + -894, -417 + ], + [22.2, 14.3, -43, -25, -57, -51, -64, -47, -50, -21], + [ + 22.2, 11.9, -439, 1091, -452, 1071, -454, 1072, -459, 1063, -457, 1062, + -460, 1057, -465, 1060, -463, 1062, -476, 1070, -478, 1067, -483, 1070, + -480, 1075, -478, 1074, -474, 1082, -476, 1084, -468, 1098, -465, 1096, + -463, 1099, -461, 1098, -459, 1101 + ], + [22.2, 10.4, -672, -266, -678, -279, -704, -264, -697, -252], + [ + 22.2, 11, -157, -1338, -137, -1349, -149, -1370, -164, -1362, -161, -1358, + -164, -1356, -161, -1351, -166, -1348, -168, -1350, -171, -1348, -163, + -1335 + ], + [ + 22.2, 5.8, 111, -1107, 108, -1113, 103, -1112, 100, -1117, 98, -1121, 103, + -1122, 99, -1129, 83, -1120, 86, -1114, 91, -1117, 92, -1115, 95, -1108, + 92, -1105, 95, -1098 + ], + [ + 22.2, 11, -712, -419, -720, -434, -742, -421, -730, -399, -710, -410, + -714, -417 + ], + [ + 22.2, 8.8, 396, -1020, 393, -1025, 389, -1027, 388, -1030, 390, -1031, + 383, -1043, 375, -1039, 377, -1036, 379, -1036, 382, -1030, 383, -1031, + 382, -1029, 388, -1016 + ], + [22.2, 9.4, 834, -89, 822, -110, 802, -99, 815, -75, 835, -86], + [ + 22.3, 9.8, 413, -991, 409, -997, 408, -996, 405, -1001, 404, -1001, 402, + -1005, 403, -1005, 402, -1007, 403, -1008, 400, -1014, 393, -1010, 394, + -1009, 390, -1007, 402, -985 + ], + [ + 22.3, 11.3, 501, -250, 507, -253, 506, -255, 516, -261, 512, -267, 502, + -262, 501, -264, 495, -260 + ], + [22.3, 18.9, 533, 824, 530, 818, 504, 832, 507, 838], + [ + 22.3, 7.9, 45, -1125, 39, -1133, 32, -1130, 44, -1108, 47, -1110, 45, + -1114, 50, -1116 + ], + [22.3, 13.4, -74, 1169, -81, 1155, -111, 1172, -96, 1198, -67, 1182], + [ + 22.3, 10.4, -588, 87, -589, 82, -583, 79, -604, 41, -622, 52, -601, 89, + -597, 87, -593, 90 + ], + [22.3, 11.3, -445, -121, -453, -135, -462, -129, -455, -116], + [22.3, 7.3, -1115, -798, -1132, -827, -1145, -820, -1128, -791], + [22.3, 11.6, -543, -1458, -555, -1480, -569, -1473, -556, -1450], + [ + 22.3, 11.3, 310, -790, 339, -806, 335, -812, 323, -806, 324, -805, 321, + -803, 320, -804, 308, -798, 309, -796, 306, -795, 309, -789 + ], + [22.3, 11.9, -384, -744, -398, -768, -405, -764, -391, -739], + [ + 22.3, 3.4, -1412, -176, -1426, -201, -1431, -198, -1427, -192, -1429, + -191, -1419, -172 + ], + [22.3, 18.3, 455, 855, 442, 831, 435, 835, 446, 853, 447, 852, 450, 859], + [22.3, 20.4, 710, 983, 699, 962, 691, 966, 703, 988], + [ + 22.4, 8.8, 407, -468, 400, -464, 403, -460, 396, -456, 393, -460, 386, + -456, 393, -444, 414, -456 + ], + [22.4, 11.6, -490, -225, -504, -250, -530, -236, -516, -210], + [ + 22.4, 20.4, 720, 1346, 717, 1341, 713, 1343, 701, 1322, 686, 1332, 700, + 1357 + ], + [ + 22.4, 9.1, -932, -918, -940, -932, -958, -923, -945, -900, -930, -908, + -935, -916 + ], + [22.4, 10.4, -672, 107, -685, 83, -696, 89, -682, 112], + [ + 22.4, 4, -1481, 232, -1480, 233, -1461, 222, -1474, 199, -1476, 200, + -1477, 198, -1480, 199, -1479, 202, -1493, 210 + ], + [22.4, 8.8, -764, -465, -778, -491, -786, -487, -771, -461], + [22.4, 19.5, 641, 108, 630, 87, 625, 89, 637, 110], + [ + 22.5, 9.4, -91, -1093, -92, -1095, -90, -1097, -88, -1095, -80, -1099, + -83, -1106, -104, -1095, -100, -1088 + ], + [22.5, 17.7, 631, 796, 620, 776, 614, 780, 625, 800], + [22.5, 15.5, 187, 1278, 184, 1272, 157, 1287, 161, 1293], + [22.5, 22.9, 490, 229, 481, 212, 478, 213, 476, 206, 471, 207, 485, 232], + [ + 22.5, 9.4, -921, -1156, -948, -1141, -950, -1144, -955, -1141, -947, + -1127, -915, -1144 + ], + [22.5, 19.8, 98, 358, 84, 333, 79, 334, 78, 336, 92, 361], + [ + 22.5, 8.5, 735, -207, 732, -214, 720, -205, 719, -206, 709, -201, 713, + -194 + ], + [ + 22.5, 8.8, -949, -908, -958, -923, -975, -913, -963, -891, -947, -899, + -952, -907 + ], + [22.6, 12.2, -235, -1429, -247, -1451, -264, -1442, -252, -1419], + [22.6, 7.9, -1093, 85, -1083, 103, -1077, 100, -1088, 82], + [22.6, 10.4, -624, -620, -640, -611, -636, -604, -620, -613], + [22.6, 14.9, -204, 1388, -212, 1374, -225, 1381, -215, 1399, -202, 1392], + [22.6, 13.7, -184, 1064, -198, 1039, -231, 1057, -216, 1084, -183, 1066], + [ + 22.6, 8.5, 405, -510, 401, -517, 390, -511, 406, -489, 411, -492, 404, + -508, 405, -509 + ], + [22.6, 13.1, -192, 1121, -171, 1109, -183, 1087, -221, 1108, -208, 1130], + [22.6, 11.6, -705, 767, -719, 775, -704, 801, -691, 793], + [ + 22.6, 7.9, -1228, -1019, -1238, -1036, -1244, -1033, -1232, -1010, -1225, + -1014 + ], + [ + 22.6, 5.2, 435, -1262, 449, -1238, 461, -1245, 457, -1251, 459, -1253, + 485, -1267, 474, -1286, 434, -1264 + ], + [ + 22.6, 6.4, -991, -305, -995, -311, -996, -311, -1001, -319, -1002, -318, + -1002, -321, -1001, -322, -1004, -328, -1015, -322, -1011, -316, -1008, + -317, -1008, -316, -1009, -315, -1004, -306, -1005, -305, -1002, -299 + ], + [ + 22.6, 4.9, -1416, -359, -1420, -365, -1422, -364, -1443, -402, -1483, + -379, -1476, -366, -1472, -368, -1471, -366, -1462, -371, -1453, -355, + -1441, -359, -1439, -355, -1441, -354, -1439, -351, -1444, -349, -1439, + -340, -1415, -354, -1418, -358 + ], + [22.6, 7.9, -1232, -1010, -1244, -1033, -1251, -1029, -1238, -1007], + [22.6, 11.9, 369, -750, 365, -757, 333, -740, 337, -733], + [22.6, 13.1, -296, 204, -312, 175, -325, 183, -309, 212], + [22.6, 9.8, -607, 410, -593, 438, -582, 431, -597, 404], + [22.6, 9.8, -742, -1171, -749, -1167, -741, -1153, -734, -1156], + [22.7, 11.9, -519, -796, -532, -819, -540, -815, -526, -792], + [22.7, 19.8, 637, 110, 625, 89, 621, 92, 634, 116, 639, 114], + [ + 22.7, 9.1, -11, -1297, -20, -1311, -19, -1311, -24, -1321, -32, -1317, + -27, -1307, -25, -1308, -24, -1305, -25, -1304, -19, -1292 + ], + [22.7, 9.8, -628, 938, -635, 926, -645, 930, -638, 943], + [ + 22.7, 12.8, -441, 1480, -456, 1453, -459, 1454, -458, 1455, -461, 1457, + -447, 1483 + ], + [22.7, 12.5, -1049, 868, -1089, 890, -1075, 916, -1035, 894], + [22.7, 14.3, -101, 7, -115, -19, -142, -4, -128, 22], + [22.7, 23.5, 472, 387, 464, 373, 439, 386, 446, 400], + [ + 22.7, 5.2, 315, -1227, 310, -1237, 305, -1234, 306, -1232, 298, -1227, + 297, -1229, 291, -1226, 299, -1210, 319, -1221 + ], + [ + 22.7, 16.2, -254, 1518, -267, 1494, -279, 1501, -270, 1513, -271, 1515, + -265, 1526, -259, 1523, -258, 1525, -252, 1522 + ], + [ + 22.7, 7.6, -1026, -687, -1038, -709, -1051, -701, -1038, -676, -1024, -684 + ], + [22.7, 17.4, -23, 573, -10, 596, -1, 591, -14, 568], + [ + 22.7, 23.8, 430, 172, 421, 155, 419, 156, 416, 153, 414, 154, 413, 156, + 424, 176 + ], + [22.7, 13.7, 222, -172, 218, -178, 193, -164, 197, -158], + [ + 22.8, 9.8, -61, -1279, -62, -1281, -48, -1287, -49, -1289, -47, -1290, + -48, -1293, -51, -1292, -51, -1293, -62, -1287, -73, -1282, -69, -1275 + ], + [ + 22.8, 11.3, -658, -432, -674, -459, -680, -456, -674, -445, -673, -446, + -665, -428 + ], + [22.8, 8.5, -1016, -912, -1029, -936, -1034, -933, -1021, -909], + [22.8, 16.5, 10, 70, 3, 73, 22, 107, 29, 104], + [22.8, 10.1, -770, -1225, -782, -1247, -789, -1243, -777, -1221], + [ + 22.8, 10.4, -719, -1212, -728, -1227, -734, -1224, -722, -1201, -715, + -1205 + ], + [22.8, 13.1, -983, 815, -991, 802, -998, 806, -984, 830, -977, 826], + [22.8, 14.9, -38, 61, -52, 37, -72, 48, -59, 72, -48, 65, -47, 67], + [22.8, 11.6, -535, -874, -547, -896, -556, -890, -543, -866, -533, -872], + [22.8, 9.4, -60, -1188, -80, -1222, -88, -1217, -69, -1183], + [22.9, 18.9, 700, 905, 686, 880, 680, 883, 694, 908], + [22.9, 12.2, -360, 419, -365, 410, -381, 418, -376, 428], + [22.9, 18.3, 1270, 222, 1257, 200, 1243, 208, 1256, 230], + [ + 22.9, 8.8, -1032, -80, -1011, -42, -975, -62, -979, -69, -968, -75, -964, + -68, -948, -77, -969, -115 + ], + [22.9, 11, -456, 544, -472, 515, -482, 521, -466, 550], + [22.9, 11, -614, -916, -626, -937, -632, -933, -620, -912], + [22.9, 11.6, 114, -507, 101, -530, 90, -524, 103, -501], + [ + 22.9, 16.2, -198, 789, -211, 766, -230, 777, -232, 774, -241, 779, -227, + 805 + ], + [ + 22.9, 9.1, -865, -910, -878, -933, -889, -927, -885, -919, -886, -918, + -878, -903 + ], + [22.9, 11, -620, -912, -632, -933, -639, -929, -627, -908], + [ + 22.9, 12.5, -467, 1494, -480, 1472, -485, 1475, -482, 1481, -481, 1483, + -483, 1484, -487, 1474, -493, 1478, -487, 1486, -488, 1487, -480, 1501 + ], + [22.9, 15.2, -198, 1039, -212, 1012, -233, 1023, -218, 1050], + [22.9, 18.6, 490, 965, 477, 941, 472, 944, 485, 968], + [22.9, 12.2, -428, 1110, -438, 1093, -458, 1104, -448, 1121], + [ + 22.9, 9.1, -858, -1176, -873, -1203, -877, -1201, -874, -1197, -880, + -1194, -867, -1171 + ], + [22.9, 7.9, -1221, -977, -1208, -984, -1217, -999, -1229, -992], + [ + 22.9, 16.5, -120, 695, -126, 696, -132, 685, -145, 693, -135, 711, -128, + 708, -126, 712, -119, 708, -123, 702, -116, 701 + ], + [22.9, 9.8, -850, -1027, -857, -1039, -882, -1026, -875, -1014], + [22.9, 7.3, 149, -1251, 140, -1268, 121, -1258, 131, -1241], + [ + 23, 11, -79, -664, -67, -671, -72, -680, -63, -685, -58, -676, -45, -683, + -59, -708, -98, -687, -97, -686, -98, -685, -94, -676, -92, -677, -84, + -662 + ], + [ + 23, 11, -653, -437, -662, -450, -660, -451, -667, -463, -674, -459, -658, + -432, -652, -435 + ], + [ + 23, 11.9, -971, 258, -978, 246, -990, 253, -981, 268, -978, 266, -977, + 267, -969, 262 + ], + [23, 6.7, 173, -1230, 161, -1251, 154, -1246, 162, -1235, 165, -1225], + [23, 18.3, 719, 96, 699, 108, 702, 114, 723, 102], + [ + 23, 6.7, 182, -1234, 172, -1247, 172, -1251, 170, -1255, 161, -1251, 173, + -1230 + ], + [23, 10.7, -696, -1039, -708, -1061, -715, -1057, -703, -1035], + [23, 8.5, -1010, -915, -1024, -939, -1029, -936, -1016, -912], + [23, 12.8, -231, -428, -235, -434, -256, -423, -255, -415, -232, -427], + [23, 13.1, -313, -186, -320, -199, -347, -184, -340, -172], + [ + 23, 17.1, -102, 706, -107, 686, -122, 689, -126, 691, -125, 694, -121, + 692, -116, 701, -123, 702, -119, 708, -126, 712 + ], + [23, 9.4, -837, -707, -849, -729, -856, -725, -843, -703], + [23, 18.6, 41, 211, 28, 187, 23, 190, 36, 214], + [23.1, 11, -604, -749, -616, -773, -629, -766, -616, -743], + [23.1, 21, 191, 448, 178, 424, 171, 428, 184, 452], + [ + 23.1, 12.8, -443, -1184, -453, -1202, -459, -1198, -449, -1179, -443, + -1183 + ], + [23.1, 11, -701, -414, -714, -437, -720, -434, -707, -410], + [23.1, 18.6, 455, 948, 442, 924, 435, 928, 448, 952], + [23.1, 9.4, -820, -716, -832, -738, -849, -729, -837, -707], + [23.1, 10.4, 441, -560, 427, -585, 421, -582, 435, -557], + [23.1, 14.6, -90, 91, -104, 64, -111, 68, -96, 94], + [ + 23.1, 16.2, 130, 1345, 122, 1329, 140, 1319, 136, 1311, 104, 1328, 112, + 1352, 116, 1353 + ], + [ + 23.2, 13.1, 805, 145, 801, 137, 799, 139, 791, 125, 782, 129, 790, 143, + 788, 145, 792, 153 + ], + [ + 23.2, 12.5, -454, -1172, -466, -1194, -473, -1191, -458, -1165, -452, + -1169 + ], + [23.2, 11.6, -242, -1148, -249, -1145, -238, -1124, -231, -1127], + [23.2, 13.1, -329, 1097, -304, 1083, -313, 1067, -339, 1082], + [ + 23.2, 11, -615, -1416, -647, -1471, -653, -1468, -638, -1441, -640, -1440, + -624, -1411 + ], + [23.2, 9.8, 229, -801, 225, -809, 214, -804, 219, -796], + [ + 23.2, 5.8, -1169, -344, -1160, -349, -1161, -351, -1163, -350, -1174, + -373, -1190, -365, -1187, -361, -1186, -362, -1176, -343, -1172, -346 + ], + [23.2, 17.7, 320, -136, 311, -153, 305, -150, 314, -133], + [23.2, 10.7, -605, -288, -618, -312, -626, -307, -613, -284], + [ + 23.2, 15.2, 130, 1073, 120, 1053, 118, 1054, 115, 1049, 109, 1052, 122, + 1077 + ], + [ + 23.2, 8.5, -822, -170, -824, -175, -826, -175, -826, -179, -829, -184, + -831, -184, -834, -192, -840, -188, -834, -178, -833, -178, -832, -176, + -828, -166 + ], + [ + 23.2, 16.5, 117, 962, 114, 957, 111, 959, 96, 932, 84, 939, 99, 965, 91, + 969, 106, 996, 128, 984 + ], + [23.2, 9.1, -878, -903, -890, -925, -896, -921, -884, -900], + [23.2, 18.9, 37, 392, 24, 368, 13, 374, 26, 398], + [23.2, 11.3, -574, -765, -588, -789, -616, -773, -603, -749], + [23.2, 18.9, 923, 978, 916, 966, 895, 978, 910, 1004, 920, 998, 912, 984], + [ + 23.2, 12.8, -77, -219, -53, -232, -57, -239, -89, -221, -90, -219, -87, + -215 + ], + [23.2, 11, -425, -659, -437, -680, -449, -673, -436, -651, -425, -658], + [23.2, 18, 46, 208, 32, 182, 27, 185, 41, 211], + [ + 23.2, 9.4, 365, -527, 368, -528, 365, -532, 349, -523, 355, -513, 366, + -519, 362, -525 + ], + [ + 23.2, 10.4, -739, -1014, -742, -1019, -746, -1016, -756, -1034, -783, + -1020, -770, -997 + ], + [23.3, 18.9, 367, 907, 353, 880, 347, 884, 361, 910], + [ + 23.3, 11.6, 491, -677, 478, -701, 468, -696, 467, -698, 464, -697, 479, + -670 + ], + [23.3, 9.4, 374, -950, 384, -932, 397, -939, 388, -957], + [ + 23.3, 13.4, -237, 1087, -234, 1085, -231, 1092, -216, 1084, -231, 1057, + -271, 1079, -264, 1093, -241, 1080 + ], + [23.3, 9.1, 477, -492, 463, -516, 426, -495, 440, -470], + [23.3, 20.4, 683, 976, 687, 974, 684, 969, 657, 983, 660, 989], + [23.3, 9.1, -855, -1284, -871, -1311, -877, -1308, -862, -1280], + [23.3, 9.1, -800, -777, -812, -799, -818, -796, -806, -774], + [23.3, 11, -517, -759, -530, -782, -539, -778, -526, -755], + [ + 23.3, 11, -586, -895, -614, -944, -626, -937, -614, -916, -611, -917, + -608, -912, -611, -910, -598, -888 + ], + [23.3, 14.3, -104, 61, -117, 37, -134, 46, -121, 70], + [ + 23.3, 7.3, 708, -411, 704, -417, 684, -405, 687, -400, 690, -400, 698, + -384, 705, -388, 698, -401, 700, -402, 701, -403, 709, -390, 716, -393, + 706, -409 + ], + [ + 23.3, 12.5, -301, -167, -308, -180, -315, -176, -318, -183, -340, -172, + -332, -157 + ], + [ + 23.3, 17.4, -70, 595, -63, 591, -67, 585, -82, 593, -96, 601, -94, 608, + -79, 600 + ], + [23.3, 14.6, -201, 344, -214, 320, -225, 327, -212, 351], + [ + 23.3, 7.3, 687, -400, 683, -406, 673, -400, 676, -394, 679, -395, 688, + -378, 695, -382, 685, -398 + ], + [23.3, 11.3, -504, -767, -517, -790, -530, -782, -517, -759], + [23.4, 11.3, -570, -946, -579, -963, -586, -959, -576, -942], + [ + 23.4, 6.1, 372, -1469, 364, -1484, 311, -1455, 333, -1418, 335, -1420, + 342, -1408, 389, -1434, 385, -1441, 387, -1442 + ], + [23.4, 13.4, 691, -108, 683, -122, 678, -119, 685, -105], + [23.4, 11.3, -533, -751, -546, -774, -551, -771, -538, -748], + [ + 23.4, 5.5, 796, -251, 792, -255, 785, -269, 775, -263, 778, -258, 780, + -259, 787, -247, 785, -246, 788, -240, 799, -246 + ], + [23.4, 12.5, -379, -26, -390, -46, -401, -40, -386, -14, -375, -20], + [ + 23.4, 9.1, -48, -1287, -52, -1284, -51, -1282, -52, -1281, -54, -1283, + -57, -1282, -56, -1281, -69, -1275, -65, -1268, -42, -1280, -46, -1288 + ], + [23.4, 20.4, 119, 219, 106, 195, 99, 199, 112, 223], + [23.4, 12.5, -732, 693, -747, 667, -756, 672, -741, 698], + [23.4, 21.3, 414, 610, 381, 628, 396, 654, 429, 636], + [23.4, 8.5, 350, -1046, 336, -1070, 330, -1066, 343, -1042], + [ + 23.4, 3, -1379, -194, -1388, -210, -1393, -207, -1394, -209, -1401, -205, + -1392, -187 + ], + [23.4, 10.4, -690, -1043, -701, -1064, -708, -1061, -696, -1039], + [23.4, 11.3, -511, 1337, -525, 1311, -538, 1319, -524, 1344], + [ + 23.4, 14, -321, 1052, -332, 1031, -359, 1046, -361, 1043, -368, 1047, + -355, 1070 + ], + [23.4, 20.1, 189, 86, 185, 80, 162, 93, 166, 99], + [23.4, 11, -592, -296, -605, -319, -613, -314, -600, -291], + [ + 23.5, 10.4, 1356, 786, 1353, 780, 1343, 786, 1346, 793, 1348, 792, 1356, + 805, 1358, 804, 1365, 805, 1356, 789, 1358, 788 + ], + [ + 23.5, 6.1, -1165, -357, -1161, -359, -1160, -358, -1158, -360, -1157, + -358, -1145, -365, -1146, -372, -1153, -385, -1169, -376, -1167, -372, + -1172, -370 + ], + [23.5, 11.3, -594, -346, -608, -372, -614, -368, -600, -342], + [23.5, 16.5, 638, -80, 630, -94, 624, -91, 637, -67, 642, -70, 636, -79], + [23.5, 14.9, -59, 72, -73, 47, -78, 50, -77, 52, -84, 56, -71, 80], + [23.5, 11.6, -393, -784, -368, -798, -374, -809, -400, -795, -394, -783], + [ + 23.5, 11.3, -641, -447, -654, -470, -667, -463, -660, -451, -658, -452, + -654, -446, -657, -445, -653, -437, -639, -444 + ], + [ + 23.5, 9.4, 464, -529, 462, -533, 467, -536, 459, -550, 449, -543, 459, + -526 + ], + [23.5, 11.6, -896, 268, -907, 247, -934, 262, -923, 283], + [ + 23.5, 9.4, -697, -189, -731, -249, -766, -230, -740, -181, -731, -186, + -732, -189, -730, -190, -721, -176 + ], + [23.5, 11.6, -638, -410, -649, -430, -662, -423, -651, -403], + [ + 23.5, 18, 231, -1352, 224, -1365, 199, -1350, 202, -1344, 199, -1343, 203, + -1336 + ], + [23.5, 5.2, -1374, -545, -1385, -566, -1398, -558, -1387, -538], + [23.5, 7.6, 1435, 653, 1457, 641, 1453, 635, 1428, 649, 1432, 655], + [23.5, 23.2, 439, 436, 429, 418, 422, 422, 432, 440], + [23.5, 21.3, 549, 72, 536, 49, 530, 52, 538, 68, 543, 66, 547, 76, 550, 74], + [23.5, 9.8, -559, 623, -586, 638, -583, 644, -556, 630], + [ + 23.5, 10.7, 1340, 811, 1349, 805, 1348, 803, 1351, 801, 1343, 787, 1327, + 795, 1335, 810, 1339, 808 + ], + [23.5, 21.6, 555, 69, 542, 46, 536, 49, 549, 72], + [23.5, 10.4, -702, -1001, -728, -1050, -735, -1046, -708, -997], + [ + 23.5, 11, -595, -1427, -615, -1464, -627, -1458, -637, -1476, -647, -1471, + -615, -1416 + ], + [23.5, 10.7, 279, -509, 266, -532, 253, -524, 265, -501], + [23.6, 20.1, 141, 334, 128, 310, 121, 314, 134, 338], + [ + 23.6, 8.8, -1048, -1015, -1043, -1017, -1058, -1045, -1079, -1033, -1064, + -1006 + ], + [23.6, 9.4, -747, 160, -751, 154, -777, 168, -774, 175], + [ + 23.6, 23.8, 380, 75, 344, 95, 350, 105, 353, 103, 355, 106, 348, 111, 355, + 124, 385, 108, 384, 106, 394, 101 + ], + [23.6, 13.1, 218, -178, 215, -185, 190, -171, 193, -164], + [ + 23.6, 15.8, -127, 941, -140, 916, -150, 921, -165, 895, -170, 898, -156, + 924, -173, 934, -157, 961, -125, 943 + ], + [23.6, 19.8, 780, 985, 771, 969, 768, 970, 777, 987], + [ + 23.6, 9.4, 802, -158, 789, -182, 762, -167, 775, -145, 777, -146, 779, + -143, 777, -141, 792, -114, 811, -125, 804, -138, 811, -142 + ], + [23.6, 18.3, 559, 712, 562, 710, 547, 683, 541, 686, 556, 713], + [ + 23.6, 10.1, -556, 669, -560, 663, -543, 653, -547, 646, -573, 661, -566, + 674 + ], + [ + 23.6, 8.2, -1049, -978, -1057, -993, -1059, -991, -1060, -993, -1061, + -992, -1060, -990, -1070, -985, -1074, -991, -1100, -977, -1089, -956 + ], + [23.6, 12.5, -398, -853, -402, -860, -431, -844, -427, -837], + [23.6, 12.2, -253, -1421, -266, -1444, -275, -1439, -262, -1416], + [ + 23.7, 20.4, 874, 1205, 864, 1187, 860, 1189, 855, 1181, 851, 1183, 866, + 1210 + ], + [ + 23.7, 13.1, -304, -185, -306, -190, -300, -193, -311, -213, -324, -206, + -310, -181 + ], + [23.7, 19.8, 185, 80, 182, 73, 158, 86, 162, 93], + [ + 23.7, 2.7, -1502, 53, -1508, 43, -1535, 57, -1523, 78, -1517, 75, -1523, + 64 + ], + [ + 23.7, 8.2, -858, -110, -872, -135, -901, -119, -890, -98, -887, -99, -885, + -95 + ], + [ + 23.7, 11.3, -271, 1205, -286, 1178, -296, 1184, -295, 1187, -305, 1193, + -306, 1191, -309, 1193, -309, 1191, -320, 1197, -318, 1200, -320, 1201, + -306, 1224 + ], + [23.7, 9.8, -579, 1041, -588, 1026, -605, 1042, -599, 1052], + [ + 23.7, 20.1, 777, 987, 763, 962, 753, 968, 750, 962, 738, 967, 745, 980, + 756, 974, 766, 993 + ], + [23.7, 21, 184, 489, 175, 472, 173, 473, 169, 465, 163, 469, 177, 493], + [23.7, 10.1, -835, -906, -808, -858, -768, -880, -795, -928], + [23.7, 8.8, -886, -645, -893, -657, -915, -645, -909, -633], + [ + 23.7, 10.4, -139, -1197, -143, -1204, -156, -1197, -152, -1189, -151, + -1190, -146, -1180, -144, -1180, -142, -1176, -133, -1182, -135, -1185, + -134, -1187, -140, -1196 + ], + [23.8, 8.5, 340, -539, 355, -547, 352, -552, 337, -544], + [ + 23.8, 13.1, -442, -1250, -413, -1266, -417, -1274, -455, -1253, -451, + -1245 + ], + [23.8, 15.8, 142, -39, 126, -68, 112, -60, 128, -31], + [ + 23.8, 3.7, -1573, -279, -1567, -269, -1548, -279, -1555, -291, -1568, + -284, -1567, -282 + ], + [ + 23.8, 6.7, -1073, -602, -1074, -605, -1080, -601, -1073, -589, -1067, -593 + ], + [23.8, 12.8, -429, -1188, -439, -1209, -447, -1205, -436, -1186], + [ + 23.8, 9.1, -846, -926, -856, -944, -862, -941, -876, -968, -897, -956, + -886, -937, -881, -940, -880, -938, -875, -941, -860, -913, -844, -922 + ], + [23.8, 20.7, 203, 104, 199, 97, 173, 112, 177, 119], + [ + 23.8, 8.2, 1412, 480, 1422, 498, 1429, 494, 1432, 500, 1459, 485, 1455, + 477, 1461, 474, 1452, 457, 1446, 460, 1444, 459, 1425, 470, 1427, 474, + 1433, 471, 1442, 487, 1431, 494, 1419, 472, 1411, 478 + ], + [23.8, 20.7, 199, 97, 206, 94, 202, 87, 169, 106, 173, 112], + [23.8, 6.7, 241, -1105, 237, -1111, 211, -1096, 214, -1090], + [23.8, 15.5, -223, 1416, -209, 1442, -196, 1434, -210, 1409], + [ + 23.8, 7.9, 713, -542, 728, -549, 720, -562, 707, -552, 698, -549, 705, + -536 + ], + [23.8, 18.3, 565, 696, 555, 679, 547, 683, 562, 710, 570, 705], + [23.9, 7.9, -798, 35, -803, 25, -805, 27, -809, 17, -831, 29, -822, 48], + [ + 23.9, 10.7, 294, -747, 283, -764, 284, -765, 281, -770, 274, -767, 278, + -760, 276, -759, 272, -766, 265, -762, 268, -756, 270, -756, 278, -738 + ], + [23.9, 11.9, -374, -809, -377, -816, -404, -801, -400, -795], + [ + 23.9, 12.2, -157, -418, -181, -405, -180, -403, -183, -401, -194, -423, + -201, -419, -186, -393, -153, -411 + ], + [ + 23.9, 12.8, -423, -1194, -432, -1213, -439, -1209, -429, -1188, -422, + -1190 + ], + [ + 23.9, 11, 205, -609, 200, -619, 195, -616, 194, -618, 193, -621, 197, + -623, 192, -633, 181, -627, 186, -618, 188, -619, 192, -613, 189, -612, + 194, -603 + ], + [23.9, 7.3, 140, -1268, 137, -1274, 118, -1263, 121, -1258], + [23.9, 19.5, 910, 1273, 897, 1250, 887, 1256, 901, 1280, 911, 1275], + [23.9, 10.1, -664, 1422, -678, 1395, -685, 1399, -671, 1425], + [23.9, 11.6, -235, -1088, -247, -1111, -254, -1107, -242, -1084], + [ + 23.9, 12.8, -400, -483, -390, -470, -392, -469, -388, -461, -381, -465, + -390, -478, -389, -480, -393, -487 + ], + [24, 17.4, 112, 903, 96, 873, 75, 885, 91, 914], + [24, 13.1, -421, -1195, -415, -1196, -426, -1216, -432, -1213, -423, -1194], + [24, 13.1, -310, -323, -325, -348, -331, -344, -318, -320], + [24, 11.3, -536, -228, -524, -205, -517, -209, -530, -233, -537, -229], + [24, 12.5, -488, -375, -491, -382, -518, -367, -514, -361], + [24, 9.4, -783, -1218, -798, -1245, -812, -1237, -796, -1210], + [24, 21, 650, 1034, 645, 1025, 618, 1040, 623, 1049], + [24.1, 7.3, -1106, -640, -1112, -637, -1098, -612, -1093, -616], + [ + 24.1, 4, -1456, -584, -1470, -608, -1472, -607, -1470, -604, -1481, -598, + -1470, -577 + ], + [24.1, 12.5, -452, -194, -465, -217, -470, -214, -456, -189, -451, -192], + [ + 24.1, 22.6, 284, 110, 279, 100, 259, 111, 265, 123, 268, 121, 274, 131, + 289, 123, 283, 113, 285, 112 + ], + [24.1, 21.6, 462, 514, 448, 490, 442, 493, 455, 517], + [ + 24.1, 3, -857, 1243, -861, 1236, -863, 1237, -868, 1227, -866, 1226, -870, + 1220, -897, 1235, -884, 1258 + ], + [24.1, 18.9, 415, 916, 400, 889, 383, 898, 398, 925], + [ + 24.1, 10.4, -597, -197, -584, -173, -571, -180, -578, -191, -577, -191, + -585, -204 + ], + [24.1, 12.5, -446, -197, -459, -221, -465, -217, -452, -194], + [24.1, 19.2, 727, 922, 713, 897, 707, 901, 721, 926], + [ + 24.1, 6.4, -1070, -454, -1076, -464, -1078, -464, -1083, -476, -1090, + -472, -1087, -467, -1083, -465, -1081, -462, -1083, -461, -1081, -458, + -1077, -450 + ], + [ + 24.1, 10.4, 400, -633, 389, -651, 383, -650, 383, -645, 366, -675, 350, + -666, 368, -634, 362, -630, 369, -618, 367, -615, 369, -612, 371, -612, + 402, -629 + ], + [24.1, 11.6, -424, -721, -438, -746, -445, -742, -431, -717], + [ + 24.1, 18.9, 473, 929, 464, 912, 458, 915, 463, 924, 464, 923, 467, 928, + 466, 929, 471, 939, 477, 936 + ], + [ + 24.1, 7.3, -998, -583, -1002, -590, -1003, -589, -1011, -607, -1024, -600, + -1020, -593, -1018, -595, -1014, -587, -1013, -584, -1014, -583, -1011, + -576 + ], + [24.2, 9.4, 58, -795, 51, -808, 42, -803, 49, -790], + [24.2, 7.6, -994, -634, -1000, -645, -1007, -641, -1000, -629, -993, -632], + [ + 24.2, 8.2, -1087, -1069, -1079, -1055, -1074, -1058, -1083, -1076, -1089, + -1072 + ], + [24.2, 11.6, -537, -382, -548, -402, -559, -396, -546, -372, -535, -378], + [ + 24.2, 9.8, -659, -489, -666, -502, -668, -501, -673, -511, -676, -510, + -677, -513, -691, -505, -676, -479 + ], + [24.2, 13.1, -43, -214, -70, -199, -66, -191, -39, -206], + [ + 24.2, 7.9, 123, -1375, 142, -1384, 134, -1399, 103, -1382, 112, -1367, + 124, -1374 + ], + [24.3, 8.2, -780, -525, -794, -549, -799, -546, -786, -522], + [24.3, 12.2, -253, -593, -257, -601, -280, -589, -278, -579], + [24.3, 13.1, -8, -151, -12, -157, -38, -142, -35, -136], + [24.3, 10.4, -741, 966, -736, 962, -751, 937, -757, 940, -742, 967], + [24.3, 10.1, -589, -470, -579, -476, -594, -503, -607, -496, -592, -469], + [24.4, 10.7, 227, -620, 238, -627, 224, -653, 212, -646], + [24.4, 9.4, -1368, 793, -1313, 764, -1340, 727, -1347, 716, -1396, 743], + [24.4, 11.3, -536, -178, -522, -153, -508, -161, -522, -186], + [24.4, 23.5, 312, 303, 316, 301, 313, 295, 284, 311, 287, 317], + [24.4, 17.1, 311, -153, 305, -163, 301, -160, 306, -151], + [24.4, 12.5, -259, 1288, -274, 1262, -285, 1268, -271, 1295], + [24.4, 20.1, 881, 1330, 878, 1324, 854, 1337, 857, 1343], + [ + 24.4, 2.7, 778, -1321, 792, -1317, 825, -1259, 835, -1264, 802, -1323, + 799, -1321, 797, -1325, 786, -1326, 789, -1345, 777, -1347, 773, -1322 + ], + [ + 24.4, 6.4, -860, 1210, -867, 1214, -865, 1217, -870, 1219, -866, 1226, + -868, 1227, -863, 1237, -861, 1236, -857, 1243, -845, 1236 + ], + [ + 24.4, 12.2, -389, -1196, -442, -1180, -440, -1174, -423, -1178, -413, + -1160, -385, -1175 + ], + [ + 24.4, 16.8, 25, 912, 40, 904, 35, 895, 31, 898, 27, 891, 32, 888, 27, 880, + 11, 889, 16, 897, 20, 895, 23, 901, 19, 904, 24, 913 + ], + [ + 24.4, 11.3, -562, -1446, -593, -1501, -614, -1489, -609, -1480, -607, + -1480, -582, -1435 + ], + [ + 24.5, 11.6, -557, -1485, -542, -1493, -546, -1500, -573, -1485, -569, + -1478 + ], + [ + 24.5, 6.1, -1319, -744, -1325, -756, -1333, -751, -1334, -752, -1344, + -745, -1345, -746, -1350, -743, -1347, -737, -1349, -735, -1346, -729 + ], + [24.5, 10.7, -505, 512, -519, 486, -529, 492, -515, 518], + [24.5, 6.7, 265, -1102, 251, -1129, 233, -1119, 248, -1093], + [24.5, 21, 699, 996, 695, 989, 668, 1004, 672, 1011], + [24.5, 11.9, -505, -306, -518, -329, -529, -324, -515, -300], + [24.5, 4, -1379, -36, -1423, -11, -1408, 15, -1364, -10], + [24.6, 8.8, -874, -1274, -889, -1301, -895, -1297, -880, -1270], + [24.6, 7.6, 287, -1051, 275, -1073, 262, -1066, 276, -1041, 289, -1048], + [24.6, 12.8, -324, 1109, -339, 1082, -346, 1086, -331, 1112], + [24.6, 10.7, -582, -1435, -603, -1473, -610, -1469, -589, -1431], + [ + 24.6, 7.6, -974, -598, -976, -603, -978, -601, -981, -605, -985, -614, + -983, -615, -987, -621, -999, -614, -996, -609, -994, -610, -987, -597, + -989, -596, -986, -590, -973, -597 + ], + [24.6, 19.2, 687, 912, 674, 887, 666, 891, 680, 916], + [24.7, 9.4, -649, 4, -662, -19, -668, -16, -655, 8], + [ + 24.7, 13.4, -937, 557, -952, 533, -956, 535, -961, 527, -974, 534, -969, + 542, -971, 543, -966, 552, -967, 552, -958, 568 + ], + [ + 24.7, 6.4, 588, -1067, 596, -1052, 602, -1055, 602, -1053, 623, -1067, + 614, -1082 + ], + [ + 24.7, 7.6, -1091, -644, -1104, -637, -1101, -630, -1098, -632, -1093, + -623, -1096, -622, -1092, -615, -1079, -622, -1083, -629, -1088, -627, + -1089, -629, -1086, -631, -1088, -634, -1090, -634, -1091, -636, -1088, + -637 + ], + [24.7, 12.5, -335, -399, -347, -421, -354, -417, -342, -395], + [24.7, 11.9, -76, -415, -80, -422, -114, -403, -110, -396], + [24.7, 20.4, 701, 984, 691, 966, 684, 970, 694, 987], + [ + 24.8, 14.3, 1385, 164, 1381, 158, 1365, 167, 1366, 169, 1362, 171, 1363, + 172, 1360, 174, 1362, 177 + ], + [ + 24.8, 12.2, -376, 531, -388, 509, -378, 504, -383, 494, -400, 503, -382, + 534 + ], + [24.8, 10.4, -613, -246, -626, -270, -638, -263, -625, -239], + [24.8, 11.9, -498, -979, -476, -992, -480, -999, -506, -984, -502, -977], + [24.8, 19.8, 658, 921, 652, 911, 626, 926, 631, 936], + [ + 24.8, 11.6, 211, -468, 212, -470, 229, -479, 226, -486, 202, -474, 207, + -465 + ], + [ + 24.8, 5.8, -1155, -407, -1161, -418, -1159, -419, -1153, -408, -1146, + -412, -1153, -424, -1150, -425, -1144, -413, -1137, -417, -1145, -432, + -1171, -418, -1162, -403 + ], + [24.8, 11.9, -498, -1283, -522, -1327, -532, -1322, -508, -1277], + [24.8, 11.3, 321, -350, 307, -375, 301, -372, 316, -346], + [24.8, 13.7, -1081, 812, -1084, 806, -1110, 821, -1099, 841, -1073, 826], + [ + 24.8, 9.8, -8, -1518, -9, -1519, -4, -1521, -10, -1532, -25, -1523, -19, + -1511 + ], + [ + 24.9, 6.7, -1042, -559, -1046, -566, -1047, -565, -1057, -584, -1071, + -577, -1058, -551 + ], + [24.9, 17.7, 625, 800, 609, 774, 601, 779, 603, 783, 602, 784, 614, 806], + [24.9, 10.7, -150, -873, -163, -897, -169, -893, -156, -870], + [24.9, 10.1, -612, 111, -626, 85, -632, 89, -647, 62, -685, 83, -656, 135], + [ + 24.9, 11, -548, -402, -549, -404, -542, -409, -556, -435, -577, -423, + -564, -400, -557, -404, -554, -399 + ], + [24.9, 14, -171, 1322, -197, 1336, -197, 1337, -194, 1343, -168, 1328], + [25, 10.7, 1447, 401, 1434, 378, 1421, 386, 1433, 408], + [25, 7.6, 307, -1062, 294, -1084, 275, -1073, 287, -1051], + [ + 25, 15.8, 225, 1112, 221, 1103, 218, 1105, 214, 1098, 217, 1096, 212, + 1088, 203, 1094, 216, 1117 + ], + [25, 12.5, -228, -420, -231, -428, -255, -415, -253, -406, -229, -420], + [ + 25, 20.7, 617, 1075, 602, 1049, 592, 1054, 595, 1059, 588, 1063, 600, 1085 + ], + [25, 11, -544, 410, -558, 384, -564, 387, -550, 414], + [25, 8.2, 65, -924, 51, -949, 44, -945, 57, -920], + [25, 23.5, 473, 239, 459, 214, 446, 221, 459, 246], + [25, 11.3, -503, -71, -489, -47, -466, -59, -480, -83], + [ + 25, 16.8, -11, 1422, -15, 1415, -16, 1416, -23, 1404, -22, 1403, -24, + 1399, -35, 1405, -32, 1409, -31, 1408, -21, 1428 + ], + [25, 5.5, 417, -1514, 406, -1508, 414, -1494, 425, -1500], + [25, 12.8, -315, -409, -329, -435, -336, -431, -322, -406], + [ + 25, 11.9, 138, -354, 131, -367, 120, -361, 128, -347, 131, -348, 133, + -343, 137, -343, 141, -347, 137, -353 + ], + [ + 25, 10.1, 310, -855, 288, -843, 278, -862, 271, -858, 285, -832, 314, -847 + ], + [25, 11.3, 511, -688, 500, -708, 494, -704, 505, -684], + [25.1, 13.4, -129, -369, -133, -375, -157, -362, -153, -355], + [25.1, 19.2, 680, 916, 666, 891, 660, 895, 674, 919], + [25.1, 5.8, -1199, -294, -1213, -320, -1220, -316, -1205, -289], + [ + 25.1, 10.1, -636, -604, -640, -611, -624, -620, -649, -666, -704, -635, + -689, -609, -674, -617, -660, -591 + ], + [ + 25.1, 7.3, 583, -1091, 566, -1121, 564, -1120, 566, -1116, 559, -1112, + 568, -1097, 528, -1075, 530, -1072, 529, -1071, 531, -1066, 534, -1068, + 537, -1062, 542, -1065, 541, -1066, 577, -1084, 576, -1085, 580, -1087, + 578, -1090 + ], + [ + 25.1, 8.8, -1023, -1043, -1031, -1059, -1042, -1053, -1028, -1028, -1017, + -1034 + ], + [ + 25.1, 11.6, -685, 756, -689, 749, -692, 745, -694, 746, -695, 743, -694, + 742, -699, 730, -707, 734, -700, 745, -698, 744, -696, 752, -692, 760 + ], + [ + 25.2, 12.8, -390, -952, -385, -954, -386, -956, -376, -962, -381, -971, + -388, -967, -386, -965, -416, -948, -411, -940 + ], + [25.2, 11, 77, -448, 67, -466, 60, -462, 70, -445], + [25.3, 8.2, 57, -920, 44, -945, 36, -941, 50, -915, 58, -919], + [25.3, 8.5, -874, -506, -894, -496, -879, -470, -860, -481], + [25.3, 9.1, 387, -1018, 375, -1039, 370, -1036, 382, -1015], + [25.3, 11.3, 310, -356, 301, -372, 295, -369, 304, -352], + [25.3, 20.7, 468, 511, 454, 487, 448, 490, 462, 514], + [25.3, 11.3, -76, -543, -105, -594, -113, -589, -84, -538], + [25.3, 18.6, 1247, 228, 1238, 211, 1223, 219, 1233, 236], + [25.4, 12.5, 272, -386, 265, -399, 248, -390, 256, -377], + [25.4, 10.7, -661, -855, -678, -884, -723, -859, -705, -828, -661, -853], + [ + 25.4, 21.3, 841, 1189, 844, 1186, 840, 1179, 843, 1178, 832, 1159, 824, + 1163, 839, 1190 + ], + [25.4, 21.3, 546, 20, 535, 0, 529, 4, 539, 23], + [25.4, 11.9, -257, -1075, -270, -1097, -280, -1092, -268, -1070], + [25.4, 14.3, -187, 425, -201, 398, -220, 408, -205, 435], + [ + 25.4, 11, 503, -620, 483, -609, 493, -589, 522, -605, 516, -617, 510, + -614, 509, -616, 507, -615 + ], + [25.5, 21, 702, 1002, 675, 1017, 679, 1023, 706, 1008], + [ + 25.5, 9.1, -816, -1307, -846, -1361, -878, -1343, -848, -1287, -815, -1306 + ], + [25.5, 12.2, -415, 769, -410, 766, -418, 753, -428, 759, -421, 772], + [ + 25.5, 7, 555, -1189, 567, -1166, 608, -1189, 600, -1204, 591, -1200, 587, + -1208, 555, -1190 + ], + [ + 25.5, 10.1, -715, -1079, -728, -1103, -722, -1106, -735, -1131, -748, + -1123, -722, -1075 + ], + [25.5, 19.8, 418, 694, 405, 671, 379, 686, 393, 712, 420, 698], + [25.6, 12.8, -409, -1029, -421, -1050, -427, -1046, -416, -1025], + [25.6, 11, -665, -429, -680, -456, -687, -452, -672, -425], + [25.6, 11, -138, -1259, -152, -1283, -159, -1280, -145, -1255], + [25.6, 11.3, -601, 799, -595, 796, -609, 769, -615, 773], + [25.6, 9.8, -802, -726, -814, -748, -832, -738, -820, -716], + [ + 25.6, 9.1, -908, -931, -916, -946, -940, -932, -932, -918, -930, -919, + -926, -911, -906, -922, -911, -930 + ], + [25.6, 11.6, 71, -301, 85, -309, 74, -328, 49, -314, 59, -296, 70, -303], + [25.6, 20.1, 496, 594, 489, 581, 482, 585, 491, 602, 498, 598], + [ + 25.6, 12.2, -582, 1346, -584, 1347, -571, 1370, -557, 1363, -572, 1336, + -583, 1342, -581, 1345 + ], + [ + 25.7, 20.4, 858, 1214, 847, 1193, 844, 1194, 841, 1189, 836, 1192, 850, + 1218 + ], + [25.7, 6.7, -1209, -720, -1223, -744, -1243, -733, -1229, -709], + [25.7, 11.9, -692, 760, -707, 734, -720, 741, -705, 767], + [25.7, 16.2, -8, 148, -21, 124, -31, 130, -18, 154], + [ + 25.8, 18.9, -76, 1590, -85, 1575, -89, 1577, -88, 1578, -114, 1591, -113, + 1592, -136, 1603, -127, 1618, -120, 1615, -119, 1616, -83, 1595, -84, 1594 + ], + [ + 25.9, 9.1, -716, 1343, -728, 1350, -734, 1341, -731, 1339, -733, 1336, + -730, 1335, -733, 1334, -747, 1342, -746, 1344, -749, 1346, -736, 1371, + -720, 1362, -722, 1358, -711, 1351 + ], + [25.9, 9.4, -858, -571, -869, -591, -882, -584, -871, -564], + [25.9, 19.8, 755, 956, 744, 936, 737, 940, 752, 966, 759, 963], + [25.9, 11.3, -1073, 340, -1063, 360, -1029, 342, -1040, 322], + [ + 25.9, 17.4, 1267, 264, 1252, 238, 1238, 245, 1246, 258, 1241, 261, 1248, + 274 + ], + [25.9, 18.6, 503, 1014, 507, 1011, 492, 985, 484, 989, 499, 1016], + [25.9, 19.5, 560, 982, 540, 993, 554, 1017, 574, 1006], + [25.9, 10.4, -614, -461, -594, -472, -605, -492, -625, -481], + [25.9, 11.9, 36, -290, 25, -309, 20, -306, 31, -287], + [ + 25.9, 8.8, -691, 1411, -690, 1410, -697, 1396, -709, 1403, -720, 1383, + -726, 1386, -708, 1420 + ], + [25.9, 11.3, -578, -450, -588, -468, -611, -455, -601, -437], + [25.9, 11, -596, -930, -606, -948, -614, -944, -603, -924, -595, -928], + [25.9, 8.2, -1109, -879, -1101, -865, -1079, -877, -1087, -891], + [25.9, 13.1, -12, -157, -15, -163, -42, -149, -38, -142], + [25.9, 11.6, -385, -104, -400, -130, -410, -127, -395, -99], + [ + 25.9, 18.9, 967, 1114, 954, 1091, 946, 1096, 952, 1107, 954, 1106, 959, + 1115, 961, 1114, 963, 1117 + ], + [26, 3.4, -1520, 255, -1534, 229, -1545, 235, -1530, 261], + [26, 6.4, -1229, -709, -1233, -716, -1260, -701, -1256, -694], + [ + 26, 9.4, -660, 132, -669, 116, -677, 120, -678, 119, -676, 118, -679, 114, + -725, 140, -711, 166, -668, 142, -671, 138 + ], + [26, 13.1, -133, -375, -136, -380, -157, -369, -154, -363], + [ + 26.1, 8.5, -925, -962, -937, -983, -943, -980, -945, -983, -954, -978, + -952, -974, -958, -971, -946, -950 + ], + [26.1, 7, -993, -407, -1006, -431, -1012, -427, -999, -404], + [26.1, 11.6, -646, 549, -657, 528, -663, 531, -650, 555, -644, 552], + [26.1, 11.3, -187, -888, -200, -911, -209, -906, -196, -882], + [ + 26.1, 9.1, -862, -1280, -877, -1308, -882, -1305, -897, -1332, -904, + -1328, -874, -1274 + ], + [26.1, 15.5, -34, 162, -63, 111, -70, 115, -53, 145, -52, 144, -40, 165], + [26.1, 12.2, -280, -981, -292, -1003, -298, -999, -287, -977], + [26.1, 6.1, 882, -271, 878, -278, 860, -267, 863, -261], + [26.2, 23.2, 485, 110, 481, 103, 460, 115, 464, 122], + [26.2, 11.6, -451, -721, -474, -762, -520, -737, -491, -684, -445, -710], + [ + 26.2, 12.8, -268, -899, -278, -916, -283, -914, -287, -921, -307, -910, + -299, -880, -275, -893, -275, -895 + ], + [26.2, 11.9, -963, -1118, -974, -1137, -1032, -1105, -1022, -1086], + [ + 26.2, 13.7, -25, 1215, 8, 1196, -7, 1170, -41, 1189, -38, 1194, -41, 1195, + -29, 1217 + ], + [26.2, 10.4, -711, -1417, -719, -1431, -746, -1416, -738, -1402], + [26.2, 17.4, 614, 806, 602, 784, 594, 788, 606, 810], + [26.2, 4.3, 275, -1197, 265, -1216, 226, -1193, 236, -1176], + [26.2, 8.5, -1026, -906, -1034, -920, -1061, -905, -1053, -891], + [26.2, 11.9, -491, -1235, -503, -1256, -516, -1249, -505, -1228], + [26.2, 10.1, -755, -760, -764, -776, -795, -758, -782, -735, -751, -752], + [ + 26.2, 15, -194, 1303, -184, 1298, -197, 1275, -208, 1281, -205, 1286, + -204, 1285 + ], + [26.3, 3, -1530, 261, -1545, 235, -1550, 238, -1536, 264], + [26.3, 8.8, -876, -855, -888, -876, -921, -858, -909, -836], + [ + 26.3, 8.2, -1021, -909, -1034, -933, -1036, -932, -1041, -941, -1045, + -939, -1026, -906 + ], + [26.3, 7.3, -1000, -629, -1007, -641, -1013, -638, -1003, -618, -996, -622], + [26.4, 12.8, -413, -1160, -423, -1178, -445, -1173, -432, -1150], + [26.4, 11, -191, -974, -169, -986, -184, -1012, -210, -997, -196, -971], + [ + 26.4, 8.5, -1074, -1163, -1087, -1187, -1089, -1186, -1091, -1189, -1108, + -1179, -1094, -1152 + ], + [26.4, 3.4, -1536, 264, -1550, 238, -1575, 252, -1561, 278], + [26.4, 20.1, 661, 926, 658, 921, 631, 936, 634, 941], + [ + 26.4, 10.7, -454, -554, -457, -558, -464, -573, -470, -570, -457, -546, + -451, -549 + ], + [26.5, 4.3, 1225, -265, 1209, -292, 1176, -274, 1191, -246], + [26.5, 8.5, 41, -1339, 25, -1331, 31, -1321, 46, -1330], + [26.5, 9.4, -887, -983, -898, -1004, -905, -1001, -893, -980], + [ + 26.5, 9.4, -900, -976, -912, -998, -930, -988, -926, -982, -928, -981, + -920, -965 + ], + [ + 26.5, 11.6, -230, -1345, -243, -1368, -249, -1364, -248, -1363, -281, + -1345, -269, -1323 + ], + [ + 26.5, 10.7, -694, -438, -697, -446, -707, -441, -694, -417, -688, -421, + -695, -437 + ], + [ + 26.6, 7.6, -953, -285, -961, -300, -988, -286, -975, -262, -969, -265, + -968, -263, -960, -267, -962, -270, -964, -269, -968, -276, -958, -281, + -954, -274, -948, -277 + ], + [26.6, 18, 428, 1053, 414, 1028, 408, 1031, 422, 1056], + [ + 26.6, 20.1, 158, 500, 148, 482, 129, 492, 125, 484, 133, 480, 119, 456, + 108, 463, 138, 515, 160, 503 + ], + [26.6, 21, 851, 1183, 855, 1181, 840, 1154, 832, 1159, 847, 1185], + [ + 26.6, 14, -958, 568, -961, 564, -963, 565, -981, 531, -979, 533, -975, + 532, -984, 516, -1045, 549, -1035, 565, -1032, 564, -1030, 567, -1010, + 556, -1008, 560, -999, 555, -1005, 545, -1001, 542, -978, 581, -958, 570 + ], + [26.6, 6.7, -1003, -618, -1013, -638, -1020, -634, -1009, -615], + [26.6, 14.3, -56, 1232, -71, 1205, -91, 1216, -76, 1243], + [26.6, 11.3, -444, 728, -461, 738, -459, 741, -442, 732], + [26.7, 12.8, -371, -448, -358, -424, -352, -427, -365, -451], + [26.7, 4, -1488, 202, -1502, 177, -1518, 187, -1505, 211], + [26.7, 6.1, 932, -637, 899, -697, 884, -689, 917, -629], + [ + 26.7, 8.2, 166, -1013, 172, -1003, 173, -1003, 176, -999, 174, -998, 179, + -989, 200, -1000, 187, -1024 + ], + [26.7, 6.1, 95, -1098, 85, -1116, 63, -1104, 73, -1086], + [26.7, 18.9, 414, 888, 425, 908, 441, 899, 430, 879], + [26.7, 9.1, -867, -1171, -875, -1184, -896, -1173, -888, -1160], + [ + 26.7, 18.3, 61, 1473, 48, 1450, 34, 1457, 32, 1455, 26, 1458, 39, 1478, + 38, 1478, 41, 1484, 50, 1480, 45, 1473, 49, 1470, 50, 1474, 50, 1476, 53, + 1478 + ], + [26.8, 7.6, -934, -374, -947, -397, -958, -391, -944, -367, -933, -373], + [26.8, 12.8, -327, 4, -339, -19, -356, -10, -343, 13], + [26.8, 11, 285, -810, 299, -786, 301, -785, 305, -787, 290, -813], + [ + 26.8, 4.6, 487, -1314, 472, -1340, 463, -1335, 468, -1326, 436, -1309, + 446, -1291 + ], + [26.8, 9.4, -717, -560, -731, -586, -748, -577, -733, -551], + [26.9, 23.5, 415, 449, 401, 423, 395, 426, 410, 452], + [ + 26.9, 12.8, -363, -495, -356, -482, -354, -483, -354, -482, -348, -485, + -352, -492, -347, -494, -344, -490, -340, -490, -337, -491, -335, -494, + -340, -504, -338, -506, -353, -533, -351, -534, -356, -545, -375, -535, + -371, -528, -369, -529, -355, -503, -365, -498 + ], + [27, 20.1, 112, 223, 99, 199, 93, 202, 106, 226], + [27, 8.2, -872, -137, -860, -144, -874, -170, -890, -161, -876, -136], + [27, 9.1, 339, -416, 325, -438, 317, -433, 329, -410], + [27, 20.7, 592, 40, 583, 23, 570, 31, 579, 47], + [ + 27, 3.4, -1563, 321, -1572, 305, -1598, 319, -1597, 321, -1600, 323, + -1597, 328, -1594, 326, -1585, 343, -1576, 338, -1569, 351, -1571, 352, + -1563, 368, -1542, 357, -1551, 341, -1553, 342, -1565, 322 + ], + [ + 27, 4.3, -1353, -242, -1380, -228, -1374, -217, -1362, -224, -1354, -208, + -1339, -216 + ], + [ + 27.1, 7.3, -1098, 78, -1110, 85, -1109, 87, -1112, 88, -1110, 92, -1122, + 98, -1120, 103, -1122, 104, -1119, 110, -1117, 109, -1114, 113, -1102, + 106, -1100, 110, -1097, 108, -1096, 110, -1089, 105, -1089, 104, -1086, + 102, -1087, 100, -1085, 99, -1097, 77 + ], + [27.1, 4.6, 435, -1285, 423, -1306, 412, -1300, 424, -1279], + [27.1, 9.8, -668, -16, -686, -6, -676, 13, -658, 3], + [27.1, 9.8, -691, -611, -704, -635, -715, -629, -701, -605], + [ + 27.1, 9.4, 278, -521, 282, -522, 287, -513, 292, -516, 293, -513, 320, + -528, 313, -541, 286, -526, 279, -539, 266, -532, 279, -509, 283, -511 + ], + [27.1, 8.5, -1094, -1152, -1107, -1177, -1140, -1159, -1127, -1134], + [27.2, 18.9, 721, 893, 707, 869, 700, 872, 714, 897], + [27.2, 5.2, -1186, -301, -1200, -327, -1213, -320, -1199, -294], + [27.2, 7, -1170, -742, -1197, -791, -1223, -776, -1196, -728], + [ + 27.2, 7, -905, 1174, -911, 1161, -912, 1162, -913, 1159, -918, 1162, -916, + 1166, -918, 1167, -909, 1183, -902, 1179 + ], + [ + 27.2, 6.7, 382, -1064, 374, -1077, 344, -1061, 342, -1064, 346, -1067, + 335, -1088, 361, -1101, 353, -1115, 321, -1098, 350, -1046 + ], + [27.2, 20.4, 445, 1533, 427, 1501, 399, 1516, 417, 1548], + [27.3, 5.8, -1264, -82, -1291, -67, -1283, -54, -1257, -69], + [27.3, 12.2, 81, -229, 71, -245, 66, -242, 79, -220, 84, -223], + [27.3, 22.9, 534, 74, 518, 82, 522, 89, 543, 77, 542, 75, 538, 77, 536, 73], + [ + 27.3, 11, -123, -475, -125, -478, -121, -480, -124, -485, -151, -470, + -146, -462 + ], + [27.3, 12.8, 1024, 488, 1011, 465, 991, 476, 1004, 500], + [27.4, 11.3, -562, -824, -572, -840, -576, -838, -567, -821], + [27.4, 16.8, 917, 547, 885, 489, 813, 529, 845, 587], + [ + 27.4, 11, 265, -575, 260, -584, 256, -581, 261, -572, 237, -559, 246, + -544, 274, -560 + ], + [ + 27.4, 11.3, -307, -1397, -277, -1414, -273, -1408, -262, -1416, -275, + -1439, -288, -1432, -296, -1447, -326, -1431, -322, -1424, -321, -1425 + ], + [ + 27.4, 3.7, -1561, 278, -1575, 252, -1588, 259, -1576, 281, -1581, 283, + -1578, 288, -1560, 279 + ], + [ + 27.4, 9.1, -754, -1169, -768, -1197, -766, -1198, -769, -1204, -807, + -1184, -798, -1168, -778, -1179, -768, -1161 + ], + [ + 27.5, 14.3, -244, 457, -258, 433, -265, 437, -261, 444, -260, 443, -252, + 462 + ], + [ + 27.5, 11.9, -284, -1067, -292, -1082, -312, -1071, -301, -1051, -281, + -1062 + ], + [27.6, 12.8, -332, -883, -343, -882, -371, -867, -360, -846, -330, -863], + [27.6, 8.5, -940, -819, -952, -841, -963, -835, -950, -813], + [27.7, 2.7, 1038, -545, 1032, -571, 1021, -569, 1014, -565, 1028, -540], + [ + 27.7, 7.9, 567, -1166, 542, -1211, 535, -1207, 536, -1205, 535, -1199, + 540, -1189, 542, -1191, 547, -1181, 549, -1182, 560, -1162 + ], + [ + 27.7, 2.4, -1556, 82, -1563, 69, -1572, 74, -1573, 72, -1618, 96, -1604, + 123, -1550, 93 + ], + [ + 27.7, 6.7, 1439, 529, 1445, 526, 1446, 527, 1457, 521, 1456, 519, 1459, + 518, 1449, 498, 1429, 509 + ], + [27.7, 15.5, -184, 975, -199, 948, -225, 963, -210, 990], + [ + 27.7, 6.1, -1223, -571, -1250, -557, -1251, -559, -1258, -556, -1244, + -531, -1211, -550 + ], + [27.7, 11.6, -523, 846, -563, 868, -548, 893, -509, 871], + [27.8, 10.1, -520, 789, -533, 764, -547, 771, -533, 796], + [ + 27.8, 14.9, 583, -180, 570, -202, 564, -199, 572, -185, 565, -182, 564, + -183, 545, -173, 552, -161 + ], + [27.8, 9.4, -755, -175, -761, -187, -800, -165, -793, -154], + [27.9, 9.4, -1048, -1117, -1059, -1136, -1065, -1133, -1055, -1114], + [ + 27.9, 21, 862, 1177, 848, 1151, 840, 1154, 849, 1170, 851, 1169, 854, + 1176, 857, 1180 + ], + [27.9, 3.4, 1196, -317, 1162, -299, 1176, -274, 1209, -292], + [ + 27.9, 19.2, 666, 223, 662, 215, 655, 219, 653, 216, 655, 215, 653, 212, + 652, 213, 651, 212, 658, 208, 654, 201, 628, 215, 632, 222, 640, 218, 644, + 225, 636, 229, 640, 237 + ], + [ + 28, 10.4, -749, -1167, -752, -1165, -754, -1169, -768, -1161, -778, -1179, + -798, -1168, -799, -1170, -801, -1169, -794, -1156, -796, -1155, -781, + -1127, -753, -1142, -755, -1145, -741, -1153 + ], + [ + 28.1, 13.1, -322, -1211, -349, -1260, -368, -1249, -371, -1246, -372, + -1235, -351, -1239, -345, -1227, -347, -1226, -334, -1203 + ], + [28.1, 14.9, -227, 805, -241, 779, -264, 791, -249, 818], + [ + 28.1, 12.2, 458, -787, 446, -810, 433, -803, 435, -799, 423, -793, 431, + -778, 442, -785, 447, -777, 460, -784 + ], + [ + 28.1, 10.4, -626, 579, -637, 558, -640, 560, -642, 558, -653, 564, -640, + 587 + ], + [28.1, 11, -497, -617, -509, -639, -529, -628, -517, -606], + [ + 28.2, 7.6, 580, -1221, 577, -1227, 578, -1232, 575, -1231, 574, -1232, + 560, -1223, 559, -1224, 551, -1220, 552, -1219, 541, -1214, 547, -1202 + ], + [ + 28.2, 7.3, -779, 1104, -806, 1056, -848, 1080, -836, 1102, -829, 1098, + -812, 1129, -776, 1110 + ], + [28.3, 12.8, -437, -1188, -447, -1205, -453, -1202, -443, -1184], + [ + 28.3, 5.8, -926, 1157, -929, 1159, -932, 1154, -939, 1156, -943, 1154, + -946, 1156, -946, 1161, -952, 1166, -949, 1170, -953, 1172, -948, 1181, + -945, 1179, -935, 1196, -911, 1183, -912, 1179, -913, 1178, -916, 1180, + -923, 1167, -921, 1166 + ], + [ + 28.3, 16.2, -109, 1433, -131, 1445, -130, 1448, -143, 1456, -141, 1460, + -138, 1458, -138, 1456, -137, 1456, -133, 1458, -123, 1453, -120, 1457, + -131, 1463, -121, 1484, -90, 1467 + ], + [28.3, 16.5, -157, 961, -173, 934, -199, 948, -184, 975], + [28.3, 11.9, -80, -422, -84, -428, -117, -409, -114, -403], + [28.4, 8.8, -908, -753, -920, -774, -932, -767, -920, -745, -907, -752], + [ + 28.4, 13.4, -381, -1009, -384, -1016, -357, -1031, -362, -1055, -403, + -1033, -387, -1005 + ], + [28.4, 10.4, -681, -882, -692, -902, -734, -879, -723, -859], + [28.5, 16.5, -150, 1470, -137, 1492, -124, 1485, -138, 1460, -151, 1467], + [28.5, 15.5, -212, 763, -226, 737, -240, 744, -225, 770], + [28.5, 13.7, -77, -40, -91, -67, -104, -60, -89, -33], + [ + 28.5, 11, -664, -1107, -677, -1130, -686, -1126, -684, -1123, -688, -1121, + -676, -1100 + ], + [28.5, 23.5, 315, 199, 302, 177, 296, 180, 308, 203], + [28.6, 11.6, -395, -99, -410, -125, -424, -118, -411, -89], + [28.6, 6.7, -983, -413, -996, -436, -1006, -431, -993, -407], + [ + 28.7, 21.3, 591, 116, 587, 109, 576, 114, 581, 123, 583, 122, 591, 135, + 597, 132, 590, 119, 590, 117 + ], + [ + 28.7, 11.6, -682, 611, -696, 586, -707, 592, -703, 601, -697, 598, -696, + 600, -697, 601, -695, 604, -694, 603, -692, 605, -698, 609, -694, 617 + ], + [ + 28.7, 15.8, -216, 1445, -221, 1435, -224, 1436, -228, 1428, -226, 1427, + -246, 1392, -255, 1397, -238, 1428, -258, 1439, -276, 1408, -285, 1414, + -266, 1449, -264, 1447, -259, 1456, -261, 1457, -256, 1467, -246, 1462, + -250, 1456, -228, 1444, -225, 1451 + ], + [ + 28.7, 6.4, -1297, 321, -1143, 236, -1148, 228, -1105, 204, -1134, 153, + -1346, 270, -1317, 321, -1302, 313 + ], + [28.7, 11.6, -210, -840, -223, -862, -229, -859, -217, -836], + [28.7, 4.6, 446, -1291, 431, -1317, 420, -1311, 435, -1285], + [ + 28.7, 12.5, -485, -1240, -497, -1262, -504, -1258, -491, -1235, -484, + -1239 + ], + [28.7, 7.3, -1123, -853, -1136, -876, -1149, -869, -1136, -845], + [ + 28.8, 13.1, -357, -1031, -384, -1016, -381, -1009, -358, -1021, -356, + -1027 + ], + [28.8, 6.1, -1094, -449, -1114, -438, -1110, -432, -1091, -442], + [28.9, 15.5, -239, 1514, -253, 1487, -261, 1492, -246, 1518], + [28.9, 7.3, -972, -419, -986, -442, -996, -436, -983, -413], + [ + 28.9, 13.1, -988, 823, -995, 811, -1001, 814, -992, 830, -989, 828, -991, + 824 + ], + [ + 28.9, 6.1, -1235, -452, -1241, -462, -1244, -461, -1249, -471, -1246, + -472, -1262, -501, -1271, -496, -1268, -490, -1290, -478, -1293, -484, + -1302, -479, -1275, -430, -1267, -435, -1271, -442, -1264, -446, -1263, + -444, -1253, -450, -1254, -451, -1247, -455, -1243, -448 + ], + [ + 28.9, 20.1, 878, 1324, 877, 1322, 880, 1320, 877, 1316, 874, 1318, 874, + 1317, 850, 1330, 854, 1337 + ], + [28.9, 9.8, 1108, -116, 1095, -138, 1088, -135, 1103, -109, 1110, -112], + [29, 4.3, 924, -1063, 953, -1010, 1018, -1046, 979, -1117, 914, -1081], + [ + 29, 4.3, 951, -1013, 924, -1063, 922, -1062, 919, -1068, 918, -1067, 917, + -1069, 910, -1066, 911, -1063, 882, -1047, 866, -1077, 882, -1086, 881, + -1088, 893, -1095, 887, -1106, 796, -1055, 802, -1044, 832, -1058, 836, + -1052, 831, -1046, 824, -1042, 831, -1031, 838, -1035, 846, -1035, 849, + -1029, 814, -1010, 767, -1011, 779, -990, 781, -991, 819, -924, 851, -941, + 838, -963, 875, -983, 878, -978, 865, -970, 873, -955, 894, -967, 889, + -977, 892, -978, 896, -969, 897, -969, 898, -967, 921, -980, 913, -994, + 927, -1001, 941, -997, 941, -999, 947, -998, 948, -1001, 951, -1001, 952, + -1005, 953, -1005, 949, -1012 + ], + [29, 13.7, -223, -29, -251, -13, -245, -2, -221, -16], + [ + 29.1, 12.5, 631, -155, 628, -160, 623, -157, 620, -163, 619, -166, 623, + -169, 619, -177, 598, -166, 603, -157, 608, -159, 611, -155, 612, -152, + 608, -149, 611, -144 + ], + [ + 29.1, 8.5, -852, -114, -866, -140, -872, -137, -870, -134, -871, -134, + -858, -110 + ], + [ + 29.2, 11.6, -388, -638, -405, -668, -404, -671, -399, -673, -411, -694, + -437, -680, -425, -659, -423, -660, -406, -628 + ], + [29.2, 11.6, -227, -1010, -238, -1032, -245, -1028, -233, -1007], + [29.3, 4.3, -1353, -242, -1367, -267, -1389, -254, -1375, -230], + [ + 29.3, 7.6, 701, -437, 688, -460, 671, -450, 674, -445, 659, -436, 661, + -434, 634, -419, 643, -404, 669, -418, 669, -419 + ], + [ + 29.4, 7, -1070, 1082, -1080, 1064, -1093, 1071, -1108, 1045, -1134, 1060, + -1120, 1086, -1107, 1079, -1092, 1105, -1066, 1090 + ], + [29.4, 18.9, 554, 658, 541, 634, 535, 638, 548, 661], + [ + 29.5, 13.4, -327, -352, -340, -376, -353, -368, -347, -357, -349, -356, + -340, -345 + ], + [29.5, 12.5, 90, -187, 76, -211, 70, -208, 84, -183], + [29.6, 13.1, -19, -170, -23, -177, -49, -162, -46, -156], + [29.6, 11.6, -911, 916, -926, 890, -932, 893, -918, 919], + [29.6, 10.7, -738, -400, -748, -418, -759, -412, -745, -387, -734, -394], + [ + 29.6, 8.8, 683, -738, 685, -739, 688, -735, 719, -752, 706, -775, 673, + -757, 678, -748, 670, -744, 676, -734 + ], + [ + 29.6, 9.8, -664, -128, -697, -189, -721, -176, -703, -142, -739, -122, + -728, -102, -736, -97, -732, -90 + ], + [29.7, 11.3, -481, 1140, -490, 1124, -519, 1140, -510, 1155], + [29.7, 18, 620, 776, 631, 796, 644, 789, 631, 765, 618, 772], + [ + 29.7, 12.8, -339, -436, -342, -442, -344, -441, -347, -448, -346, -448, + -352, -459, -365, -452, -359, -441, -358, -442, -352, -429 + ], + [29.8, 11.9, -540, -1295, -554, -1322, -574, -1311, -560, -1284], + [ + 29.8, 18.9, 342, -98, 335, -110, 315, -98, 328, -75, 341, -82, 340, -84, + 347, -88 + ], + [ + 29.9, 15.8, 189, 999, 158, 1016, 161, 1021, 170, 1016, 171, 1018, 168, + 1019, 173, 1027, 175, 1026, 179, 1032, 176, 1034, 181, 1045, 219, 1025, + 204, 999, 195, 1004, 201, 1016, 193, 1020, 187, 1009, 193, 1006 + ], + [ + 29.9, 6.4, 220, -1110, 218, -1115, 222, -1117, 224, -1112, 234, -1117, + 228, -1130, 235, -1134, 239, -1126, 241, -1127, 240, -1129, 260, -1139, + 256, -1146, 258, -1146, 259, -1145, 263, -1147, 253, -1164, 212, -1142, + 221, -1125, 201, -1114, 207, -1103 + ], + [29.9, 9.4, -743, 168, -747, 160, -774, 175, -769, 182], + [29.9, 4.9, -1155, -318, -1168, -341, -1179, -335, -1167, -311], + [29.9, 5.2, -963, 1272, -964, 1271, -969, 1274, -956, 1298, -951, 1295], + [29.9, 14.6, 764, 347, 752, 326, 742, 331, 741, 329, 737, 331, 750, 355], + [29.9, 10.7, -676, -1049, -670, -1052, -682, -1075, -689, -1071], + [29.9, 7.9, 135, -971, 124, -990, 117, -986, 128, -967], + [ + 30, 11.3, -285, 1268, -281, 1266, -296, 1239, -310, 1247, -305, 1255, + -301, 1253, -291, 1272 + ], + [30, 11.3, -589, -1431, -613, -1474, -619, -1470, -595, -1427], + [ + 30, 18.9, 429, -127, 434, -130, 427, -144, 401, -129, 407, -118, 414, + -123, 416, -119 + ], + [30, 19.8, 388, 750, 373, 723, 346, 738, 361, 765], + [ + 30, 12.8, -242, -570, -240, -571, -244, -579, -245, -578, -276, -561, + -274, -552, -245, -568 + ], + [30.1, 9.4, 134, -855, 119, -846, 126, -833, 145, -843, 137, -856], + [ + 30.1, 10.7, -732, -1203, -741, -1220, -747, -1216, -734, -1192, -728, + -1195 + ], + [ + 30.1, 20.4, 866, 1210, 851, 1183, 846, 1186, 849, 1192, 847, 1193, 858, + 1214 + ], + [ + 30.1, 19.8, 311, 848, 316, 845, 301, 818, 289, 824, 296, 837, 298, 836, + 300, 839, 298, 840, 300, 844, 302, 843, 306, 851 + ], + [30.1, 12.8, 958, 431, 944, 408, 926, 418, 940, 445, 959, 434], + [ + 30.1, 12.8, -335, -1152, -338, -1168, -342, -1166, -341, -1164, -360, + -1161, -358, -1148 + ], + [ + 30.2, 10.7, 226, -622, 220, -633, 218, -632, 197, -672, 186, -666, 194, + -652, 199, -654, 212, -630, 209, -628, 216, -615, 227, -620 + ], + [ + 30.2, 7.6, 1125, -162, 1114, -182, 1094, -171, 1106, -148, 1119, -155, + 1118, -158 + ], + [ + 30.2, 12.2, -267, -988, -282, -1015, -294, -1008, -290, -1001, -286, + -1003, -282, -996, -287, -993, -280, -981 + ], + [30.2, 9.1, -953, -946, -966, -969, -979, -962, -966, -939], + [30.2, 18.6, 419, 823, 403, 795, 397, 799, 412, 827], + [30.3, 10.4, -740, -704, -711, -653, -659, -682, -687, -733], + [ + 30.3, 10.7, -406, -628, -420, -653, -431, -648, -428, -643, -433, -640, + -422, -620 + ], + [30.3, 20.4, 323, 786, 305, 754, 296, 759, 284, 738, 271, 745, 300, 798], + [ + 30.3, 15.5, 122, 1077, 108, 1051, 118, 1045, 104, 1019, 80, 1032, 85, + 1040, 87, 1039, 89, 1043, 87, 1044, 95, 1058, 104, 1053, 119, 1080 + ], + [30.4, 19.8, 357, 803, 351, 792, 331, 803, 345, 830, 366, 818], + [ + 30.5, 12.8, -375, -1123, -378, -1140, -411, -1122, -408, -1118, -401, + -1118, -398, -1111 + ], + [30.5, 10.4, -123, -887, -136, -910, -143, -907, -130, -883], + [ + 30.5, 10.1, -104, -1122, -92, -1129, -100, -1143, -130, -1126, -124, + -1116, -105, -1126 + ], + [ + 30.5, 9.1, -878, -940, -880, -938, -881, -940, -886, -937, -897, -956, + -916, -946, -904, -923, -887, -932, -884, -933, -883, -932, -876, -936 + ], + [ + 30.5, 19.2, 120, 1587, 130, 1582, 132, 1585, 137, 1582, 133, 1574, 148, + 1565, 136, 1543, 80, 1575, 93, 1598, 114, 1587 + ], + [30.5, 15.2, -82, 151, -95, 128, -102, 132, -89, 155], + [ + 30.6, 11.3, -621, -999, -632, -1018, -646, -1010, -636, -993, -639, -992, + -637, -988, -634, -989, -628, -978, -625, -980, -628, -986, -618, -992 + ], + [30.6, 12.8, -378, -1140, -381, -1157, -412, -1140, -404, -1126], + [30.6, 20.1, 750, 962, 737, 939, 730, 944, 742, 966], + [ + 30.6, 7.6, -1140, -810, -1145, -820, -1177, -802, -1171, -790, -1140, + -807, -1141, -810 + ], + [ + 30.6, 15.5, -118, 354, -93, 340, -94, 338, -93, 337, -104, 316, -106, 317, + -107, 314, -145, 335, -145, 339, -147, 339, -144, 363, -138, 361, -136, + 364 + ], + [ + 30.6, 7.6, -1176, -823, -1188, -846, -1195, -842, -1194, -840, -1200, + -836, -1201, -838, -1208, -835, -1196, -812 + ], + [30.6, 18, 682, 214, 670, 192, 662, 197, 659, 192, 657, 194, 671, 220], + [ + 30.7, 13.7, 1165, 823, 1156, 808, 1158, 807, 1154, 800, 1140, 808, 1143, + 815, 1145, 814, 1154, 830 + ], + [ + 30.8, 7.6, 102, -1498, 98, -1506, 83, -1498, 88, -1489, 90, -1490, 99, + -1474, 110, -1481, 101, -1497 + ], + [30.8, 8.5, -659, 1134, -673, 1107, -686, 1114, -671, 1141], + [30.8, 10.4, -575, -126, -588, -149, -601, -142, -588, -118], + [30.8, 18.9, 561, 654, 548, 630, 541, 634, 554, 658], + [30.8, 8.8, 688, -621, 667, -610, 673, -599, 693, -610], + [ + 30.9, 23.5, 370, 157, 387, 147, 386, 145, 394, 141, 388, 129, 379, 133, + 379, 136, 371, 140, 370, 139, 362, 143 + ], + [ + 31, 13.7, -340, -345, -349, -356, -347, -357, -353, -368, -360, -365, + -346, -340, -340, -344 + ], + [31, 23.5, 291, 323, 316, 310, 312, 303, 286, 318, 290, 324], + [31, 6.4, 333, -1418, 327, -1429, 310, -1420, 322, -1397, 339, -1406], + [ + 31.1, 19.5, 1281, 165, 1277, 159, 1272, 160, 1268, 153, 1273, 150, 1269, + 143, 1251, 153, 1255, 160, 1260, 158, 1264, 165, 1259, 168, 1263, 175 + ], + [31.1, 14.3, -941, 499, -944, 494, -971, 509, -968, 514], + [31.1, 12.5, -352, -771, -379, -756, -375, -749, -348, -763], + [ + 31.1, 10.7, -764, -776, -755, -760, -734, -772, -716, -739, -697, -749, + -697, -753, -699, -754, -723, -798, -726, -798 + ], + [ + 31.1, 24.1, 379, 371, 354, 327, 347, 331, 362, 357, 348, 364, 346, 361, + 319, 375, 336, 406, 383, 380 + ], + [31.1, 9.1, -796, -1210, -811, -1237, -817, -1233, -803, -1206], + [ + 31.2, 11.6, 159, -372, 155, -381, 137, -371, 142, -363, 145, -364, 152, + -351, 164, -358, 157, -371 + ], + [ + 31.2, 9.1, -43, -1021, -47, -1029, -50, -1028, -56, -1041, -62, -1038, + -62, -1039, -67, -1037, -63, -1030, -65, -1029, -67, -1029, -71, -1035, + -80, -1030, -74, -1019, -73, -1019, -71, -1016, -74, -1015, -70, -1007, + -58, -1013, -61, -1018, -57, -1020, -54, -1015 + ], + [ + 31.2, 8.5, 39, -1529, 39, -1528, 37, -1527, 40, -1523, 65, -1537, 63, + -1540, 88, -1553, 75, -1577, 38, -1555, 39, -1554, 35, -1552, 37, -1548, + 36, -1544, 36, -1540, 39, -1538, 43, -1537, 45, -1533 + ], + [ + 31.2, 14, 711, -72, 706, -81, 702, -78, 698, -86, 702, -88, 699, -93, 683, + -84, 686, -79, 690, -81, 694, -74, 690, -72, 695, -63 + ], + [ + 31.2, 13.1, 1187, 809, 1175, 788, 1160, 797, 1163, 803, 1165, 802, 1174, + 818, 1187, 810 + ], + [ + 31.2, 19.2, 55, 1588, 59, 1596, 61, 1595, 62, 1596, 70, 1610, 76, 1606, + 72, 1598, 76, 1596, 80, 1604, 87, 1600, 79, 1587, 81, 1584, 76, 1576 + ], + [ + 31.2, 8.8, 4, -1263, 2, -1267, 0, -1266, 0, -1268, -3, -1272, -1, -1273, + -5, -1280, -14, -1276, -10, -1269, -8, -1270, -5, -1263, -6, -1262, 3, + -1244, 5, -1245, 8, -1240, 10, -1236, 9, -1235, 12, -1228, 20, -1232, 16, + -1239, 15, -1238, 12, -1247, 11, -1246, 10, -1248, 11, -1249 + ], + [ + 31.2, 13.7, 1143, 784, 1140, 779, 1138, 780, 1129, 763, 1118, 770, 1130, + 792 + ], + [ + 31.2, 10.1, -931, 452, -839, 401, -839, 400, -822, 390, -821, 391, -748, + 351, -747, 352, -731, 344, -789, 242, -803, 250, -802, 251, -876, 293, + -987, 353 + ], + [31.3, 12.8, -351, -878, -360, -894, -380, -883, -371, -867], + [31.3, 11.9, -402, 514, -401, 514, -417, 485, -427, 490, -411, 519], + [ + 31.3, 11.6, -311, 1258, -315, 1250, -328, 1257, -323, 1266, -328, 1268, + -332, 1259, -345, 1266, -340, 1275, -344, 1277, -349, 1268, -362, 1276, + -358, 1283, -353, 1281, -349, 1289, -354, 1291, -350, 1298, -336, 1291, + -339, 1285, -335, 1282, -332, 1288, -320, 1282, -324, 1276, -320, 1274, + -316, 1280, -303, 1272, -307, 1265, -311, 1267, -315, 1260 + ], + [31.3, 11.6, -623, -369, -636, -391, -649, -384, -637, -362], + [31.4, 17.7, 26, 1458, 33, 1454, 18, 1428, 4, 1436, 19, 1462], + [ + 31.4, 12.2, -521, -1270, -508, -1277, -534, -1325, -553, -1320, -540, + -1295, -537, -1297 + ], + [ + 31.4, 4.9, 501, -1177, 516, -1185, 518, -1182, 529, -1188, 523, -1200, + 511, -1195, 510, -1198, 503, -1194, 502, -1195, 485, -1184, 485, -1186, + 477, -1181, 477, -1180, 462, -1173, 462, -1172, 455, -1168, 462, -1155 + ], + [ + 31.4, 9.8, -796, -1155, -794, -1156, -801, -1169, -811, -1163, -813, + -1168, -821, -1171, -825, -1169, -826, -1165, -823, -1156, -833, -1151, + -826, -1139, -821, -1142, -806, -1115, -802, -1118, -800, -1114, -786, + -1121, -789, -1125, -785, -1127, -800, -1153 + ], + [ + 31.4, 9.1, 21, -1530, 13, -1544, -10, -1532, 7, -1501, 15, -1505, 13, + -1510, 11, -1509, 9, -1512, 20, -1518, 19, -1520, 23, -1523, 20, -1529 + ], + [ + 31.4, 9.8, 673, -600, 664, -615, 662, -614, 657, -623, 646, -616, 656, + -601, 649, -597, 653, -589 + ], + [ + 31.4, 7.3, -1142, -927, -1149, -941, -1155, -938, -1160, -947, -1172, + -939, -1165, -927, -1170, -924, -1164, -914 + ], + [ + 31.4, 11.6, -366, 972, -433, 851, -646, 968, -616, 1022, -505, 961, -488, + 969, -473, 997, -479, 1000, -465, 1026 + ], + [ + 31.4, 7.9, -1077, -989, -1081, -996, -1064, -1006, -1079, -1033, -1119, + -1011, -1100, -977 + ], + [ + 31.5, 13.4, 1157, 777, 1153, 770, 1149, 772, 1143, 761, 1147, 759, 1145, + 754, 1133, 761, 1142, 776, 1140, 777, 1143, 784 + ], + [ + 31.6, 13.1, -364, -1064, -366, -1078, -369, -1079, -395, -1064, -389, + -1053, -388, -1054, -387, -1052 + ], + [ + 31.6, 12.5, -270, -1448, -283, -1473, -297, -1466, -295, -1462, -292, + -1463, -288, -1452, -286, -1452, -282, -1446, -285, -1444, -283, -1441 + ], + [ + 31.6, 10.4, 309, -645, 314, -637, 315, -638, 316, -636, 323, -624, 331, + -628, 325, -640, 325, -641, 326, -642, 321, -652 + ], + [31.6, 8.2, -1005, -1241, -1018, -1263, -1028, -1258, -1016, -1235], + [31.6, 12.2, -502, -1165, -506, -1172, -533, -1157, -529, -1150], + [ + 31.7, 13.7, 607, -192, 603, -199, 599, -198, 595, -205, 599, -207, 595, + -214, 585, -209, 596, -186 + ], + [31.7, 22.9, 471, 126, 488, 117, 485, 110, 457, 125, 461, 132], + [ + 31.7, 11, -607, -1053, -612, -1063, -615, -1062, -615, -1068, -619, -1075, + -634, -1068, -631, -1063, -625, -1057, -625, -1056, -627, -1055, -620, + -1044 + ], + [31.7, 16.5, 369, 1079, 357, 1059, 347, 1064, 359, 1085], + [ + 31.8, 13.1, -348, -987, -350, -1001, -354, -1003, -370, -994, -365, -985, + -363, -986, -360, -980 + ], + [31.8, 11.9, -352, -771, -358, -781, -384, -766, -379, -756], + [ + 31.8, 15.5, 630, -115, 626, -122, 624, -121, 616, -136, 604, -129, 610, + -118, 612, -118, 613, -116, 609, -114, 614, -106 + ], + [ + 31.8, 10.4, 1300, 607, 1296, 598, 1289, 602, 1286, 597, 1291, 594, 1287, + 586, 1266, 598, 1270, 606, 1275, 603, 1278, 608, 1271, 612, 1276, 621, + 1301, 607 + ], + [ + 31.8, 12.5, -455, -1506, -486, -1560, -518, -1542, -510, -1528, -529, + -1516, -522, -1503, -512, -1508, -497, -1482 + ], + [ + 31.8, 9.4, -864, 160, -868, 154, -872, 156, -873, 154, -876, 149, -872, + 146, -876, 139, -893, 149, -889, 156, -885, 153, -881, 161, -885, 163, + -881, 170, -864, 161 + ], + [ + 31.8, 15.5, -203, 764, -199, 762, -198, 765, -175, 752, -182, 738, -208, + 753 + ], + [ + 31.9, 13.1, 1177, 766, 1173, 760, 1170, 762, 1164, 753, 1169, 750, 1166, + 744, 1146, 756, 1149, 762, 1153, 759, 1156, 764, 1155, 765, 1156, 768, + 1153, 770, 1157, 777 + ], + [31.9, 10.1, -625, -734, -621, -736, -624, -743, -649, -729, -646, -723], + [ + 32, 13.7, 1193, 904, 1190, 900, 1201, 894, 1197, 886, 1192, 889, 1188, + 881, 1193, 879, 1189, 872, 1158, 889, 1162, 896, 1169, 893, 1171, 898, + 1167, 900, 1171, 906, 1185, 902, 1188, 907 + ], + [32, 9.1, -966, -939, -980, -963, -986, -960, -973, -936], + [ + 32, 4.9, -1380, 171, -1380, 170, -1377, 170, -1376, 142, -1359, 143, + -1359, 133, -1371, 133, -1371, 120, -1381, 119, -1381, 133, -1385, 132, + -1386, 160, -1402, 160, -1403, 169, -1390, 169, -1391, 182, -1381, 183 + ], + [ + 32, 11.3, -339, 1240, -348, 1224, -353, 1226, -354, 1225, -378, 1238, + -377, 1239, -381, 1242, -372, 1258 + ], + [32, 11.9, -240, -1036, -253, -1058, -266, -1051, -254, -1029], + [32, 17.4, -54, 442, -69, 416, -79, 422, -65, 448], + [32.1, 19.5, 182, 73, 178, 67, 155, 80, 158, 86], + [ + 32.1, 5.5, -1277, 119, -1276, 107, -1263, 108, -1263, 98, -1276, 97, + -1276, 91, -1278, 91, -1278, 94, -1307, 92, -1307, 76, -1316, 76, -1316, + 88, -1329, 88, -1330, 97, -1317, 98, -1317, 102, -1285, 103, -1286, 119 + ], + [32.1, 12.2, -285, -1015, -296, -1035, -301, -1032, -290, -1012], + [ + 32.2, 10.7, 1254, 633, 1250, 626, 1245, 628, 1241, 621, 1246, 618, 1242, + 611, 1226, 619, 1232, 630, 1225, 633, 1233, 646, 1254, 634 + ], + [32.2, 7.6, 176, -1403, 168, -1418, 133, -1400, 142, -1385], + [ + 32.2, 9.1, 118, -829, 113, -838, 108, -836, 106, -840, 110, -843, 105, + -852, 94, -846, 99, -837, 101, -839, 104, -833, 102, -831, 107, -822 + ], + [32.3, 10.4, -737, -1385, -752, -1412, -759, -1408, -744, -1381], + [32.3, 20.1, 147, 129, 142, 121, 116, 136, 120, 144], + [ + 32.3, 5.2, -1245, -267, -1255, -286, -1258, -284, -1260, -289, -1264, + -286, -1262, -283, -1269, -279, -1259, -260 + ], + [32.3, 9.4, 330, -464, 349, -475, 344, -485, 322, -473, 328, -463], + [32.3, 15.8, 1246, 405, 1255, 400, 1251, 393, 1224, 408, 1228, 414], + [ + 32.3, 18.3, 1304, 204, 1300, 196, 1295, 199, 1291, 192, 1295, 188, 1291, + 181, 1257, 200, 1261, 207, 1265, 205, 1270, 213, 1266, 215, 1270, 222 + ], + [ + 32.4, 13.7, 647, -124, 643, -132, 639, -131, 635, -137, 638, -140, 635, + -146, 621, -138, 629, -124, 626, -122, 630, -115 + ], + [32.4, 18.9, 284, 876, 278, 866, 280, 865, 276, 858, 243, 877, 252, 894], + [32.4, 6.7, 176, -1053, 165, -1071, 160, -1068, 170, -1050], + [ + 32.5, 13.1, 967, 480, 963, 472, 958, 475, 955, 468, 959, 466, 955, 458, + 944, 464, 947, 469, 942, 472, 940, 467, 929, 472, 941, 494, 951, 489, 948, + 484, 953, 481, 956, 486 + ], + [32.5, 10.7, 112, -673, 120, -678, 117, -683, 93, -670, 96, -664], + [ + 32.6, 8.5, 154, -937, 150, -945, 146, -943, 142, -950, 146, -952, 142, + -960, 128, -952, 132, -945, 136, -947, 140, -939, 136, -937, 140, -930 + ], + [32.6, 19.2, 541, 624, 529, 603, 515, 611, 528, 634, 543, 626], + [32.6, 12.2, -313, -1131, -325, -1153, -358, -1148, -351, -1110], + [ + 32.6, 7.6, 729, -239, 734, -230, 740, -234, 743, -228, 741, -227, 742, + -225, 738, -223, 742, -217, 762, -229, 759, -235, 756, -233, 754, -235, + 753, -234, 750, -240, 755, -243, 750, -251 + ], + [32.6, 20.4, 396, 654, 381, 628, 347, 647, 362, 673], + [32.7, 10.7, -602, 923, -616, 897, -643, 912, -628, 938], + [ + 32.7, 21, 838, 1225, 825, 1202, 819, 1205, 823, 1211, 820, 1213, 823, + 1218, 815, 1223, 815, 1224, 809, 1228, 809, 1227, 811, 1225, 810, 1223, + 795, 1231, 803, 1245 + ], + [ + 32.7, 15.5, 193, 1069, 189, 1062, 179, 1068, 190, 1084, 189, 1085, 192, + 1091, 202, 1085 + ], + [ + 32.8, 16.2, 1158, 40, 1154, 34, 1150, 36, 1146, 28, 1150, 26, 1145, 18, + 1143, 20, 1132, 33, 1136, 39, 1137, 38, 1139, 42, 1135, 44, 1139, 50 + ], + [32.9, 18, 1199, 48, 1196, 43, 1158, 64, 1169, 83, 1207, 62], + [33, 9.8, 563, -588, 557, -598, 531, -584, 539, -570, 565, -585], + [ + 33.1, 6.4, 822, -316, 814, -330, 781, -312, 789, -298, 796, -301, 798, + -297, 818, -308, 816, -313 + ], + [33.1, 15.8, 128, -31, 120, -46, 93, -31, 102, -16], + [ + 33.1, 18.3, 1354, 155, 1350, 148, 1340, 154, 1344, 163, 1339, 165, 1334, + 157, 1324, 163, 1328, 171, 1323, 174, 1318, 166, 1307, 172, 1312, 180, + 1307, 183, 1302, 175, 1291, 181, 1295, 189, 1299, 186, 1303, 194, 1300, + 196, 1304, 204, 1314, 198, 1311, 191, 1313, 189, 1313, 188, 1316, 187, + 1320, 194, 1331, 189, 1326, 181, 1332, 178, 1336, 185, 1347, 180, 1342, + 172, 1348, 169, 1352, 177, 1356, 175, 1352, 168, 1357, 165, 1352, 157 + ], + [33.1, 8.5, 343, -1042, 329, -1068, 309, -1058, 323, -1031], + [ + 33.2, 22.3, 316, 36, 307, 41, 317, 58, 342, 44, 341, 43, 343, 42, 337, 30, + 330, 34, 329, 31, 320, 36, 320, 38, 317, 39 + ], + [33.2, 11.6, -583, -876, -571, -854, -551, -866, -563, -887], + [33.2, 17.1, 70, 926, 55, 899, 57, 897, 43, 871, 27, 880, 56, 933], + [33.2, 16.5, 21, 105, 3, 73, -10, 80, 7, 111], + [ + 33.2, 11.3, -222, -1048, -233, -1069, -240, -1066, -228, -1044, -221, + -1047 + ], + [ + 33.2, 8.8, -1014, 994, -1008, 1006, -1021, 1013, -1013, 1027, -1026, 1035, + -1012, 1060, -959, 1031, -988, 979 + ], + [33.2, 11.6, 535, -707, 524, -728, 517, -724, 529, -703], + [ + 33.2, 16.8, 42, 1393, 40, 1389, 38, 1391, 36, 1388, 39, 1386, 29, 1369, + 18, 1375, 20, 1379, 22, 1378, 31, 1394, 30, 1395, 32, 1399 + ], + [ + 33.2, 12.2, -259, -1116, -269, -1134, -276, -1130, -264, -1108, -257, + -1112 + ], + [ + 33.2, 2.7, 1070, -681, 1077, -668, 1088, -674, 1076, -739, 1051, -725, + 1049, -729, 1045, -726 + ], + [ + 33.3, 6.1, 1406, -59, 1398, -65, 1385, -64, 1376, -54, 1377, -31, 1388, + -22, 1401, -22, 1410, -33, 1409, -56 + ], + [33.3, 12.5, -432, -1150, -444, -1172, -450, -1169, -438, -1146], + [33.3, 11.9, 143, -396, 128, -422, 120, -417, 134, -390], + [ + 33.3, 7.9, -927, -399, -931, -406, -947, -397, -934, -374, -918, -383, + -922, -390, -924, -389, -925, -391, -923, -392 + ], + [ + 33.4, 6.7, -1344, -790, -1346, -793, -1372, -779, -1353, -742, -1326, -757 + ], + [ + 33.4, 8.2, 710, -202, 722, -208, 719, -212, 733, -220, 737, -214, 742, + -217, 738, -224, 734, -222, 730, -229, 734, -231, 729, -239, 697, -221, + 709, -201 + ], + [33.4, 12.8, 1238, 879, 1223, 853, 1211, 860, 1225, 886], + [33.4, 8.5, -962, -857, -980, -889, -997, -880, -979, -847], + [ + 33.4, 12.5, -452, -1139, -479, -1187, -489, -1182, -473, -1153, -469, + -1155, -458, -1135 + ], + [ + 33.4, 17.1, 1146, 19, 1149, 25, 1153, 22, 1154, 24, 1157, 30, 1153, 33, + 1158, 40, 1175, 31, 1170, 23, 1166, 26, 1161, 18, 1166, 16, 1163, 9 + ], + [33.4, 11.6, -197, -1506, -176, -1518, -182, -1528, -203, -1517], + [ + 33.5, 12.5, -465, -1132, -476, -1152, -473, -1153, -489, -1182, -499, + -1176, -471, -1128 + ], + [33.5, 6.7, 683, -942, 692, -931, 715, -943, 706, -954], + [33.5, 13.4, -223, -29, -225, -47, -260, -28, -251, -13], + [33.6, 12.8, -310, 33, -327, 4, -343, 13, -327, 43], + [33.6, 12.2, -597, 1385, -612, 1358, -625, 1365, -611, 1392], + [ + 33.6, 0.6, 1128, -458, 1091, -438, 1091, -437, 1088, -435, 1106, -404, + 1155, -431, 1137, -463 + ], + [33.8, 12.8, -245, -858, -257, -881, -264, -877, -252, -855], + [34, 3.7, -1481, 232, -1491, 215, -1504, 222, -1495, 239], + [ + 34.1, 4.3, -1424, 112, -1423, 101, -1410, 101, -1410, 92, -1427, 91, + -1425, 65, -1429, 65, -1428, 53, -1438, 53, -1439, 64, -1451, 64, -1452, + 73, -1435, 74, -1437, 100, -1433, 100, -1434, 112 + ], + [34.1, 12.8, -478, -1294, -488, -1312, -508, -1302, -498, -1283], + [34.1, 11.6, -212, -927, -225, -951, -232, -948, -218, -924], + [34.1, 12.2, -278, -1149, -290, -1172, -301, -1166, -289, -1143], + [34.2, 18.9, 291, 888, 284, 876, 252, 894, 262, 911, 293, 893], + [34.2, 11, -432, -614, -460, -666, -476, -658, -447, -606], + [ + 34.2, 12.5, -501, -1335, -508, -1349, -528, -1338, -518, -1319, -498, + -1330 + ], + [ + 34.2, 9.1, 393, -460, 407, -468, 404, -474, 408, -476, 405, -481, 380, + -467, 386, -456 + ], + [ + 34.2, 15.8, 169, 1198, 186, 1189, 181, 1180, 180, 1180, 173, 1169, 175, + 1168, 172, 1162, 151, 1174, 154, 1179, 155, 1178, 162, 1190, 160, 1191, + 165, 1200 + ], + [34.3, 18, 985, 1165, 963, 1177, 978, 1204, 999, 1192], + [34.3, 10.7, -923, 283, -937, 257, -958, 268, -943, 294], + [ + 34.3, 15.5, 205, 1122, 189, 1093, 192, 1091, 179, 1068, 146, 1086, 160, + 1111, 170, 1105, 159, 1085, 161, 1084, 180, 1118, 172, 1122, 181, 1136, + 196, 1128, 197, 1125, 198, 1125, 199, 1126 + ], + [34.4, 9.1, 41, -854, 55, -831, 71, -839, 57, -863], + [ + 34.4, 9.4, -683, -523, -692, -539, -719, -524, -722, -528, -728, -525, + -725, -520, -749, -507, -735, -481, -705, -497, -711, -508 + ], + [34.4, 15.2, 689, -61, 680, -78, 664, -69, 673, -52], + [34.4, 11.6, 345, -792, 322, -780, 329, -767, 352, -780], + [ + 34.4, 9.1, -70, -1007, -77, -1020, -81, -1018, -85, -1026, -100, -1018, + -88, -996 + ], + [34.4, 12.8, -62, -248, -67, -258, -101, -240, -95, -229], + [34.5, 19.8, 112, 171, 99, 148, 91, 152, 104, 176], + [ + 34.5, 12.2, 212, -256, 199, -279, 189, -273, 193, -266, 195, -268, 200, + -259, 198, -257, 202, -250 + ], + [34.5, 13.4, -274, 385, -288, 360, -304, 369, -290, 394], + [34.5, 8.5, -835, -162, -847, -185, -860, -177, -848, -155], + [34.5, 16.5, 1024, 1143, 1055, 1197, 1081, 1182, 1051, 1128], + [34.6, 12.8, -471, -1213, -483, -1236, -490, -1232, -477, -1210], + [34.6, 11.6, -242, -1085, -255, -1108, -265, -1102, -253, -1080], + [ + 34.7, 6.1, -1380, -498, -1382, -497, -1380, -494, -1372, -498, -1360, + -476, -1353, -479, -1350, -473, -1345, -477, -1348, -482, -1342, -485, + -1354, -508, -1359, -506, -1361, -509 + ], + [34.7, 8.5, -938, -870, -950, -893, -974, -879, -962, -857], + [ + 34.7, 11.3, -212, -1102, -224, -1124, -247, -1111, -235, -1088, -211, + -1101 + ], + [34.7, 12.5, -457, -1221, -470, -1243, -477, -1239, -464, -1217], + [ + 34.8, 12.8, -215, -143, -190, -157, -198, -172, -195, -174, -201, -184, + -220, -174 + ], + [34.8, 20.4, 500, -47, 491, -64, 478, -57, 487, -40], + [34.9, 9.1, -772, -574, -782, -592, -794, -586, -781, -562, -769, -568], + [34.9, 12.5, -464, -1217, -476, -1239, -483, -1235, -471, -1213], + [34.9, 12.8, 1432, 350, 1423, 333, 1379, 357, 1389, 374], + [35.1, 16.8, 135, 976, 124, 955, 115, 960, 120, 966, 129, 984, 137, 979], + [35.1, 19.8, 587, 1273, 558, 1220, 496, 1254, 526, 1307], + [35.1, 9.4, -773, -248, -787, -273, -835, -247, -820, -221, -773, -247], + [ + 35.3, 12.5, -282, -1233, -293, -1253, -306, -1245, -322, -1275, -341, + -1264, -313, -1215 + ], + [35.3, 12.8, 98, -148, 88, -166, 75, -159, 86, -137, 93, -141, 91, -144], + [ + 35.3, 4, -1376, 86, -1376, 74, -1363, 75, -1362, 66, -1379, 65, -1378, 39, + -1381, 39, -1381, 27, -1391, 27, -1391, 38, -1404, 37, -1405, 47, -1388, + 48, -1389, 74, -1385, 74, -1386, 85 + ], + [35.4, 9.4, -763, -624, -776, -647, -788, -641, -775, -617], + [ + 35.4, 8.8, -877, -1308, -876, -1308, -891, -1336, -897, -1332, -882, -1305 + ], + [ + 35.4, 18, 115, 863, 114, 861, 124, 855, 125, 857, 129, 855, 128, 853, 133, + 851, 120, 829, 87, 847, 101, 871 + ], + [35.4, 4.6, -1220, -283, -1229, -301, -1249, -291, -1239, -272], + [ + 35.4, 9.8, 575, -938, 577, -938, 592, -945, 594, -951, 588, -961, 582, + -962, 566, -953, 564, -947, 570, -938 + ], + [ + 35.5, 19.5, 541, -68, 535, -79, 531, -76, 527, -85, 508, -75, 512, -66, + 508, -64, 514, -53 + ], + [ + 35.5, 15.8, 216, 1117, 204, 1099, 205, 1099, 202, 1093, 192, 1099, 197, + 1105, 206, 1123 + ], + [35.6, 12.5, -274, -1101, -287, -1125, -303, -1116, -290, -1092], + [ + 35.6, 11.6, 103, -501, 98, -509, 96, -508, 93, -513, 95, -515, 90, -524, + 79, -518, 84, -509, 88, -511, 91, -505, 87, -503, 92, -494 + ], + [35.6, 11.3, -203, -932, -218, -957, -226, -953, -212, -927], + [35.6, 19.2, 759, 954, 780, 942, 769, 922, 744, 936, 755, 956], + [35.7, 19.5, 585, -18, 597, -24, 586, -44, 570, -34, 577, -22, 581, -24], + [ + 35.7, 13.4, -1029, 734, -1015, 760, -981, 741, -966, 768, -953, 760, -951, + 756, -979, 739, -982, 740, -1006, 726, -1009, 728, -1014, 725 + ], + [ + 35.7, 11.9, -238, -952, -251, -975, -257, -971, -252, -962, -250, -963, + -246, -956, -248, -955, -244, -947 + ], + [35.7, 10.1, 8, -823, 31, -835, 25, -845, 3, -833], + [ + 35.7, 8.2, -1052, -668, -1037, -676, -1051, -701, -1071, -690, -1057, -665 + ], + [35.7, 10.4, -638, -321, -651, -345, -670, -335, -657, -311], + [ + 35.8, 11.9, -547, -1037, -560, -1059, -573, -1052, -560, -1028, -546, + -1036 + ], + [35.8, 21.3, 810, 1223, 819, 1218, 813, 1208, 790, 1221, 795, 1231], + [ + 35.8, 15.5, 600, -150, 593, -162, 581, -156, 581, -154, 577, -152, 576, + -153, 560, -144, 565, -134, 567, -135, 575, -116, 591, -125, 585, -135, + 589, -137, 592, -135, 602, -140, 597, -148 + ], + [35.8, 9.8, 1363, 751, 1355, 737, 1329, 752, 1337, 765], + [35.9, 9.4, -860, -1046, -867, -1058, -887, -1047, -880, -1035], + [35.9, 11.3, -632, -985, -644, -977, -631, -954, -618, -961], + [35.9, 8.8, 362, -535, 365, -537, 361, -544, 343, -534, 347, -527], + [35.9, 8.8, -685, -58, -672, -35, -666, -38, -679, -62], + [ + 35.9, 9.8, -806, -1070, -815, -1086, -823, -1082, -810, -1060, -803, -1064 + ], + [36, 12.8, -408, -1118, -419, -1136, -425, -1133, -414, -1114], + [36, 12.8, -404, -1126, -412, -1140, -419, -1136, -411, -1122], + [ + 36, 11, -946, 242, -950, 235, -957, 237, -962, 242, -955, 254, -953, 253, + -952, 254, -945, 250, -945, 249, -943, 247 + ], + [ + 36, 20.7, 861, 1271, 862, 1270, 852, 1253, 831, 1265, 832, 1267, 819, + 1275, 829, 1292, 856, 1277, 854, 1275 + ], + [ + 36.1, 10.7, -649, -1032, -662, -1056, -676, -1049, -674, -1046, -681, + -1042, -668, -1019, -648, -1030 + ], + [36.1, 12.8, -477, -1210, -490, -1232, -497, -1229, -484, -1206], + [ + 36.1, 8.5, -1000, -1204, -1015, -1230, -1008, -1234, -1009, -1236, -1022, + -1227, -1007, -1200 + ], + [36.2, 9.4, 983, -89, 957, -75, 960, -69, 970, -75, 987, -44, 1003, -53], + [36.2, 18, 6, 1534, 2, 1527, -17, 1537, -13, 1544], + [36.2, 11, -197, -936, -210, -959, -216, -955, -203, -932], + [36.3, 4.6, -1392, 408, -1402, 390, -1429, 405, -1419, 422], + [36.3, 10.4, -769, -995, -783, -1020, -804, -1008, -791, -983], + [ + 36.3, 16.5, 610, -107, 607, -112, 600, -109, 599, -112, 602, -116, 598, + -123, 585, -115, 584, -118, 577, -114, 588, -92, 611, -104 + ], + [ + 36.3, 12.2, -522, -1416, -503, -1426, -502, -1428, -510, -1440, -541, + -1423, -534, -1411, -524, -1417 + ], + [36.4, 12.5, 686, -180, 671, -206, 653, -196, 667, -170], + [36.4, 3.7, -1505, 211, -1518, 187, -1530, 193, -1516, 217], + [36.4, 11.9, 119, -471, 107, -493, 91, -484, 103, -462], + [ + 36.5, 7.6, 55, -1207, 69, -1217, 76, -1204, 80, -1206, 77, -1212, 79, + -1213, 83, -1208, 87, -1210, 72, -1238, 67, -1235, 73, -1225, 71, -1223, + 65, -1234, 39, -1219, 42, -1214, 46, -1216, 48, -1216, 50, -1213, 45, + -1209, 48, -1203 + ], + [36.5, 17.7, 614, 764, 602, 743, 595, 747, 610, 773, 616, 769], + [36.5, 10.4, -579, 698, -593, 672, -620, 686, -605, 712], + [ + 36.5, 7.6, -895, -179, -904, -195, -911, -191, -916, -201, -941, -187, + -945, -195, -971, -180, -953, -148 + ], + [ + 36.5, 9.8, 358, -394, 354, -402, 333, -390, 337, -383, 340, -384, 348, + -371, 364, -380, 355, -393 + ], + [ + 36.6, 7.3, -1009, -248, -986, -261, -991, -270, -981, -275, -988, -286, + -1020, -268 + ], + [36.6, 9.8, -667, 892, -660, 905, -650, 899, -657, 886], + [ + 36.6, 12.2, -896, 660, -939, 685, -936, 696, -930, 701, -932, 703, -910, + 726, -899, 730, -895, 727, -910, 700, -882, 685 + ], + [ + 36.6, 10.1, -783, 845, -757, 831, -768, 811, -783, 819, -780, 826, -777, + 828, -790, 833 + ], + [ + 36.6, 9.1, -962, -1026, -956, -1030, -967, -1049, -969, -1048, -970, + -1049, -973, -1046, -969, -1038, -971, -1037, -966, -1028, -964, -1029 + ], + [ + 36.6, 9.1, -831, -1193, -847, -1221, -853, -1218, -857, -1225, -871, + -1217, -851, -1182 + ], + [36.6, 13.4, -912, 881, -926, 855, -933, 859, -918, 885], + [36.6, 10.1, -751, -697, -741, -679, -730, -685, -740, -704], + [ + 36.6, 11.6, 1180, 549, 1170, 554, 1174, 562, 1168, 565, 1177, 583, 1201, + 569, 1202, 568, 1191, 557, 1186, 559 + ], + [ + 36.6, 8.5, -952, -841, -945, -828, -935, -834, -933, -831, -928, -833, + -929, -836, -914, -845, -921, -858 + ], + [ + 36.6, 8.8, -949, -201, -948, -202, -945, -196, -920, -210, -931, -229, + -957, -214 + ], + [36.6, 21, 146, 243, 132, 217, 121, 222, 135, 249], + [36.7, 8.8, -894, -1263, -908, -1288, -921, -1280, -907, -1255], + [36.8, 11.3, -599, -1057, -612, -1080, -620, -1076, -607, -1053], + [ + 36.8, 5.5, -1515, -312, -1524, -327, -1534, -321, -1525, -306, -1551, + -294, -1545, -281, -1439, -340, -1444, -349, -1507, -313, -1509, -315 + ], + [36.9, 16.5, 1166, 318, 1157, 301, 1122, 320, 1131, 337], + [36.9, 4.3, 646, -1278, 625, -1266, 639, -1240, 661, -1252], + [36.9, 7.9, 361, -544, 358, -549, 340, -539, 343, -534], + [36.9, 11.3, -696, 835, -703, 822, -721, 832, -714, 845], + [ + 36.9, 9.8, -877, -766, -873, -768, -880, -780, -878, -781, -872, -769, + -862, -775, -875, -799, -907, -781, -894, -757 + ], + [36.9, 18.6, 465, 941, 452, 918, 442, 924, 455, 948, 466, 942], + [36.9, 10.7, -170, -953, -183, -976, -190, -972, -176, -948, -169, -952], + [37, 10.1, 65, -778, 77, -755, 85, -759, 101, -731, 182, -775, 154, -826], + [37, 9.1, -10, -950, -23, -974, -30, -970, -17, -947], + [37, 11, -616, -1086, -626, -1106, -634, -1102, -622, -1079, -614, -1083], + [ + 37, 6.4, 215, -1253, 203, -1275, 199, -1273, 197, -1276, 182, -1267, 184, + -1264, 180, -1262, 192, -1240 + ], + [ + 37.1, 10.7, -699, -981, -675, -937, -693, -927, -690, -921, -631, -954, + -644, -977, -632, -985, -634, -989, -637, -988, -639, -992, -636, -993, + -646, -1010 + ], + [37.1, 13.4, -256, -264, -261, -296, -295, -276, -281, -251], + [ + 37.2, 12.2, -519, -1193, -514, -1196, -522, -1212, -553, -1194, -545, + -1179 + ], + [37.2, 14, 1242, 456, 1232, 436, 1212, 447, 1222, 467], + [37.2, 12.8, 786, 112, 809, 99, 800, 82, 773, 97, 783, 114], + [ + 37.2, 12.2, -519, -1193, -545, -1179, -542, -1173, -510, -1191, -513, + -1195, -518, -1192 + ], + [ + 37.2, 4.9, 913, -361, 884, -413, 868, -404, 883, -377, 869, -370, 871, + -366, 866, -364, 878, -341 + ], + [37.2, 23.5, 425, 85, 416, 68, 388, 84, 397, 100], + [ + 37.2, 10.1, -924, 237, -931, 225, -938, 227, -943, 231, -936, 244, -934, + 242, -933, 244 + ], + [37.2, 9.1, -973, -936, -985, -958, -996, -952, -984, -929], + [37.2, 18.9, 530, 818, 522, 804, 496, 818, 504, 832], + [37.2, 10.7, -734, -1270, -724, -1252, -684, -1274, -694, -1292], + [37.3, 8.2, -787, 1091, -779, 1104, -757, 1092, -764, 1079], + [37.3, 8.5, 590, -1004, 634, -1027, 626, -1042, 566, -1009, 574, -995], + [ + 37.3, 10.4, -680, -1208, -687, -1223, -668, -1234, -671, -1239, -666, + -1241, -673, -1254, -727, -1225, -719, -1212, -714, -1215, -712, -1210, + -692, -1221, -683, -1207 + ], + [37.3, 11.9, -238, -1124, -249, -1145, -263, -1138, -251, -1116], + [37.3, 11.3, -560, -1029, -573, -1052, -586, -1044, -573, -1021], + [37.4, 8.5, 822, -110, 834, -89, 837, -91, 838, -88, 842, -91, 830, -114], + [37.4, 16.2, 711, 177, 703, 182, 705, 184, 693, 191, 700, 204, 720, 193], + [ + 37.4, 10.4, -645, -1204, -652, -1217, -658, -1214, -660, -1219, -714, + -1190, -711, -1185, -716, -1182, -709, -1169 + ], + [37.4, 7.6, 767, -220, 767, -221, 747, -211, 759, -188, 779, -199], + [37.4, 14, 1377, 339, 1368, 322, 1348, 333, 1357, 350], + [ + 37.4, 8.5, -980, -889, -966, -897, -975, -913, -1017, -890, -1002, -863, + -1009, -859, -997, -838, -979, -847, -999, -882, -981, -892 + ], + [ + 37.4, 13.4, -203, -240, -179, -254, -192, -277, -211, -266, -217, -266, + -230, -259, -231, -254, -229, -238, -221, -243 + ], + [ + 37.5, 8.5, -952, -816, -963, -835, -981, -825, -968, -802, -960, -807, + -962, -811 + ], + [37.5, 5.8, 868, -912, 835, -894, 846, -875, 879, -893], + [37.5, 7.9, -1074, -774, -1061, -751, -1054, -753, -1068, -778], + [37.5, 7.9, -1064, -756, -1074, -774, -1081, -770, -1071, -752], + [37.6, 7.3, 1478, 597, 1468, 580, 1448, 591, 1458, 608], + [ + 37.6, 13.1, 792, 153, 787, 142, 784, 144, 778, 134, 765, 141, 771, 151, + 768, 153, 773, 163 + ], + [ + 37.6, 5.2, -1301, 134, -1313, 113, -1335, 127, -1341, 123, -1347, 125, + -1349, 128, -1349, 145, -1348, 147, -1351, 149, -1342, 164, -1304, 142, + -1306, 138, -1305, 136 + ], + [37.6, 9.1, -847, -786, -859, -808, -870, -802, -857, -780], + [ + 37.6, 12.2, -231, -1378, -244, -1402, -257, -1395, -242, -1368, -236, + -1372, -237, -1375 + ], + [ + 37.6, 7.6, -1234, -969, -1238, -976, -1241, -974, -1253, -996, -1261, + -991, -1249, -970, -1251, -969, -1247, -961 + ], + [ + 37.6, 13.4, -96, -121, -100, -129, -102, -128, -104, -131, -105, -130, + -110, -135, -105, -138, -110, -146, -123, -138, -119, -130, -117, -131, + -115, -129, -114, -130, -111, -126, -113, -125, -112, -123, -114, -122, + -109, -114 + ], + [ + 37.6, 9.4, 733, -767, 734, -766, 747, -774, 748, -773, 751, -775, 750, + -776, 769, -787, 770, -785, 773, -787, 772, -788, 779, -792, 780, -791, + 792, -799, 784, -813, 778, -810, 777, -811, 762, -801, 761, -802, 748, + -793, 747, -795, 741, -791, 741, -790, 732, -784, 731, -786, 719, -777, + 727, -763 + ], + [ + 37.7, 18.3, 553, -98, 558, -100, 551, -114, 545, -110, 546, -108, 530, + -99, 534, -91, 549, -98, 550, -96 + ], + [37.7, 11, -480, -587, -494, -611, -514, -600, -501, -576], + [37.7, 19.2, 541, 837, 533, 824, 507, 838, 514, 852], + [37.8, 11, -140, -1330, -129, -1335, -137, -1349, -157, -1338, -150, -1324], + [ + 37.8, 15.2, 154, 1206, 165, 1200, 151, 1174, 145, 1177, 147, 1183, 147, + 1181, 144, 1183, 142, 1177, 106, 1197, 120, 1222, 122, 1221, 124, 1223 + ], + [ + 37.8, 9.4, -5, -1418, -24, -1407, -21, -1401, -48, -1386, -46, -1383, -49, + -1381, -43, -1371, -18, -1385, -15, -1380, 10, -1395, -1, -1416, -3, -1415 + ], + [ + 37.8, 8.2, -1066, -630, -1078, -651, -1084, -647, -1081, -641, -1089, + -639, -1080, -623 + ], + [37.9, 12.8, -450, -1332, -463, -1356, -480, -1346, -467, -1323], + [ + 37.9, 9.4, -65, -1065, -70, -1075, -84, -1067, -81, -1063, -79, -1064, + -77, -1060, -72, -1062, -67, -1054, -70, -1052, -64, -1042, -57, -1046, + -58, -1048, -56, -1049 + ], + [ + 37.9, 14.9, 747, 36, 740, 24, 710, 41, 716, 51, 719, 49, 725, 60, 744, 47, + 746, 50, 750, 48, 744, 37 + ], + [38, 9.4, 370, -1012, 360, -1030, 300, -997, 310, -979], + [ + 38, 10.7, -143, -877, -150, -889, -153, -887, -155, -891, -152, -892, + -157, -900, -163, -897, -150, -873 + ], + [ + 38.1, 5.5, 809, -277, 818, -262, 843, -276, 839, -282, 841, -283, 836, + -292, 827, -288, 826, -290, 816, -284, 817, -282 + ], + [38.1, 12.5, -407, -994, -411, -1001, -437, -986, -434, -979], + [38.1, 6.4, 449, -1012, 465, -1021, 451, -1047, 435, -1038], + [38.1, 11.9, -512, -887, -524, -909, -532, -904, -519, -881, -511, -886], + [ + 38.1, 10.7, -130, -1335, -140, -1330, -138, -1326, -148, -1320, -150, + -1324, -155, -1321, -147, -1307, -121, -1321 + ], + [ + 38.1, 7.3, 1486, 549, 1477, 534, 1471, 538, 1470, 536, 1456, 544, 1457, + 546, 1453, 548, 1461, 563, 1465, 561, 1466, 563, 1482, 554, 1481, 552 + ], + [38.1, 17.7, 409, 1065, 423, 1058, 408, 1031, 385, 1044, 399, 1071], + [38.1, 18.9, 488, 1054, 474, 1029, 466, 1034, 481, 1060, 489, 1056], + [ + 38.1, 12.2, -490, -1406, -501, -1428, -522, -1416, -519, -1411, -529, + -1406, -524, -1398, -525, -1395, -540, -1387, -537, -1380 + ], + [ + 38.1, 12.8, -449, -1179, -459, -1198, -466, -1194, -454, -1172, -447, + -1176 + ], + [ + 38.1, 9.8, -837, -390, -841, -398, -843, -397, -853, -415, -860, -411, + -850, -393, -852, -392, -856, -400, -859, -398, -862, -404, -876, -396, + -869, -383, -872, -382, -867, -374 + ], + [38.1, 3.4, -1512, 130, -1528, 102, -1554, 117, -1538, 145], + [38.1, 14.9, -256, 605, -269, 582, -275, 585, -261, 608], + [38.2, 11.6, -267, -1256, -288, -1244, -282, -1233, -261, -1244], + [ + 38.2, 11.3, -636, -1208, -647, -1229, -650, -1227, -655, -1231, -659, + -1229, -644, -1202, -635, -1207 + ], + [38.2, 9.8, -851, 193, -856, 183, -872, 192, -864, 206, -848, 197], + [ + 38.2, 10.7, -666, -1063, -675, -1079, -682, -1075, -670, -1052, -663, + -1056, -667, -1062 + ], + [ + 38.2, 16.2, -178, 833, -174, 831, -188, 805, -228, 828, -214, 853, -187, + 838, -172, 865, -166, 863, -182, 835 + ], + [ + 38.2, 17.1, 78, 922, 72, 911, 71, 912, 69, 907, 70, 907, 62, 892, 56, 895, + 57, 897, 55, 899, 62, 911, 66, 909, 68, 914, 64, 916, 70, 926 + ], + [ + 38.2, 23.5, 284, 602, 355, 563, 334, 524, 339, 521, 325, 496, 319, 499, + 298, 460, 227, 499 + ], + [38.3, 11.6, -212, -962, -227, -987, -237, -982, -223, -956], + [38.3, 12.5, -394, -971, -398, -978, -424, -963, -420, -956], + [ + 38.3, 21.9, 565, 91, 556, 74, 533, 85, 535, 87, 525, 93, 536, 112, 543, + 109, 541, 105, 543, 103, 547, 109, 566, 99, 562, 93 + ], + [38.3, 21, 695, 1269, 681, 1243, 667, 1251, 681, 1277], + [38.4, 9.4, -759, 158, -766, 145, -784, 155, -777, 168], + [ + 38.4, 11.9, -523, -1361, -524, -1362, -532, -1374, -533, -1374, -540, + -1387, -545, -1384, -531, -1358, -532, -1358, -530, -1355, -522, -1360 + ], + [ + 38.4, 4.9, 469, -1218, 464, -1228, 462, -1227, 456, -1239, 447, -1234, + 446, -1237, 441, -1234, 456, -1208, 470, -1216 + ], + [38.4, 12.2, 1235, 508, 1225, 491, 1198, 506, 1208, 524], + [ + 38.5, 6.7, 949, -786, 953, -788, 940, -811, 894, -786, 897, -781, 895, + -780, 903, -766, 944, -788, 945, -785 + ], + [ + 38.7, 6.4, 823, -251, 835, -230, 862, -245, 848, -269, 839, -264, 841, + -261, 836, -258, 834, -262, 825, -256, 827, -253 + ], + [ + 38.7, 6.7, 297, -1120, 295, -1123, 292, -1122, 289, -1126, 291, -1126, + 278, -1149, 266, -1143, 265, -1145, 259, -1141, 266, -1128, 260, -1125, + 271, -1106 + ], + [ + 38.7, 12.5, -320, -1074, -291, -1090, -292, -1092, -290, -1093, -303, + -1116, -347, -1091, -341, -1062 + ], + [ + 38.7, 8.8, -1028, -1028, -1042, -1053, -1058, -1045, -1043, -1017, -1027, + -1026 + ], + [38.7, 9.1, -1088, 987, -1101, 994, -1089, 1014, -1077, 1007], + [38.7, 7.3, -1058, -666, -1071, -690, -1081, -685, -1068, -660], + [ + 38.8, 8.2, -924, -578, -916, -582, -927, -601, -950, -588, -945, -578, + -947, -576, -942, -567 + ], + [ + 38.8, 9.4, 307, -984, 300, -997, 294, -994, 299, -986, 297, -985, 300, + -980 + ], + [ + 38.8, 11, -198, -970, -196, -971, -210, -997, -227, -987, -221, -979, + -218, -981, -213, -972, -216, -970, -212, -962 + ], + [ + 38.8, 5.5, 424, -1279, 410, -1305, 384, -1291, 386, -1288, 360, -1273, + 373, -1251 + ], + [ + 38.9, 18.6, 465, 846, 453, 825, 442, 831, 457, 858, 460, 856, 458, 854, + 467, 849 + ], + [38.9, 9.1, -774, 111, -787, 89, -813, 104, -801, 126], + [38.9, 21.6, 698, 1121, 688, 1103, 635, 1132, 645, 1150], + [ + 38.9, 9.1, 1362, 709, 1359, 705, 1357, 706, 1356, 703, 1353, 705, 1351, + 701, 1355, 698, 1351, 691, 1328, 704, 1332, 712, 1345, 704, 1348, 711, + 1335, 718, 1340, 726, 1363, 713 + ], + [ + 39, 5.5, -1238, -789, -1245, -801, -1249, -798, -1248, -797, -1258, -793, + -1252, -781 + ], + [39, 9.8, -711, -653, -725, -678, -732, -674, -718, -649], + [39, 4.9, 868, -912, 863, -921, 874, -926, 868, -936, 825, -913, 835, -894], + [ + 39, 2.7, -1508, 43, -1514, 32, -1533, 43, -1544, 22, -1552, 26, -1539, 49, + -1532, 45, -1528, 53 + ], + [ + 39.1, 10.7, -690, -921, -693, -927, -675, -937, -699, -981, -769, -942, + -741, -893 + ], + [ + 39.1, 21, 852, 1253, 846, 1242, 812, 1261, 819, 1275, 832, 1267, 831, 1265 + ], + [39.1, 11.3, 5, -452, -6, -472, -31, -458, -24, -445, -16, -450, -12, -442], + [ + 39.1, 18.6, 664, 28, 663, 26, 678, 17, 673, 9, 659, 17, 658, 15, 650, 19, + 657, 32 + ], + [ + 39.2, 10.4, 280, -676, 285, -679, 278, -692, 261, -682, 265, -673, 266, + -674, 268, -670 + ], + [39.3, 2.7, -1392, -187, -1404, -209, -1424, -198, -1412, -176], + [39.3, 20.1, 225, 64, 215, 46, 194, 58, 204, 76], + [ + 39.3, 10.7, 201, -629, 195, -640, 199, -642, 193, -652, 190, -651, 188, + -655, 191, -657, 186, -666, 170, -657, 184, -631, 191, -635, 205, -609, + 211, -612 + ], + [ + 39.4, 11.6, -1, -405, -5, -412, -7, -411, -27, -446, -25, -448, -31, -458, + -44, -450, -38, -440, -36, -442, -17, -409, -20, -407, -14, -397 + ], + [ + 39.4, 9.1, -851, -1182, -864, -1205, -872, -1200, -858, -1176, -850, -1181 + ], + [39.6, 14.6, -1, 1236, -16, 1210, -25, 1215, -10, 1241], + [39.6, 21, 672, 1075, 669, 1069, 616, 1097, 626, 1116, 679, 1087], + [ + 39.6, 13.4, -360, -334, -373, -357, -400, -343, -394, -333, -392, -334, + -390, -330, -392, -329, -386, -319, -377, -324, -381, -331, -374, -335, + -370, -328 + ], + [39.6, 11, -220, -1014, -233, -1036, -239, -1033, -227, -1010], + [ + 39.7, 14.3, -878, 612, -900, 573, -951, 602, -938, 626, -937, 628, -939, + 629, -924, 655, -871, 625 + ], + [ + 39.7, 9.8, -838, -1112, -857, -1102, -849, -1089, -835, -1096, -836, + -1097, -808, -1111, -813, -1120, -815, -1119, -818, -1126, -821, -1125, + -823, -1129, -830, -1126, -826, -1119 + ], + [ + 39.9, 9.4, 372, -486, 377, -489, 377, -490, 396, -501, 390, -512, 363, + -496, 370, -484 + ], + [ + 39.9, 13.1, -407, -994, -400, -998, -412, -1018, -418, -1015, -416, -1011, + -424, -1007, -425, -1008, -444, -998, -437, -986, -411, -1001 + ], + [39.9, 9.8, 798, -72, 811, -79, 800, -98, 774, -84, 785, -65], + [ + 39.9, 9.8, 222, -829, 207, -857, 195, -850, 206, -831, 211, -834, 229, + -801, 236, -805 + ], + [40, 19.8, 412, 827, 384, 773, 351, 792, 362, 813, 366, 811, 384, 842], + [40.1, 10.4, -701, -1086, -713, -1109, -720, -1105, -708, -1082], + [ + 40.2, 6.4, 182, -1267, 218, -1287, 232, -1263, 265, -1281, 252, -1305, + 241, -1299, 227, -1322, 177, -1293, 175, -1295, 138, -1274, 152, -1250 + ], + [40.2, 2.7, -1595, 28, -1574, 17, -1589, -9, -1609, 2], + [40.2, 8.2, 14, -1076, -16, -1060, -6, -1043, 24, -1058], + [40.2, 8.5, 449, -1012, 439, -1030, 424, -1021, 434, -1003], + [ + 40.2, 8.5, 287, -974, 298, -979, 295, -984, 299, -986, 294, -994, 274, + -983, 281, -970 + ], + [ + 40.3, 23.2, 527, 299, 515, 276, 494, 287, 499, 295, 504, 292, 508, 298, + 502, 301, 507, 310 + ], + [ + 40.4, 8.8, -871, -1311, -863, -1316, -878, -1343, -891, -1336, -876, -1308 + ], + [ + 40.4, 9.4, 370, -534, 366, -532, 369, -528, 362, -525, 366, -519, 381, + -527, 376, -537 + ], + [40.4, 10.7, -474, -539, -486, -561, -498, -554, -486, -532], + [ + 40.4, 6.1, -1244, -735, -1232, -741, -1234, -745, -1213, -757, -1223, + -776, -1257, -757 + ], + [ + 40.5, 7.6, -1196, -812, -1207, -833, -1230, -820, -1230, -822, -1235, + -819, -1224, -797 + ], + [40.5, 11.9, -269, -1008, -260, -992, -247, -999, -259, -1021, -272, -1014], + [ + 40.6, 18, 2, 570, -18, 532, -45, 547, -34, 568, -18, 559, -2, 586, 6, 582, + 0, 571 + ], + [ + 40.6, 4, -1510, 337, -1519, 322, -1525, 325, -1526, 324, -1552, 340, + -1542, 357, -1509, 338 + ], + [ + 40.7, 7.3, -1120, -664, -1132, -657, -1124, -643, -1116, -648, -1114, + -645, -1111, -647 + ], + [ + 40.7, 9.4, -839, -1208, -830, -1192, -803, -1206, -814, -1226, -836, + -1213, -834, -1211 + ], + [ + 40.8, 6.7, -1119, -635, -1132, -657, -1152, -646, -1137, -618, -1132, + -621, -1135, -626 + ], + [ + 40.8, 9.4, -733, -551, -748, -577, -767, -566, -753, -540, -746, -544, + -747, -548, -743, -550, -741, -547 + ], + [ + 40.8, 12.8, -976, 766, -985, 750, -988, 752, -986, 756, -989, 758, -983, + 769 + ], + [40.8, 8.8, -825, -590, -835, -608, -847, -600, -838, -583], + [ + 40.8, 13.1, -334, 686, -348, 660, -368, 671, -367, 673, -370, 675, -357, + 698 + ], + [ + 40.8, 10.1, 650, -241, 637, -234, 640, -229, 637, -228, 639, -224, 636, + -221, 642, -212, 662, -223 + ], + [ + 40.8, 8.8, -794, -155, -801, -167, -805, -167, -836, -148, -830, -136, + -826, -138, -826, -136, -820, -141, -819, -140, -813, -144, -814, -145, + -803, -149, -804, -150, -797, -152, -798, -154 + ], + [40.9, 20.1, 667, 923, 634, 941, 639, 949, 672, 931], + [ + 40.9, 11.9, -502, -977, -510, -991, -484, -1006, -488, -1014, -533, -989, + -520, -966 + ], + [40.9, 16.5, 45, 939, 29, 910, 25, 912, 35, 931, 34, 932, 39, 943], + [ + 40.9, 4.3, -1466, 459, -1480, 433, -1534, 463, -1526, 476, -1541, 484, + -1531, 503, -1504, 489, -1508, 482 + ], + [40.9, 11.6, -520, -883, -532, -904, -547, -896, -535, -874], + [41, 10.7, -587, -1014, -599, -1036, -613, -1029, -601, -1007], + [41, 10.1, -750, -846, -796, -821, -778, -789, -732, -815], + [ + 41, 9.4, -1055, -1114, -1065, -1133, -1071, -1129, -1070, -1127, -1072, + -1126, -1068, -1120, -1067, -1121, -1056, -1102, -1050, -1106 + ], + [41.1, 14.6, -146, 1043, -160, 1018, -177, 1028, -163, 1054, -145, 1045], + [ + 41.1, 15, -1498, 264, -1468, 318, -1421, 291, -1437, 264, -1470, 283, + -1485, 257 + ], + [ + 41.1, 3.7, -1431, 385, -1442, 365, -1448, 368, -1448, 370, -1456, 375, + -1457, 373, -1469, 379, -1468, 381, -1476, 386, -1477, 384, -1482, 387, + -1471, 407 + ], + [41.1, 8.5, -993, -1207, -959, -1225, -974, -1253, -1008, -1234], + [ + 41.1, 4, -1392, 429, -1403, 435, -1403, 436, -1410, 440, -1442, 455, + -1434, 471, -1400, 452, -1396, 446 + ], + [41.1, 3, -1512, 429, -1526, 403, -1546, 414, -1531, 440], + [ + 41.1, 13.1, -310, -474, -287, -479, -289, -492, -290, -493, -315, -479, + -312, -474 + ], + [41.1, 15, -1496, 332, -1468, 317, -1498, 264, -1523, 278], + [41.1, 12.2, -993, 281, -1004, 260, -1031, 274, -1019, 295], + [41.1, 9.4, -660, -243, -666, -254, -691, -240, -685, -230], + [ + 41.1, 8.8, -738, -12, -743, -20, -751, -15, -751, -17, -768, -5, -761, 8, + -735, -6 + ], + [41.1, 6.1, -825, 1351, -852, 1365, -825, 1414, -798, 1400], + [41.2, 10.7, -138, -1228, -152, -1251, -158, -1248, -145, -1224], + [41.3, 11.9, -366, -598, -379, -620, -393, -613, -380, -590], + [ + 41.4, 9.1, 767, -837, 760, -850, 739, -838, 737, -841, 733, -838, 727, + -835, 728, -832, 707, -821, 715, -807, 768, -836 + ], + [ + 41.4, 20.4, 293, 785, 288, 788, 287, 787, 273, 762, 273, 760, 278, 758, + 271, 745, 257, 753, 287, 806, 300, 798 + ], + [41.4, 11, -40, -533, -43, -540, -69, -525, -65, -519], + [ + 41.5, 9.1, 380, -467, 397, -477, 392, -486, 401, -491, 397, -499, 370, + -484 + ], + [41.5, 9.1, -862, -828, -872, -846, -906, -827, -897, -808], + [ + 41.5, 11.9, -395, -772, -410, -798, -431, -786, -417, -760, -409, -764, + -414, -772, -407, -776, -402, -768 + ], + [41.5, 9.4, -778, -789, -805, -838, -827, -826, -800, -777], + [41.5, 9.1, -813, -620, -803, -603, -792, -609, -801, -626], + [ + 41.6, 12.2, -375, -1123, -402, -1109, -404, -1112, -408, -1109, -406, + -1106, -425, -1095, -431, -1107, -415, -1116, -425, -1133, -443, -1123, + -430, -1098, -432, -1096, -431, -1094, -482, -1066, -470, -1044, -371, + -1099 + ], + [ + 41.6, 11.9, -321, 1230, -339, 1198, -337, 1196, -347, 1177, -360, 1184, + -346, 1211, -344, 1210, -329, 1236 + ], + [ + 41.6, 17.7, 1101, 987, 1071, 937, 1041, 954, 1050, 970, 1047, 972, 1048, + 975, 1029, 986, 1032, 992, 1031, 993, 1043, 1014, 1052, 1009, 1051, 1007, + 1065, 999, 1070, 1006, 1089, 996, 1088, 994 + ], + [41.8, 9.8, -808, -858, -835, -906, -888, -876, -862, -828], + [ + 41.8, 11, -648, -1094, -655, -1090, -646, -1074, -642, -1076, -641, -1072, + -637, -1074 + ], + [ + 41.8, 12.8, -795, 762, -813, 730, -820, 734, -823, 728, -828, 731, -829, + 730, -856, 745, -852, 752, -828, 780 + ], + [ + 41.8, 11, -179, -893, -191, -916, -200, -911, -196, -903, -194, -903, + -187, -888 + ], + [ + 41.8, 2.7, -1532, 173, -1544, 150, -1602, 182, -1603, 180, -1605, 181, + -1592, 205 + ], + [ + 41.8, 9.1, -53, -975, -44, -978, -40, -971, -28, -978, -27, -975, -25, + -976, -39, -1003, -80, -980, -71, -965 + ], + [ + 41.8, 2.7, -1544, 22, -1537, 34, -1534, 33, -1533, 35, -1526, 31, -1523, + 37, -1514, 32, -1525, 11 + ], + [41.9, 11, -621, -1079, -634, -1102, -648, -1094, -635, -1071], + [ + 41.9, 3.4, 1017, -451, 1017, -453, 1010, -466, 1029, -476, 1022, -489, + 993, -473, 1008, -446 + ], + [ + 42, 23.8, 765, 1162, 803, 1141, 805, 1145, 832, 1130, 829, 1126, 848, + 1116, 845, 1110, 849, 1107, 849, 1104, 847, 1101, 858, 1095, 859, 1091, + 857, 1087, 853, 1086, 842, 1092, 841, 1088, 838, 1087, 833, 1089, 830, + 1084, 811, 1094, 809, 1090, 782, 1104, 784, 1108, 747, 1128 + ], + [42, 19.8, 334, 832, 320, 807, 301, 818, 306, 826, 308, 827, 315, 843], + [ + 42.1, 21, 370, -15, 375, -18, 374, -20, 377, -22, 369, -35, 328, -13, 336, + 1, 339, -1, 340, 2 + ], + [ + 42.1, 23.5, 491, 170, 489, 167, 482, 171, 480, 170, 469, 176, 469, 178, + 462, 182, 471, 198, 498, 183 + ], + [ + 42.1, 12.5, 449, -248, 467, -258, 456, -279, 414, -254, 421, -241, 446, + -254 + ], + [42.1, 11.6, -619, -1109, -607, -1087, -600, -1091, -612, -1113], + [ + 42.1, 8.8, -733, -596, -743, -614, -757, -604, -758, -605, -782, -592, + -772, -574 + ], + [42.1, 3.4, -1502, 53, -1522, 64, -1517, 75, -1496, 64], + [ + 42.2, 6.7, 269, -1325, 264, -1323, 260, -1331, 264, -1333, 259, -1341, + 248, -1335, 249, -1333, 240, -1328, 239, -1330, 227, -1323, 232, -1315, + 239, -1319, 241, -1314, 238, -1313, 240, -1310, 236, -1307, 238, -1303, + 252, -1311, 250, -1314, 258, -1318, 259, -1315, 271, -1321 + ], + [ + 42.2, 12.8, -437, -924, -463, -910, -461, -907, -468, -904, -465, -898, + -471, -894, -462, -879, -424, -900 + ], + [42.2, 11, -451, -576, -440, -557, -414, -572, -427, -594, -453, -579], + [ + 42.2, 19.8, 1196, 13, 1203, 11, 1204, 14, 1217, 7, 1215, 4, 1227, -3, + 1219, -17, 1207, -11, 1206, -13, 1199, -10, 1197, -13, 1218, -25, 1216, + -29, 1195, -17, 1192, -21, 1199, -25, 1198, -27, 1209, -33, 1200, -51, + 1137, -17, 1151, 10, 1160, 4, 1164, 11, 1169, 8, 1178, 27, 1196, 17, 1194, + 14 + ], + [42.2, 8.5, -850, -204, -865, -230, -887, -218, -873, -192], + [ + 42.3, 7.9, 42, -1013, 49, -1017, 34, -1043, 14, -1032, 19, -1023, 25, + -1026, 32, -1014, 29, -1013, 30, -1009, 29, -1008, 30, -1006 + ], + [ + 42.3, 10.4, -103, -1368, -114, -1361, -100, -1334, -90, -1339, -91, -1341, + -65, -1355, -64, -1353, -49, -1362, -58, -1377, -61, -1375, -63, -1379, + -77, -1371, -78, -1374, -91, -1367, -89, -1364, -96, -1360, -101, -1369 + ], + [ + 42.3, 8.2, -866, -19, -863, -21, -862, -19, -822, -41, -830, -57, -793, + -78, -795, -81, -793, -83, -807, -108, -809, -107, -811, -110, -848, -90, + -843, -79, -864, -67, -870, -78, -901, -61, -874, -12, -865, -18 + ], + [ + 42.5, 3.7, 700, -1426, 710, -1441, 712, -1440, 715, -1444, 716, -1443, + 721, -1450, 719, -1451, 722, -1455, 720, -1456, 730, -1472, 718, -1479, + 709, -1464, 707, -1465, 704, -1461, 703, -1462, 698, -1454, 700, -1453, + 697, -1450, 699, -1448, 689, -1433 + ], + [ + 42.5, 16.8, -120, 695, -121, 692, -125, 694, -126, 691, -122, 689, -107, + 686, -110, 673, -132, 685, -126, 696 + ], + [42.5, 13.1, -50, -149, -63, -172, -70, -168, -56, -143, -49, -147], + [ + 42.6, 11.3, -92, -1542, -76, -1551, -80, -1558, -82, -1557, -89, -1570, + -87, -1571, -91, -1577, -110, -1567, -108, -1563, -111, -1561, -112, + -1563, -122, -1558, -122, -1556, -125, -1554, -126, -1557, -136, -1552, + -135, -1551, -138, -1549, -134, -1541, -132, -1541, -131, -1538, -129, + -1539, -125, -1533, -104, -1545, -105, -1546, -98, -1550, -96, -1549 + ], + [ + 42.6, 4, 673, -1447, 680, -1458, 664, -1468, 665, -1470, 661, -1473, 662, + -1474, 655, -1479, 654, -1477, 650, -1480, 649, -1478, 633, -1488, 626, + -1476, 642, -1466, 640, -1465, 644, -1462, 644, -1461, 651, -1456, 652, + -1457, 656, -1455, 657, -1457 + ], + [42.6, 11.3, -346, 1211, -360, 1184, -381, 1196, -366, 1222], + [ + 42.7, 8.5, -908, -1288, -901, -1291, -902, -1294, -889, -1301, -904, + -1328, -931, -1314, -914, -1284 + ], + [42.7, 8.8, -887, -1266, -901, -1291, -908, -1288, -894, -1263], + [42.7, 23.5, 227, 157, 203, 170, 221, 202, 263, 179, 249, 154, 231, 164], + [ + 42.7, 11.6, -987, -1165, -992, -1173, -1052, -1140, -1041, -1121, -1034, + -1125, -1036, -1128, -983, -1157 + ], + [ + 42.7, 11.6, 144, -321, 142, -325, 138, -323, 136, -327, 134, -325, 133, + -327, 108, -314, 120, -294, 144, -307, 138, -318 + ], + [42.7, 12.5, -479, -271, -490, -293, -501, -287, -488, -263, -477, -269], + [ + 42.7, 17.7, 92, 1430, 112, 1419, 95, 1385, 65, 1402, 80, 1428, 86, 1425, + 90, 1431 + ], + [ + 42.7, 6.7, -1146, -432, -1159, -455, -1160, -455, -1163, -461, -1187, + -447, -1171, -418 + ], + [42.7, 8.8, -820, -221, -835, -247, -859, -233, -845, -207], + [42.7, 10.7, -699, -1395, -704, -1404, -732, -1388, -728, -1379], + [ + 42.8, 4, 614, -1331, 622, -1329, 623, -1331, 640, -1322, 646, -1333, 630, + -1342, 631, -1344, 627, -1346, 628, -1348, 620, -1352, 619, -1351, 615, + -1353, 614, -1351, 598, -1360, 592, -1348, 608, -1339, 607, -1337 + ], + [ + 42.8, 7.9, 435, -1038, 451, -1047, 436, -1073, 413, -1060, 424, -1041, + 421, -1039, 425, -1033 + ], + [ + 42.8, 4.3, 594, -1398, 601, -1409, 585, -1419, 586, -1421, 583, -1424, + 584, -1425, 576, -1430, 575, -1428, 572, -1431, 570, -1429, 555, -1439, + 547, -1427, 563, -1417, 561, -1415, 565, -1413, 565, -1412, 572, -1407, + 573, -1408, 577, -1406, 578, -1408 + ], + [42.9, 13.4, -133, -104, -145, -126, -155, -121, -141, -98], + [43, 19.8, 279, 842, 294, 833, 290, 825, 271, 836, 275, 844], + [ + 43, 4.3, 545, -1485, 540, -1478, 542, -1477, 539, -1473, 541, -1472, 531, + -1456, 543, -1449, 553, -1465, 555, -1463, 557, -1467, 559, -1466, 563, + -1474, 562, -1475, 564, -1479, 562, -1480, 572, -1495, 561, -1503, 551, + -1487, 549, -1488, 546, -1484 + ], + [ + 43, 3.4, 730, -1372, 740, -1387, 742, -1386, 745, -1390, 746, -1389, 751, + -1396, 749, -1397, 752, -1401, 750, -1402, 760, -1418, 748, -1425, 738, + -1410, 736, -1411, 734, -1407, 732, -1408, 728, -1401, 730, -1400, 727, + -1396, 729, -1394, 719, -1379 + ], + [43, 11.3, -539, -1007, -551, -1028, -564, -1020, -552, -999], + [ + 43, 5.2, 512, -1241, 498, -1265, 456, -1242, 469, -1218, 475, -1221, 476, + -1219, 485, -1224, 484, -1226, 497, -1233, 497, -1231, 503, -1234, 506, + -1236, 506, -1238 + ], + [ + 43, 3.7, 673, -1340, 683, -1356, 685, -1355, 688, -1359, 689, -1358, 694, + -1365, 692, -1366, 695, -1370, 693, -1371, 703, -1387, 692, -1394, 682, + -1378, 680, -1379, 677, -1376, 676, -1376, 671, -1369, 673, -1368, 670, + -1364, 672, -1363, 662, -1347 + ], + [ + 43, 21.9, 573, 159, 571, 156, 582, 151, 579, 145, 584, 142, 579, 133, 572, + 137, 574, 141, 566, 145, 565, 146, 563, 142, 554, 147, 564, 164 + ], + [ + 43.1, 4, 627, -1387, 635, -1399, 637, -1398, 639, -1402, 640, -1401, 645, + -1408, 644, -1409, 646, -1413, 644, -1414, 654, -1430, 643, -1437, 633, + -1422, 631, -1423, 628, -1419, 627, -1420, 622, -1413, 624, -1412, 621, + -1408, 623, -1407, 613, -1391, 625, -1384 + ], + [43.1, 12.2, -511, -339, -525, -363, -538, -356, -524, -332], + [43.1, 19.8, 401, 743, 388, 719, 375, 727, 388, 750], + [ + 43.1, 3.7, 598, -1479, 608, -1495, 610, -1494, 612, -1498, 614, -1497, + 619, -1504, 617, -1505, 619, -1509, 618, -1510, 627, -1526, 616, -1533, + 606, -1517, 604, -1519, 602, -1515, 600, -1516, 596, -1508, 597, -1507, + 595, -1504, 597, -1502, 587, -1486 + ], + [ + 43.1, 10.7, 340, -726, 333, -740, 365, -757, 362, -763, 335, -749, 336, + -746, 330, -742, 326, -742, 324, -743, 323, -740, 318, -737, 316, -738, + 315, -736, 311, -733, 310, -735, 296, -727, 302, -717, 304, -718, 308, + -709 + ], + [43.1, 11.9, -443, -467, -429, -474, -442, -497, -469, -482, -456, -459], + [ + 43.1, 12.2, -358, -566, -364, -575, -367, -574, -370, -580, -367, -581, + -371, -589, -375, -587, -375, -588, -385, -582, -381, -574, -377, -576, + -373, -569, -377, -567, -372, -559 + ], + [43.2, 22.9, 227, 157, 231, 155, 225, 143, 198, 158, 204, 170], + [ + 43.2, 9.8, -780, -1077, -770, -1083, -782, -1105, -799, -1096, -787, -1074 + ], + [ + 43.2, 22.3, 388, 16, 382, 7, 377, 9, 373, 1, 340, 19, 345, 27, 341, 29, + 346, 39 + ], + [43.2, 12.5, -440, -838, -425, -811, -418, -814, -434, -841], + [43.2, 12.2, 345, -720, 376, -737, 372, -744, 340, -726, 344, -720], + [43.3, 10.4, -112, -1242, -125, -1266, -138, -1259, -125, -1235], + [43.3, 11.6, -235, -1040, -247, -1062, -253, -1058, -240, -1036], + [43.3, 20.1, 611, 27, 624, 20, 615, 4, 592, 16, 601, 32], + [ + 43.3, 4, 1002, -457, 994, -471, 988, -467, 987, -470, 945, -446, 946, + -444, 941, -441, 948, -428, 954, -431, 955, -429, 996, -452, 995, -454 + ], + [43.4, 11, -444, 728, -452, 714, -469, 724, -461, 738], + [ + 43.4, 3.7, 980, -502, 971, -518, 934, -497, 943, -482, 949, -485, 950, + -484 + ], + [43.4, 12.5, 265, -399, 274, -404, 268, -418, 241, -403, 248, -390], + [ + 43.4, 20.4, 147, 129, 114, 147, 109, 139, 103, 142, 104, 145, 99, 148, + 112, 171, 157, 147 + ], + [43.4, 20.7, 119, 456, 133, 480, 143, 474, 132, 454, 128, 452], + [43.5, 11.9, -442, -497, -429, -474, -416, -481, -429, -504], + [43.5, 15.2, 1139, 50, 1130, 34, 1124, 40, 1122, 39, 1119, 45, 1126, 58], + [43.6, 24.4, 356, 271, 341, 245, 328, 252, 343, 278], + [43.6, 11, -612, -881, -624, -903, -638, -896, -625, -873], + [43.6, 3.7, -1478, 410, -1471, 407, -1481, 389, -1488, 392], + [ + 43.6, 40.5, 200, -1347, 177, -1335, 183, -1325, 203, -1336, 199, -1343, + 202, -1344 + ], + [43.6, 11, -599, -888, -611, -910, -624, -903, -612, -881], + [43.6, 7.3, -820, -660, -842, -648, -827, -622, -806, -634], + [ + 43.6, 11.9, -244, -947, -257, -971, -269, -964, -263, -954, -261, -956, + -259, -952, -261, -950, -255, -941, -251, -943, -250, -941, -247, -943, + -248, -945 + ], + [ + 43.6, 11, -491, -684, -520, -737, -540, -726, -529, -707, -536, -703, + -518, -670 + ], + [ + 43.6, 9.8, -100, -1210, -97, -1212, -105, -1225, -120, -1216, -113, -1203, + -110, -1205, -105, -1196, -96, -1201 + ], + [43.7, 17.4, -42, 491, -55, 466, -66, 470, -52, 496], + [ + 43.7, 9.8, -626, -515, -652, -561, -665, -554, -653, -532, -650, -533, + -643, -520, -646, -519, -636, -501, -623, -509 + ], + [43.7, 9.4, -732, -620, -743, -614, -730, -590, -719, -596], + [ + 43.8, 17.7, 1168, 292, 1189, 281, 1170, 248, 1149, 260, 1164, 287, 1159, + 289, 1163, 295 + ], + [ + 43.9, 11.9, -489, -843, -472, -812, -474, -811, -462, -790, -425, -811, + -440, -837, -446, -833, -461, -859 + ], + [ + 43.9, 49.4, 206, -1383, 200, -1394, 170, -1377, 176, -1366, 182, -1369, + 185, -1364, 204, -1374, 200, -1380 + ], + [43.9, 8.5, -605, -340, -600, -342, -615, -369, -620, -366], + [44, 13.4, -170, -223, -183, -246, -189, -242, -177, -219], + [44, 12.2, -510, -854, -522, -875, -535, -868, -523, -845, -509, -853], + [ + 44, 8.8, -818, -969, -836, -959, -832, -952, -833, -949, -836, -947, -835, + -945, -838, -943, -839, -945, -841, -944, -846, -953, -858, -947, -844, + -922, -804, -944 + ], + [44, 11.6, -546, -372, -558, -395, -581, -382, -569, -360], + [44.1, 10.1, -777, -1221, -790, -1245, -797, -1242, -783, -1218], + [ + 44.1, 7.6, -1130, -765, -1147, -794, -1167, -783, -1165, -780, -1168, + -778, -1165, -772, -1151, -780, -1139, -759 + ], + [ + 44.1, 7.6, 116, -1310, 127, -1317, 125, -1320, 131, -1323, 119, -1346, + 102, -1336, 101, -1339, 82, -1328, 88, -1318, 90, -1319, 100, -1301 + ], + [ + 44.1, 4.9, 422, -1223, 418, -1232, 420, -1231, 445, -1245, 435, -1262, + 409, -1247, 407, -1249, 382, -1235, 396, -1209 + ], + [44.1, 19.2, 75, 242, 62, 219, 52, 225, 65, 248], + [ + 44.2, 8.2, 38, -1120, 32, -1130, 16, -1121, 32, -1092, 46, -1099, 35, + -1119 + ], + [44.2, 7, 761, -866, 773, -873, 761, -895, 735, -880, 745, -863, 758, -870], + [ + 44.2, 13.1, 212, -183, 210, -186, 212, -187, 208, -194, 207, -193, 205, + -197, 182, -184, 190, -171 + ], + [44.2, 9.4, -684, 110, -696, 89, -705, 94, -693, 116], + [ + 44.2, 8.2, -845, 18, -847, 14, -831, 6, -838, -7, -845, -4, -846, -6, + -866, 5, -861, 18, -858, 16, -854, 24 + ], + [ + 44.2, 5.8, 295, -1298, 307, -1305, 289, -1336, 269, -1325, 281, -1304, + 289, -1308 + ], + [44.2, 11.9, -506, -894, -517, -913, -524, -909, -512, -887, -505, -891], + [44.2, 8.8, -930, -1172, -945, -1199, -966, -1187, -951, -1160], + [ + 44.3, 10.1, -1023, 243, -1030, 229, -1037, 233, -1038, 231, -1048, 239, + -1040, 253, -1028, 248, -1029, 247 + ], + [ + 44.4, 17.4, 32, 1399, 27, 1391, 24, 1392, 20, 1386, 23, 1384, 19, 1375, 2, + 1385, 15, 1408 + ], + [44.4, 10.4, -620, 26, -633, 2, -636, 4, -638, 2, -653, 10, -638, 36], + [ + 44.4, 10.7, -662, 300, -663, 298, -642, 297, -625, 291, -609, 280, -596, + 262, -588, 262, -583, 246, -591, 242, -590, 232, -581, 232, -583, 222, + -554, 206, -577, 164, -606, 180, -613, 173, -619, 181, -627, 176, -626, + 167, -643, 163, -647, 168, -646, 170, -670, 172, -688, 179, -702, 190, + -714, 207, -715, 206, -722, 206, -726, 218, -728, 232, -735, 239, -701, + 300, -694, 296, -680, 302, -666, 306 + ], + [ + 44.4, 8.5, 352, -552, 349, -556, 351, -557, 349, -560, 333, -551, 337, + -544 + ], + [44.4, 11.9, -493, -260, -506, -284, -520, -276, -507, -253], + [44.4, 13.1, -347, -341, -360, -365, -373, -357, -360, -334], + [ + 44.4, 12.2, 1244, 514, 1228, 523, 1234, 534, 1226, 538, 1220, 527, 1213, + 531, 1228, 557, 1264, 537, 1263, 535, 1259, 538, 1249, 521, 1254, 518, + 1250, 511 + ], + [44.5, 13.7, -313, -239, -325, -261, -336, -255, -324, -233], + [44.5, 24.1, 264, 198, 230, 216, 241, 236, 275, 217], + [44.5, 10.1, -812, -715, -799, -693, -738, -727, -751, -751, -813, -717], + [44.5, 18.3, 60, 201, 45, 175, 32, 182, 46, 208], + [ + 44.5, 7, 1114, -182, 1128, -157, 1155, -171, 1169, -145, 1202, -163, 1173, + -215 + ], + [ + 44.6, 12.5, -302, -1052, -312, -1071, -317, -1068, -320, -1074, -341, + -1062, -336, -1039, -333, -1036 + ], + [ + 44.7, 4, 841, -468, 855, -476, 858, -471, 860, -472, 862, -470, 887, -484, + 882, -491, 890, -497, 881, -511, 879, -510, 878, -513, 840, -492, 841, + -489, 840, -487, 831, -482, 840, -468 + ], + [44.8, 13.4, -961, 854, -976, 828, -996, 839, -982, 865], + [44.8, 15, -1414, 307, -1433, 317, -1419, 344, -1400, 333], + [ + 44.8, 8.5, -1020, -1193, -1034, -1218, -1036, -1219, -1040, -1217, -1039, + -1216, -1048, -1211, -1034, -1185 + ], + [44.8, 17.7, 16, 187, 3, 163, -12, 171, 1, 195], + [44.8, 9.4, -823, -415, -844, -403, -837, -390, -816, -402], + [44.9, 16.2, 282, -152, 269, -176, 238, -159, 251, -135], + [44.9, 22.6, 186, 198, 153, 216, 148, 207, 143, 209, 158, 236, 195, 216], + [44.9, 18, 33, 177, 20, 154, 3, 163, 16, 187], + [44.9, 11, -676, -1100, -689, -1124, -714, -1110, -701, -1086], + [ + 44.9, 13.7, -889, 869, -887, 867, -880, 878, -873, 874, -893, 837, -926, + 855, -912, 881 + ], + [ + 45, 15.5, -40, 165, -52, 144, -53, 145, -70, 115, -95, 128, -76, 163, -70, + 159, -60, 178 + ], + [ + 45, 8.5, -908, -719, -922, -742, -919, -744, -932, -767, -972, -745, -945, + -697, -908, -718 + ], + [45, 11.3, -690, -382, -705, -408, -719, -400, -705, -373], + [45, 12.5, -480, -1346, -463, -1356, -470, -1369, -508, -1349, -501, -1335], + [ + 45, 10.4, 831, -47, 816, -73, 811, -70, 817, -60, 796, -48, 798, -45, 796, + -44, 803, -32 + ], + [ + 45, 11.9, -214, -1489, -235, -1478, -226, -1462, -232, -1459, -219, -1435, + -193, -1450 + ], + [45, 13.4, 974, 507, 963, 488, 943, 499, 958, 525, 978, 514], + [ + 45.1, 10.1, 508, -282, 511, -283, 510, -286, 521, -292, 517, -301, 514, + -299, 509, -308, 479, -291, 489, -272 + ], + [ + 45.1, 11, -628, -1041, -639, -1062, -643, -1060, -650, -1072, -646, -1074, + -655, -1090, -675, -1079, -666, -1063, -664, -1064, -657, -1052, -659, + -1051, -648, -1030 + ], + [45.1, 11, -628, -1041, -621, -1045, -632, -1065, -639, -1061], + [45.1, 12.2, -252, -399, -224, -414, -228, -420, -253, -406], + [ + 45.1, 23.5, 302, 407, 299, 408, 300, 411, 289, 418, 280, 427, 276, 429, + 277, 431, 273, 437, 274, 439, 309, 420 + ], + [45.1, 12.2, 1380, 438, 1400, 427, 1385, 400, 1366, 412], + [45.1, 11.6, 130, -326, 127, -333, 105, -320, 108, -314], + [45.1, 17.4, 2, 284, -11, 260, -27, 269, -14, 292], + [ + 45.1, 11.9, -219, -1435, -233, -1461, -248, -1453, -235, -1429, -226, + -1434, -225, -1432 + ], + [45.1, 11.3, -627, -1127, -639, -1149, -647, -1144, -635, -1123], + [ + 45.1, 4.3, -1356, -14, -1324, -32, -1336, -55, -1369, -37, -1367, -32, + -1373, -28, -1363, -10 + ], + [45.1, 11, -587, -350, -600, -371, -605, -369, -594, -346], + [ + 45.2, 12.2, -347, 1177, -335, 1199, -318, 1190, -322, 1183, -319, 1182, + -327, 1166 + ], + [45.2, 15.8, -60, 178, -70, 159, -76, 163, -80, 155, -91, 162, -77, 187], + [ + 45.3, 12.2, -266, -1202, -243, -1214, -251, -1229, -294, -1205, -284, + -1186, -279, -1189, -281, -1193 + ], + [ + 45.3, 10.4, -120, -1277, -102, -1287, -109, -1299, -130, -1288, -123, + -1276 + ], + [ + 45.3, 12.2, -410, -181, -424, -206, -451, -191, -438, -166, -418, -175, + -419, -176 + ], + [45.3, 15.5, -990, 588, -999, 571, -1026, 586, -1017, 602], + [ + 45.3, 17.1, -3, 200, -9, 190, -16, 194, -20, 187, -12, 183, -17, 174, -40, + 187, -35, 195, -29, 192, -25, 199, -32, 202, -27, 210, -9, 200, -7, 203 + ], + [45.3, 9.8, -660, -591, -674, -617, -694, -606, -680, -580], + [45.4, 8.5, -804, 59, -797, 72, -794, 71, -790, 69, -797, 55], + [45.4, 12.8, -371, -961, -361, -967, -375, -991, -388, -984, -374, -959], + [ + 45.4, 4.9, -1353, 515, -1291, 480, -1293, 476, -1289, 474, -1313, 432, + -1378, 468, -1377, 499, -1362, 489, -1360, 494, -1364, 497 + ], + [ + 45.4, 11, -103, -498, -107, -505, -122, -496, -118, -490, -116, -491, + -105, -473, -96, -479, -106, -497 + ], + [ + 45.4, 10.1, 644, -700, 628, -691, 631, -684, 629, -683, 637, -669, 655, + -679 + ], + [45.4, 11, -518, -869, -510, -854, -504, -858, -512, -873], + [ + 45.4, 6.7, -1217, 0, -1232, -27, -1252, -16, -1250, -12, -1258, -8, -1245, + 15 + ], + [45.4, 19.8, 625, 58, 640, 50, 624, 20, 611, 27, 614, 32, 610, 35, 623, 59], + [ + 45.4, 10.4, 285, -832, 257, -884, 207, -857, 222, -829, 225, -830, 238, + -806 + ], + [ + 45.4, 14, 1102, 265, 1073, 212, 1038, 231, 1048, 250, 1052, 248, 1058, + 259, 1041, 268, 1054, 291 + ], + [45.5, 12.2, -157, -418, -162, -426, -184, -414, -180, -406], + [45.5, 11.3, -447, -606, -460, -629, -474, -622, -461, -598], + [ + 45.5, 10.4, 648, -852, 648, -854, 643, -864, 637, -866, 623, -857, 619, + -851, 624, -841, 630, -839, 647, -848 + ], + [45.5, 9.4, -803, -603, -815, -625, -832, -616, -819, -593], + [ + 45.5, 24.4, 357, 304, 328, 252, 319, 257, 328, 274, 333, 271, 336, 277, + 331, 280, 335, 288, 341, 285, 343, 290, 338, 292, 347, 309 + ], + [45.5, 11, -607, -840, -617, -857, -644, -842, -633, -821, -605, -836], + [45.5, 11.6, -572, -819, -584, -841, -602, -831, -589, -809], + [ + 45.5, 12.5, -287, -921, -269, -931, -284, -957, -289, -954, -280, -938, + -287, -935, -285, -932, -293, -928, -294, -931, -310, -921, -307, -910 + ], + [ + 45.5, 16.5, -103, 444, -110, 432, -82, 416, -94, 396, -135, 419, -128, 457 + ], + [45.5, 19.8, 93, 233, 80, 210, 67, 217, 80, 241], + [45.5, 12.8, 101, -173, 115, -149, 128, -156, 115, -180], + [45.5, 17.4, -35, 304, -26, 300, -39, 276, -53, 283, -40, 307], + [45.5, 11.9, -527, -293, -540, -317, -550, -311, -537, -288], + [45.5, 13.4, -126, -68, -139, -92, -152, -85, -138, -61], + [45.5, 18.6, 48, 259, 35, 235, 21, 243, 34, 266], + [45.5, 9.8, -811, -686, -824, -708, -842, -698, -830, -676], + [ + 45.5, 14.6, -243, 300, -231, 322, -251, 333, -247, 340, -214, 320, -201, + 344, -180, 333, -188, 273, -192, 272 + ], + [ + 45.5, 12.8, 114, -151, 101, -173, 88, -166, 92, -158, 97, -161, 101, -153, + 97, -151, 100, -144 + ], + [45.6, 12.5, -203, -422, -216, -445, -229, -438, -215, -414, -202, -421], + [ + 45.6, 12.8, -339, 476, -330, 471, -345, 445, -366, 457, -362, 465, -350, + 459, -346, 466, -358, 472, -353, 482, -340, 475 + ], + [ + 45.6, 10.4, 676, -807, 670, -807, 655, -799, 654, -797, 650, -798, 648, + -793, 639, -788, 636, -784, 645, -767, 650, -765, 684, -784, 686, -789, + 682, -796, 683, -797 + ], + [45.6, 11.6, -592, -1093, -605, -1117, -612, -1113, -599, -1090], + [45.6, 11, 99, -708, 78, -696, 84, -687, 86, -688, 88, -684, 107, -695], + [45.6, 12.2, -226, -867, -206, -879, -218, -902, -257, -881, -244, -857], + [45.6, 10.7, -627, -908, -640, -931, -668, -915, -655, -892], + [45.6, 13.4, -322, -532, -335, -556, -342, -552, -329, -529], + [ + 45.6, 11.6, -577, -1332, -590, -1356, -597, -1352, -595, -1348, -630, + -1329, -617, -1307, -576, -1330 + ], + [45.6, 11.6, 62, -351, 51, -370, 26, -356, 37, -336], + [45.6, 10.1, -750, -846, -759, -863, -805, -838, -796, -821], + [45.6, 13.7, -5, -83, -7, -85, 20, -100, 7, -121, -25, -104, -12, -80], + [ + 45.6, 11.6, -605, -1117, -579, -1069, -563, -1078, -571, -1093, -541, + -1110, -551, -1129, -581, -1113, -588, -1127 + ], + [ + 45.6, 18.3, 689, 27, 688, 24, 682, 27, 678, 20, 671, 25, 674, 31, 669, 34, + 665, 28, 657, 32, 665, 45, 670, 42, 669, 39, 670, 38, 672, 41, 690, 31, + 688, 27 + ], + [45.7, 14, -148, -1, -134, -9, -148, -35, -164, -26, -150, 0], + [45.7, 11.6, 51, -370, 47, -377, 30, -367, 33, -360], + [45.7, 11.3, -679, -337, -692, -360, -712, -349, -699, -326], + [ + 45.7, 11.3, -678, 519, -707, 466, -740, 485, -734, 496, -732, 494, -729, + 499, -719, 516, -722, 518, -711, 537 + ], + [ + 45.7, 11, -461, -598, -474, -622, -460, -629, -463, -634, -476, -627, + -489, -650, -509, -639, -480, -587 + ], + [45.7, 16.2, -64, 1452, -43, 1440, -72, 1387, -93, 1399], + [45.7, 11.9, -240, 1243, -221, 1232, -235, 1206, -262, 1221, -247, 1247], + [45.7, 12.2, -419, -131, -429, -148, -453, -135, -443, -118], + [45.7, 11.6, -394, -583, -388, -586, -400, -609, -413, -601, -401, -579], + [ + 45.7, 9.1, -886, -645, -880, -648, -894, -672, -922, -657, -915, -645, + -893, -657 + ], + [45.7, 10.7, -676, -1048, -689, -1071, -701, -1064, -689, -1041], + [ + 45.7, 7.6, 58, -1079, 62, -1081, 63, -1080, 70, -1083, 60, -1099, 57, + -1097, 56, -1100, 50, -1097, 50, -1098, 34, -1089, 38, -1082, 39, -1083, + 41, -1079, 40, -1078, 45, -1070, 59, -1078 + ], + [45.7, 11.3, -544, -744, -558, -768, -570, -761, -556, -737], + [45.7, 11, -168, -906, -178, -925, -192, -917, -179, -893, -164, -901], + [ + 45.7, 8.5, -862, -404, -863, -406, -860, -407, -876, -436, -896, -426, + -887, -410, -885, -412, -876, -396 + ], + [ + 45.7, 8.8, 12, -1228, 8, -1237, 5, -1235, -2, -1247, -6, -1245, -8, -1249, + -12, -1246, -4, -1231, -6, -1229, -1, -1220 + ], + [ + 45.7, 11.3, -592, -955, -577, -928, -584, -924, -572, -903, -552, -915, + -564, -935, -571, -931, -586, -959 + ], + [45.7, 10.7, -594, -717, -607, -741, -619, -734, -606, -710], + [45.7, 8.2, 130, -963, 118, -986, 110, -982, 125, -956, 132, -960], + [ + 45.7, 10.1, -754, -391, -749, -394, -759, -412, -781, -400, -768, -377, + -753, -386, -756, -390 + ], + [ + 45.8, 10.4, -611, -192, -599, -198, -602, -204, -600, -205, -612, -226, + -638, -211, -627, -190, -614, -197 + ], + [ + 45.8, 14.3, -83, -3, -97, -29, -89, -33, -104, -60, -130, -45, -120, -27, + -115, -29, -97, 5 + ], + [45.8, 10.7, -458, -548, -470, -570, -486, -561, -474, -539], + [45.8, 11.3, -571, -854, -583, -876, -609, -861, -597, -839], + [ + 45.8, 12.5, -306, -1167, -307, -1170, -294, -1178, -305, -1199, -325, + -1188, -312, -1164 + ], + [45.8, 16.2, 157, -46, 140, -76, 126, -68, 143, -38], + [ + 45.8, 11.6, 411, -667, 396, -659, 402, -648, 393, -644, 400, -633, 423, + -646 + ], + [45.8, 9.8, -718, -649, -731, -672, -751, -661, -738, -638], + [45.8, 11.3, -463, -634, -476, -658, -489, -650, -476, -627], + [45.8, 19.2, 434, 775, 437, 774, 424, 751, 410, 759, 423, 781], + [45.8, 20.4, 113, 261, 100, 237, 83, 246, 96, 270], + [ + 45.8, 12.2, -535, -1204, -539, -1212, -526, -1219, -530, -1227, -562, + -1209, -553, -1194 + ], + [ + 45.8, 7, 152, -1080, 140, -1102, 127, -1094, 139, -1075, 138, -1075, 141, + -1068, 143, -1069, 143, -1071, 149, -1073, 149, -1077, 153, -1079 + ], + [45.8, 18.9, 373, 904, 382, 899, 367, 873, 353, 880, 367, 907], + [ + 45.8, 10.4, -759, -1236, -771, -1258, -784, -1251, -770, -1225, -757, + -1232 + ], + [45.8, 13.4, -141, -98, -155, -121, -163, -116, -150, -93], + [ + 45.8, 16.5, 770, 487, 742, 436, 740, 437, 730, 420, 655, 461, 665, 479, + 662, 480, 695, 538, 775, 494 + ], + [45.8, 13.1, 226, -211, 213, -234, 200, -227, 213, -204], + [45.8, 16.5, 227, 1251, 211, 1263, 227, 1291, 244, 1282], + [45.9, 9.1, 95, -854, 83, -877, 69, -870, 81, -847], + [ + 45.9, 8.5, 67, -1185, 67, -1187, 70, -1188, 71, -1187, 76, -1190, 64, + -1212, 59, -1209, 59, -1208, 48, -1203, 53, -1195, 59, -1199, 62, -1193, + 56, -1189, 60, -1181 + ], + [ + 45.9, 11.6, -504, -835, -491, -811, -487, -813, -483, -806, -488, -803, + -476, -782, -462, -790, -474, -811, -477, -809, -481, -817, -476, -819, + -489, -843 + ], + [ + 45.9, 13.4, -210, -112, -165, -136, -178, -159, -202, -147, -203, -149, + -215, -143, -211, -113 + ], + [45.9, 9.4, -843, -703, -856, -725, -867, -719, -855, -696], + [45.9, 11.6, -469, -95, -482, -119, -498, -110, -485, -86], + [ + 45.9, 11.6, -451, -105, -455, -114, -454, -115, -462, -129, -482, -119, + -469, -95 + ], + [45.9, 19.2, 320, 878, 307, 854, 298, 859, 296, 856, 295, 857, 310, 884], + [45.9, 4.3, 935, -410, 922, -434, 898, -421, 911, -398], + [45.9, 10.4, -481, -2, -492, -23, -512, -12, -499, 11, -479, 0], + [45.9, 11.3, -663, -345, -676, -369, -692, -360, -679, -336], + [ + 45.9, 14, -162, 40, -167, 31, -163, 29, -168, 20, -164, 18, -167, 13, + -194, 20, -189, 54, -187, 54 + ], + [45.9, 13.7, -33, -70, -45, -92, -58, -85, -45, -61, -32, -69], + [45.9, 12.2, -489, -864, -502, -886, -515, -879, -503, -856], + [46, 11.9, -515, -300, -528, -323, -540, -317, -527, -293], + [46, 23.5, 330, 318, 325, 307, 319, 310, 318, 308, 291, 323, 298, 336], + [46, 9.1, -775, -617, -788, -641, -804, -631, -791, -608], + [46, 11.6, -654, -350, -667, -374, -676, -369, -663, -345], + [46, 13.1, -92, -177, -104, -200, -111, -196, -98, -172, -91, -176], + [ + 46, 18, 401, 1012, 397, 1004, 395, 1005, 393, 1002, 395, 1001, 387, 987, + 393, 984, 387, 972, 380, 976, 377, 970, 383, 967, 379, 959, 364, 967, 373, + 980, 372, 980, 387, 1010, 386, 1011, 390, 1018 + ], + [ + 46, 13.1, -102, -209, -113, -230, -126, -223, -115, -202, -106, -207, + -104, -204, -100, -206 + ], + [46, 11, -164, -865, -177, -889, -183, -885, -170, -862], + [46, 14, -64, -47, -51, -55, -65, -82, -85, -71, -70, -44], + [46, 7, -1177, -787, -1184, -798, -1197, -791, -1170, -742, -1157, -750], + [46, 11.6, -651, -403, -662, -423, -686, -410, -675, -389], + [46, 12.8, -390, -963, -394, -971, -420, -956, -416, -948], + [ + 46, 12.8, -433, -853, -405, -868, -414, -885, -454, -864, -441, -839, + -435, -843, -438, -850 + ], + [46, 12.5, -518, -329, -505, -306, -489, -314, -502, -338], + [46, 13.1, -391, -1039, -402, -1060, -414, -1054, -403, -1033], + [46, 11.6, -240, -914, -253, -937, -274, -925, -261, -902], + [46, 11.3, -740, -378, -730, -360, -720, -365, -733, -388, -743, -383], + [46, 11, -151, -1001, -164, -1023, -184, -1012, -171, -990], + [46, 1.8, -1495, 239, -1508, 215, -1534, 229, -1520, 255, -1494, 241], + [46, 11.6, -637, -362, -649, -384, -667, -374, -654, -350, -636, -360], + [ + 46, 8.8, 23, -969, 12, -988, 10, -986, 2, -1000, 5, -1002, -6, -1021, -26, + -1010, -12, -984, -18, -981, -3, -954 + ], + [46, 10.7, -160, -1163, -152, -1167, -159, -1179, -182, -1166, -176, -1154], + [ + 46, 18.6, 65, 465, 36, 413, 20, 422, 33, 446, 41, 442, 45, 450, 42, 451, + 53, 472 + ], + [46, 9.1, 81, -847, 69, -870, 57, -863, 70, -840, 82, -846], + [46.1, 11.9, -523, -845, -535, -868, -562, -853, -550, -831], + [46.1, 18.6, 422, -141, 419, -147, 398, -135, 401, -129], + [46.1, 17.4, 62, 892, 94, 874, 81, 850, 43, 871, 56, 895], + [46.1, 10.7, -559, -97, -572, -120, -585, -113, -572, -90], + [ + 46.1, 17.1, 226, 982, 221, 973, 217, 975, 212, 966, 216, 964, 213, 959, + 196, 968, 200, 976, 206, 974, 209, 979, 208, 982, 205, 984, 209, 991 + ], + [46.1, 11, -627, -328, -640, -351, -651, -345, -638, -321], + [46.1, 13.4, -119, -115, -130, -135, -145, -126, -133, -104, -117, -112], + [46.1, 11, -21, -501, -28, -514, -54, -499, -47, -486], + [ + 46.1, 7, 116, -1160, 135, -1171, 127, -1184, 117, -1178, 119, -1175, 110, + -1170, 108, -1173, 98, -1167, 106, -1153, 108, -1154, 113, -1147, 120, + -1150, 115, -1160 + ], + [46.1, 9.8, -799, -693, -812, -715, -824, -708, -811, -686], + [ + 46.1, 12.8, 205, -197, 199, -207, 202, -208, 193, -223, 168, -210, 182, + -184 + ], + [ + 46.1, 12.2, -310, -1133, -289, -1144, -298, -1160, -301, -1159, -306, + -1167, -312, -1164, -325, -1188, -338, -1181, -324, -1156, -326, -1155, + -313, -1131 + ], + [46.1, 11, -508, -254, -520, -276, -546, -262, -534, -239], + [ + 46.1, 12.2, 55, -258, 42, -283, 40, -282, 39, -285, 26, -277, 30, -270, + 35, -273, 42, -260, 37, -257, 41, -249 + ], + [ + 46.1, 12.2, 84, -183, 54, -236, 37, -226, 47, -209, 49, -210, 58, -193, + 56, -192, 67, -174 + ], + [46.1, 17.4, 670, 192, 682, 214, 698, 205, 684, 181, 668, 189], + [ + 46.1, 3.7, -1494, -275, -1498, -283, -1520, -270, -1516, -263, -1512, + -265, -1509, -261, -1512, -260, -1508, -253, -1489, -263, -1493, -270, + -1497, -268, -1499, -272 + ], + [ + 46.2, 11.9, 164, -263, 163, -266, 176, -273, 163, -296, 130, -278, 144, + -252 + ], + [46.2, 11, -551, -157, -556, -167, -569, -160, -556, -137, -543, -143], + [46.2, 19.2, 77, 191, 63, 165, 52, 171, 53, 173, 47, 177, 60, 201], + [46.2, 10.7, 174, -681, 161, -704, 144, -694, 157, -671], + [ + 46.2, 10.7, -613, -795, -626, -818, -637, -811, -639, -813, -657, -803, + -642, -778, -613, -794 + ], + [46.2, 11.3, 86, -492, 74, -515, 62, -508, 74, -485], + [46.2, 11.3, -485, -86, -498, -110, -511, -103, -498, -79], + [ + 46.2, 10.4, -732, -1388, -704, -1404, -711, -1417, -738, -1402, -746, + -1416, -752, -1412, -737, -1385 + ], + [ + 46.2, 13.1, -310, -447, -308, -448, -316, -461, -312, -463, -320, -476, + -331, -470, -316, -444 + ], + [46.2, 11.6, -624, -417, -636, -438, -649, -430, -638, -410], + [46.2, 11.9, -84, -428, -71, -405, -58, -412, -71, -435], + [46.2, 19.2, 46, 319, 60, 344, 71, 338, 72, 334, 59, 311], + [46.3, 12.5, 231, -265, 217, -291, 198, -281, 212, -255], + [46.3, 7.6, 523, -364, 505, -396, 491, -388, 509, -356], + [ + 46.3, 11.9, -560, -1285, -575, -1312, -606, -1295, -601, -1284, -576, + -1299, -567, -1281 + ], + [46.3, 11.3, -565, -992, -578, -1015, -594, -1006, -581, -982], + [46.3, 21.6, 151, 289, 164, 282, 152, 260, 132, 271, 145, 293], + [ + 46.3, 5.2, 456, -1208, 451, -1216, 449, -1214, 440, -1230, 428, -1223, + 427, -1226, 422, -1223, 437, -1197 + ], + [46.3, 23.8, 326, 231, 312, 206, 299, 214, 312, 239], + [46.3, 11.3, -596, -805, -608, -827, -622, -820, -609, -798], + [46.3, 10.7, -625, -873, -637, -895, -666, -879, -654, -858], + [46.3, 15.2, 112, -60, 145, -79, 132, -100, 98, -81, 111, -59], + [46.3, 11.3, -579, -304, -591, -326, -605, -319, -592, -296], + [46.3, 21.9, 202, 390, 190, 368, 178, 374, 190, 396], + [46.3, 12.2, -392, -547, -405, -571, -418, -564, -405, -540], + [ + 46.3, 11.3, 13, -438, -10, -425, -6, -417, -7, -414, -1, -405, 22, -418, + 23, -421 + ], + [46.3, 19.8, 92, 361, 79, 338, 64, 346, 68, 354, 67, 355, 75, 370], + [46.3, 11.6, -528, -795, -540, -815, -554, -807, -541, -784, -526, -792], + [ + 46.3, 11.3, -605, -1170, -582, -1183, -595, -1207, -627, -1189, -627, + -1188, -636, -1183, -625, -1163, -611, -1170, -612, -1173, -608, -1175 + ], + [46.3, 8.8, -896, -760, -907, -781, -920, -774, -908, -753], + [ + 46.3, 8.2, -1095, -904, -1113, -895, -1112, -893, -1115, -891, -1116, + -893, -1121, -890, -1105, -862, -1101, -865, -1109, -879, -1087, -891 + ], + [46.4, 11, -635, -1123, -647, -1144, -660, -1137, -648, -1115], + [46.4, 11.6, -675, -390, -690, -416, -705, -408, -690, -382], + [ + 46.4, 12.5, 224, -372, 214, -367, 216, -363, 205, -357, 197, -370, 188, + -365, 202, -339, 233, -356 + ], + [ + 46.4, 18.6, 473, 881, 462, 861, 460, 858, 457, 859, 459, 862, 450, 867, + 462, 888 + ], + [46.4, 11, -648, -1115, -662, -1140, -668, -1136, -655, -1112], + [ + 46.4, 23.5, 461, 117, 455, 107, 476, 95, 470, 84, 433, 107, 438, 116, 440, + 115, 443, 120, 448, 117, 451, 122 + ], + [46.4, 9.4, 107, -822, 94, -846, 83, -840, 96, -817], + [46.4, 11.3, -460, -511, -472, -533, -498, -519, -485, -495, -459, -509], + [ + 46.4, 12.5, 168, -410, 163, -420, 159, -418, 158, -421, 160, -422, 154, + -432, 136, -422, 149, -399 + ], + [ + 46.4, 11.3, -526, -929, -539, -953, -532, -957, -546, -981, -579, -963, + -552, -914 + ], + [ + 46.4, 14.3, 555, -188, 567, -195, 560, -204, 558, -203, 555, -207, 532, + -194, 540, -179 + ], + [46.4, 21, 154, 327, 142, 305, 129, 312, 141, 334], + [46.4, 12.5, -104, -294, -132, -278, -117, -252, -77, -274, -91, -301], + [46.5, 12.5, 106, -197, 93, -221, 76, -211, 90, -187, 107, -196], + [ + 46.5, 11, -675, -1313, -659, -1322, -674, -1350, -700, -1335, -691, -1319, + -690, -1319, -684, -1310, -676, -1315 + ], + [46.5, 23.2, 471, 126, 461, 132, 471, 151, 499, 136, 488, 117], + [ + 46.5, 11.3, -72, -454, -78, -464, -88, -459, -92, -467, -86, -470, -90, + -478, -106, -469, -96, -455, -99, -454, -92, -443 + ], + [46.5, 12.5, -277, -96, -276, -97, -281, -108, -299, -98, -293, -87], + [46.5, 12.2, -472, -1248, -484, -1269, -497, -1262, -485, -1240], + [ + 46.5, 23.8, 347, 309, 339, 294, 335, 296, 332, 291, 334, 290, 328, 279, + 326, 280, 323, 275, 327, 273, 319, 257, 309, 262, 338, 314 + ], + [46.5, 9.1, 34, -909, 21, -932, 7, -924, 20, -901], + [ + 46.5, 11.9, -500, -1145, -493, -1149, -502, -1165, -529, -1150, -521, + -1134 + ], + [46.5, 11.6, -432, -526, -444, -548, -472, -533, -460, -511], + [ + 46.5, 23.8, 439, 386, 432, 373, 418, 380, 424, 392, 426, 391, 434, 405, + 440, 402, 439, 400, 444, 398, 437, 387 + ], + [46.5, 11, -208, -1056, -220, -1077, -233, -1069, -222, -1048], + [ + 46.6, 11.3, -548, -766, -553, -774, -540, -781, -554, -807, -581, -792, + -567, -767, -559, -771, -544, -744, -538, -748 + ], + [ + 46.6, 12.5, 214, -367, 224, -372, 215, -389, 193, -377, 200, -366, 205, + -369, 208, -364 + ], + [ + 46.6, 9.8, -739, -122, -735, -125, -736, -127, -704, -144, -717, -167, + -748, -150, -745, -143, -750, -140, -752, -143, -808, -113, -791, -80, + -734, -110, -740, -122 + ], + [46.6, 10.1, -668, -1019, -680, -1041, -700, -1030, -688, -1008], + [46.6, 9.8, -788, -641, -768, -652, -784, -680, -810, -666, -794, -637], + [46.6, 12.8, -309, -414, -322, -438, -329, -434, -315, -409], + [ + 46.6, 10.4, -614, -285, -617, -291, -619, -290, -620, -292, -618, -293, + -626, -307, -666, -285, -658, -271, -656, -272, -655, -270, -657, -269, + -651, -260, -644, -263, -643, -267 + ], + [46.6, 10.4, -626, -269, -613, -246, -595, -256, -608, -279], + [46.6, 20.1, 443, -102, 439, -110, 418, -98, 423, -90], + [ + 46.6, 17.7, 664, 93, 654, 99, 655, 101, 653, 103, 653, 104, 649, 106, 654, + 116, 657, 114, 660, 118, 649, 123, 657, 137, 662, 134, 663, 135, 683, 124, + 665, 93 + ], + [46.6, 10.7, -500, 10, -512, -12, -532, -1, -520, 21], + [ + 46.6, 24.1, 312, 239, 299, 214, 296, 215, 281, 188, 264, 198, 275, 217, + 241, 236, 259, 268 + ], + [ + 46.6, 8.2, 85, -934, 90, -937, 89, -940, 91, -941, 78, -964, 65, -957, 78, + -934, 83, -937 + ], + [ + 46.6, 11.9, -552, -1129, -559, -1143, -588, -1127, -583, -1117, -577, + -1120, -575, -1116 + ], + [ + 46.6, 10.1, -749, -1061, -761, -1082, -767, -1078, -770, -1083, -780, + -1077, -765, -1050 + ], + [ + 46.6, 11.9, -498, -1136, -495, -1137, -500, -1145, -521, -1134, -516, + -1126 + ], + [ + 46.6, 15.5, 174, 1138, 162, 1116, 159, 1118, 157, 1115, 156, 1115, 147, + 1120, 148, 1123, 143, 1126, 156, 1148 + ], + [ + 46.6, 11, -581, -982, -595, -1007, -599, -1004, -613, -1029, -632, -1018, + -621, -999, -619, -1000, -613, -990, -616, -989, -605, -969 + ], + [46.6, 11, -585, -1065, -597, -1086, -611, -1079, -599, -1057], + [46.6, 18.6, 61, 612, 28, 630, 42, 657, 75, 639], + [46.6, 4.3, -1402, 271, -1386, 262, -1401, 236, -1427, 250, -1412, 277], + [46.6, 12.8, -278, -201, -290, -223, -303, -216, -291, -193], + [46.7, 11.9, -491, -811, -504, -835, -532, -819, -519, -796], + [46.7, 11.6, -603, -378, -616, -402, -636, -391, -622, -367], + [46.7, 11.3, -534, -239, -546, -262, -566, -251, -554, -228], + [46.7, 14, 249, -186, 236, -210, 214, -198, 227, -174], + [46.7, 13.1, -376, -377, -389, -400, -401, -393, -388, -370], + [ + 46.7, 11.6, -192, -429, -170, -441, -178, -455, -188, -450, -186, -447, + -191, -445, -192, -447, -202, -442, -197, -432, -206, -427, -203, -422 + ], + [46.7, 12.2, -379, -555, -392, -578, -405, -571, -392, -547], + [46.7, 11.3, -569, -360, -582, -383, -600, -373, -587, -350], + [46.7, 23.8, 416, 361, 401, 335, 395, 338, 380, 312, 373, 316, 402, 368], + [46.7, 8.8, -736, -484, -749, -507, -765, -499, -752, -475], + [46.8, 10.4, -556, -137, -569, -160, -581, -153, -568, -130], + [ + 46.8, 10.7, 112, -711, 110, -714, 99, -708, 107, -695, 86, -683, 93, -670, + 125, -688 + ], + [ + 46.8, 8.5, 1032, -127, 1027, -135, 1016, -129, 1021, -123, 1014, -119, + 1011, -126, 1001, -120, 1014, -97, 1024, -103, 1019, -110, 1023, -112, + 1029, -102, 1038, -108, 1029, -124 + ], + [46.8, 12.5, -322, -406, -336, -431, -349, -424, -335, -399], + [ + 46.8, 13.4, -170, -172, -178, -185, -177, -186, -181, -193, -200, -183, + -188, -161 + ], + [46.8, 11.3, -550, -831, -562, -853, -575, -846, -562, -824], + [46.8, 13.4, -304, -279, -315, -299, -327, -292, -315, -270, -303, -277], + [ + 46.8, 10.4, -591, -326, -579, -304, -559, -315, -565, -326, -561, -328, + -568, -339 + ], + [46.8, 20.7, 135, 249, 121, 222, 109, 229, 124, 255], + [ + 46.8, 11.9, -476, -992, -498, -979, -490, -964, -494, -962, -499, -972, + -524, -958, -512, -936, -460, -965 + ], + [ + 46.8, 13.4, -226, 166, -230, 157, -234, 159, -238, 152, -235, 150, -239, + 142, -251, 149, -238, 172 + ], + [ + 46.9, 12.5, 255, -317, 240, -309, 244, -300, 237, -296, 249, -275, 272, + -288 + ], + [46.9, 11.9, -442, -162, -457, -188, -467, -182, -453, -156], + [46.9, 11, -486, -147, -495, -163, -505, -157, -493, -134, -482, -140], + [46.9, 19.2, 75, 370, 64, 352, 65, 352, 63, 347, 34, 362, 47, 386], + [46.9, 11.3, -634, 817, -649, 792, -662, 799, -647, 825], + [46.9, 11, -554, -228, -566, -251, -579, -243, -566, -220, -553, -227], + [ + 46.9, 12.5, -719, 569, -722, 564, -743, 576, -728, 601, -708, 590, -714, + 580, -716, 580, -718, 576, -716, 575 + ], + [ + 46.9, 19.2, 300, 844, 299, 841, 294, 844, 293, 843, 290, 836, 279, 842, + 281, 842, 284, 848, 279, 852, 284, 860, 303, 850 + ], + [46.9, 13.1, 577, -219, 567, -237, 557, -232, 567, -214], + [46.9, 12.2, 202, -339, 190, -362, 159, -345, 171, -322], + [ + 46.9, 9.8, 36, -818, 31, -828, 27, -825, 28, -823, 21, -819, 20, -822, 12, + -817, 17, -807 + ], + [47, 21.3, 194, 305, 180, 278, 166, 286, 164, 282, 151, 289, 168, 319], + [47, 12.5, -440, -462, -426, -437, -411, -446, -424, -471], + [ + 47, 11.6, -512, -936, -524, -958, -527, -956, -529, -959, -539, -953, + -526, -929 + ], + [47, 10.4, -640, -351, -627, -328, -605, -340, -618, -363], + [ + 47, 7.6, 788, -909, 778, -905, 780, -902, 774, -897, 772, -901, 762, -893, + 785, -853, 800, -862, 804, -855, 806, -855, 806, -854, 816, -859 + ], + [ + 47, 12.8, -454, -1016, -427, -1031, -422, -1021, -416, -1025, -428, -1047, + -462, -1029, -455, -1016 + ], + [47, 12.5, -342, -395, -357, -421, -372, -413, -358, -387], + [ + 47.1, 11, -39, -473, -57, -504, -70, -496, -73, -503, -70, -505, -74, + -514, -78, -511, -82, -518, -107, -505, -86, -470, -92, -467, -88, -459, + -78, -464, -72, -454 + ], + [47.1, 11.6, -615, 807, -614, 806, -629, 780, -642, 788, -627, 814], + [47.1, 12.5, -388, -461, -400, -484, -419, -474, -406, -450, -387, -460], + [ + 47.1, 13.4, -265, 119, -251, 145, -239, 138, -237, 142, -238, 143, -226, + 166, -208, 156, -205, 150, -208, 133, -211, 123, -224, 99, -227, 98 + ], + [47.1, 20.1, 134, 338, 121, 314, 108, 321, 121, 345], + [47.1, 12.8, -794, 638, -780, 664, -760, 653, -775, 627], + [47.1, 23.5, 307, 201, 296, 180, 281, 188, 293, 209], + [ + 47.1, 11.9, 171, -322, 158, -346, 149, -341, 156, -328, 153, -327, 160, + -316 + ], + [ + 47.1, 11.9, -471, -1128, -484, -1151, -496, -1144, -492, -1137, -497, + -1134, -498, -1136, -516, -1126, -506, -1109 + ], + [47.2, 13.7, 117, -114, 104, -137, 97, -133, 110, -110], + [47.2, 13.7, 130, -121, 117, -144, 104, -137, 117, -114], + [ + 47.2, 11.9, -511, -1058, -511, -1058, -523, -1080, -560, -1060, -547, + -1037, -546, -1038, -544, -1035, -541, -1037, -544, -1043, -535, -1048, + -534, -1045 + ], + [ + 47.2, 2.7, -1387, 575, -1387, 594, -1389, 594, -1391, 575, -1397, 576, + -1405, 581, -1410, 589, -1411, 599, -1409, 608, -1406, 612, -1397, 619, + -1388, 620, -1376, 617, -1371, 613, -1365, 601, -1366, 592, -1368, 586, + -1373, 581, -1379, 577 + ], + [47.2, 2.7, -1387, 575, -1390, 575, -1388, 594, -1387, 593], + [47.2, 10.4, -67, -582, -81, -607, -88, -604, -89, -603, -75, -578], + [47.2, 10.4, -655, -1112, -668, -1136, -677, -1131, -664, -1107], + [47.2, 16.8, 79, 100, 50, 48, 10, 70, 29, 104, 12, 113, 22, 131], + [ + 47.2, 10.7, 587, -765, 602, -773, 589, -800, 581, -796, 584, -789, 582, + -790, 569, -783, 570, -781, 564, -778, 568, -771, 571, -772, 570, -770, + 572, -767, 574, -767, 575, -764, 578, -766, 580, -762 + ], + [47.2, 13.7, 110, -110, 97, -133, 91, -130, 104, -107], + [47.3, 16.5, 79, 69, 62, 41, 50, 48, 57, 62, 62, 59, 70, 74], + [47.3, 9.8, -729, -450, -742, -473, -756, -466, -743, -443], + [ + 47.3, 12.8, -101, -195, -100, -193, -92, -197, -88, -189, -96, -185, -92, + -177, -66, -191, -70, -199, -78, -194, -83, -202, -74, -207, -78, -214, + -104, -200 + ], + [ + 47.3, 11.9, 249, -275, 243, -285, 240, -284, 237, -290, 240, -291, 235, + -300, 217, -290, 231, -265 + ], + [47.3, 10.4, 249, -492, 236, -515, 226, -510, 239, -487], + [ + 47.4, 11.3, 281, -349, 295, -356, 300, -347, 306, -350, 295, -370, 268, + -355, 274, -345 + ], + [47.4, 12.8, -741, 698, -756, 672, -771, 680, -757, 707], + [47.4, 12.5, 26, -151, 67, -174, 62, -182, 19, -158, 24, -150], + [47.4, 18, 29, 269, 16, 246, -11, 260, 2, 284], + [47.4, 16.8, 1261, 171, 1235, 125, 1188, 151, 1213, 197], + [ + 47.4, 4.9, 650, -1156, 624, -1142, 635, -1122, 642, -1126, 645, -1120, + 665, -1131 + ], + [47.4, 20.7, 691, 991, 683, 976, 660, 989, 668, 1004], + [47.5, 12.5, -358, -387, -371, -411, -390, -401, -376, -377], + [47.5, 11.6, -542, 856, -557, 830, -577, 841, -563, 868], + [47.5, 10.4, -563, -887, -554, -870, -548, -874, -557, -890], + [ + 47.5, 9.4, -625, -239, -637, -261, -651, -253, -652, -255, -661, -250, + -648, -226 + ], + [47.6, 20.1, 373, 723, 393, 712, 379, 686, 353, 700, 368, 726], + [ + 47.6, 13.1, -191, -339, -204, -361, -217, -354, -212, -346, -206, -349, + -203, -344, -209, -341, -204, -332 + ], + [47.7, 12.5, -362, -476, -374, -499, -387, -492, -374, -469], + [47.7, 11, -528, -115, -542, -140, -561, -130, -547, -105], + [47.7, 19.5, 138, 515, 124, 491, 111, 499, 124, 523], + [47.8, 24.4, 439, 329, 422, 339, 418, 332, 404, 340, 416, 361, 447, 343], + [ + 47.9, 18.6, 751, 636, 829, 592, 783, 509, 777, 512, 769, 497, 701, 535, + 709, 550, 704, 553 + ], + [47.9, 10.7, -565, -451, -576, -471, -586, -465, -575, -445], + [48, 10.4, -474, -6, -486, -27, -492, -23, -481, -2], + [ + 48, 18.9, 384, 842, 369, 816, 353, 825, 358, 834, 364, 831, 368, 840, 369, + 841, 364, 844, 368, 851 + ], + [48.1, 21.3, 706, 1229, 694, 1236, 708, 1262, 721, 1255], + [48.1, 7, -832, -759, -843, -779, -857, -772, -846, -752], + [ + 48.1, 8.5, 889, -80, 873, -109, 875, -110, 873, -114, 885, -121, 875, + -140, 842, -122, 869, -69 + ], + [ + 48.1, 10.4, 635, -579, 628, -592, 617, -586, 606, -605, 635, -621, 624, + -641, 579, -616, 604, -572, 600, -570, 603, -565, 606, -566, 608, -563 + ], + [ + 48.2, 10.7, 342, -684, 337, -693, 335, -692, 334, -694, 332, -694, 327, + -703, 303, -690, 310, -679, 307, -677, 312, -668 + ], + [48.2, 11.6, 74, -328, 71, -334, 46, -320, 49, -314], + [48.3, 10.1, -638, 36, -653, 10, -659, 13, -645, 40], + [48.3, 10.4, -722, -1075, -733, -1096, -746, -1089, -735, -1068], + [ + 48.3, 10.7, -159, -1179, -157, -1180, -150, -1168, -142, -1172, -156, + -1196, -189, -1178, -182, -1166 + ], + [48.4, 12.8, 1392, 177, 1365, 192, 1373, 205, 1399, 191], + [ + 48.4, 11.3, -734, 638, -745, 617, -747, 618, -748, 616, -751, 617, -750, + 620, -752, 621, -740, 642 + ], + [ + 48.4, 9.1, -17, -947, -28, -966, -32, -964, -31, -963, -38, -961, -37, + -959, -50, -952, -54, -960, -43, -966, -49, -977, -71, -965, -51, -928 + ], + [48.4, 3.7, -1487, 80, -1514, 94, -1485, 147, -1459, 132], + [ + 48.4, 14, 10, -54, -5, -83, -12, -80, -25, -103, -38, -96, -29, -78, -24, + -80, -17, -68, -42, -54, -58, -85, -65, -81, -51, -55, -52, -54, -50, -49, + -55, -47, -43, -25 + ], + [ + 48.5, 10.7, 353, -903, 337, -929, 312, -915, 327, -888, 329, -889, 332, + -883, 357, -897 + ], + [48.5, 8.2, -489, 562, -505, 533, -518, 541, -502, 569], + [ + 48.5, 13.1, -219, -373, -227, -387, -238, -380, -240, -389, -224, -397, + -228, -403, -251, -391, -248, -362, -246, -360, -243, -360 + ], + [ + 48.5, 21.9, 181, 364, 175, 352, 171, 354, 170, 352, 174, 350, 168, 340, + 153, 349, 166, 372 + ], + [ + 48.7, 12.8, 788, 66, 775, 44, 756, 55, 768, 77, 775, 73, 773, 70, 779, 66, + 781, 70 + ], + [ + 48.8, 11.6, -185, -1392, -182, -1393, -179, -1388, -163, -1397, -162, + -1398, -184, -1437, -244, -1403, -231, -1378, -197, -1397, -195, -1394, + -188, -1398 + ], + [ + 48.8, 11.3, 1468, 313, 1453, 287, 1432, 298, 1439, 311, 1434, 314, 1441, + 328 + ], + [48.8, 11.6, -421, 772, -428, 759, -444, 768, -437, 781], + [ + 48.8, 11, -531, -693, -536, -703, -529, -707, -540, -726, -566, -712, + -555, -692, -549, -696, -542, -687 + ], + [ + 48.9, 14.6, -280, 708, -293, 684, -313, 695, -306, 708, -304, 706, -297, + 717 + ], + [ + 48.9, 8.5, 398, -381, 385, -404, 375, -399, 373, -403, 368, -400, 373, + -393, 363, -387, 371, -374, 379, -379, 380, -377, 377, -375, 380, -371 + ], + [ + 49, 11.6, 130, -388, 128, -391, 127, -390, 99, -440, 79, -429, 85, -418, + 91, -421, 92, -418, 106, -393, 107, -393, 108, -391, 102, -387, 109, -375, + 130, -387 + ], + [49, 11.9, -380, 443, -394, 417, -439, 442, -425, 468], + [49, 19.8, 104, 395, 96, 380, 85, 386, 98, 409, 109, 403], + [49.1, 9.8, -705, -611, -715, -629, -732, -620, -722, -602], + [ + 49.1, 21, 616, 159, 610, 147, 607, 149, 600, 136, 588, 142, 595, 156, 597, + 155, 598, 157, 581, 166, 580, 164, 582, 162, 578, 156, 563, 165, 574, 184, + 615, 162, 614, 161 + ], + [49.1, 9.1, -826, -795, -813, -802, -827, -826, -859, -808, -846, -784], + [49.1, 16.8, 209, 991, 196, 968, 184, 974, 197, 998], + [ + 49.1, 13.7, -190, -304, -203, -327, -213, -322, -212, -320, -216, -318, + -210, -307, -226, -299, -228, -314, -239, -308, -235, -279, -231, -278, + -208, -291, -209, -293 + ], + [ + 49.3, 6.1, 318, -1268, 327, -1269, 317, -1288, 293, -1275, 299, -1264, + 308, -1265, 306, -1269, 316, -1272 + ], + [ + 49.3, 7.6, 492, -356, 488, -364, 501, -371, 491, -388, 465, -374, 479, + -348 + ], + [ + 49.3, 17.7, 134, 946, 133, 944, 136, 941, 131, 936, 133, 935, 133, 936, + 139, 933, 138, 932, 139, 931, 143, 938, 145, 938, 146, 939, 152, 936, 151, + 934, 152, 933, 139, 909, 112, 923, 118, 931, 126, 948, 127, 947, 128, 949 + ], + [49.3, 19.2, 62, 286, 51, 265, 37, 273, 50, 295, 63, 288], + [49.3, 8.2, 288, -1019, 273, -1046, 250, -1033, 265, -1006], + [49.4, 22.9, 282, 167, 266, 139, 273, 136, 259, 112, 246, 119, 275, 170], + [49.4, 10.4, -424, 557, -437, 534, -477, 556, -464, 579], + [49.4, 21.3, 147, 297, 135, 276, 129, 280, 140, 301], + [49.4, 14.3, -50, -21, -64, -47, -97, -29, -83, -3], + [ + 49.4, 10.1, -775, -681, -766, -666, -764, -668, -759, -660, -740, -670, + -745, -678, -742, -680, -751, -697, -776, -684 + ], + [ + 49.4, 4, -1448, -60, -1455, -72, -1476, -62, -1484, -55, -1478, -43, + -1469, -48, -1468, -47 + ], + [49.4, 11, -442, -560, -451, -576, -463, -570, -454, -554], + [49.5, 19.5, 142, 121, 128, 95, 102, 109, 117, 136], + [49.5, 13.7, -243, 419, -256, 396, -266, 402, -253, 426, -242, 420], + [ + 49.5, 6.7, 224, -1455, 215, -1450, 218, -1444, 208, -1440, 209, -1437, + 205, -1435, 201, -1442, 192, -1438, 197, -1430, 194, -1428, 201, -1416, + 236, -1434 + ], + [ + 49.5, 8.5, -753, -540, -760, -552, -761, -552, -763, -554, -761, -555, + -766, -563, -793, -548, -780, -525 + ], + [49.5, 4.3, -1438, -109, -1444, -121, -1474, -105, -1467, -93, -1446, -103], + [ + 49.5, 12.8, -237, -562, -240, -569, -242, -570, -274, -552, -273, -543, + -244, -558 + ], + [ + 49.5, 11.9, 581, -225, 585, -227, 591, -227, 625, -247, 626, -245, 643, + -255, 633, -274, 571, -240, 571, -238, 576, -229, 578, -230 + ], + [49.5, 7.3, -1062, -717, -1074, -739, -1099, -726, -1086, -704], + [ + 49.5, 4.6, -1390, -92, -1396, -104, -1406, -99, -1416, -120, -1429, -114, + -1422, -99, -1420, -100, -1417, -93, -1426, -88, -1419, -76 + ], + [ + 49.6, 15.2, -77, 187, -90, 163, -92, 164, -98, 155, -91, 151, -102, 132, + -115, 139, -85, 191 + ], + [49.6, 20.4, 365, -67, 369, -60, 385, -69, 376, -85, 363, -78, 367, -69], + [49.6, 13.7, -122, -356, -129, -369, -156, -354, -149, -341], + [49.6, 19.2, 90, 183, 76, 157, 63, 165, 77, 191], + [49.6, 21.9, 180, 278, 165, 252, 152, 260, 166, 286], + [49.6, 11.3, -152, -1474, -167, -1501, -188, -1490, -173, -1462], + [ + 49.7, 12.2, -368, -32, -379, -52, -388, -47, -386, -44, -388, -43, -379, + -26 + ], + [49.7, 12.2, 204, -290, 192, -312, 169, -300, 181, -278], + [49.7, 11, -158, -1217, -170, -1237, -210, -1215, -198, -1193], + [49.7, 18.6, 63, 429, 50, 404, 36, 412, 49, 436], + [49.7, 14.9, -279, 656, -292, 633, -297, 636, -285, 659], + [ + 49.7, 13.1, -44, -153, -52, -167, -25, -183, -29, -191, -63, -172, -50, + -149 + ], + [ + 49.7, 12.2, -432, -56, -424, -41, -405, -51, -403, -47, -383, -58, -390, + -80 + ], + [ + 49.7, 12.5, 215, -389, 204, -408, 181, -395, 190, -379, 193, -380, 194, + -377 + ], + [49.7, 18.3, 729, 888, 715, 864, 707, 869, 721, 893], + [ + 49.7, 18, 106, 55, 91, 64, 94, 69, 80, 77, 78, 73, 67, 79, 79, 100, 119, + 78 + ], + [49.8, 4, -1419, -76, -1426, -88, -1442, -80, -1455, -72, -1448, -60], + [ + 49.8, 11, -659, -1322, -675, -1313, -669, -1304, -686, -1294, -681, -1285, + -683, -1284, -679, -1275, -644, -1295 + ], + [ + 49.8, 4.3, -1429, -114, -1408, -125, -1415, -137, -1444, -121, -1438, -109 + ], + [49.8, 12.8, -45, -343, -53, -356, -80, -341, -73, -328], + [ + 49.8, 11.6, -493, -134, -505, -157, -532, -142, -526, -133, -527, -133, + -519, -119 + ], + [ + 49.9, 4.3, -1349, -157, -1356, -169, -1386, -153, -1379, -141, -1369, -145 + ], + [49.9, 23.2, 309, 96, 287, 108, 296, 125, 282, 133, 296, 158, 332, 139], + [49.9, 21, 479, 587, 474, 577, 442, 595, 447, 605], + [ + 49.9, 14.6, -1062, 676, -1064, 672, -1060, 670, -1063, 663, -1086, 675, + -1082, 681, -1078, 679, -1073, 687, -1078, 690, -1074, 696, -1052, 684, + -1055, 678, -1060, 680 + ], + [ + 50, 4.3, -1331, -124, -1338, -136, -1358, -126, -1367, -120, -1360, -108, + -1340, -118, -1341, -119 + ], + [50, 11, -616, 693, -620, 686, -633, 694, -619, 720, -605, 712], + [ + 50, 11.6, 1119, 638, 1100, 649, 1107, 662, 1109, 660, 1117, 675, 1125, + 688, 1122, 690, 1129, 702, 1165, 682, 1135, 629 + ], + [50, 16.2, -18, 154, -32, 129, -48, 138, -34, 162], + [50, 4.3, -1360, -108, -1367, -120, -1377, -116, -1396, -104, -1390, -92], + [ + 50, 10.4, -538, 521, -547, 506, -555, 510, -571, 481, -596, 494, -571, 540 + ], + [ + 50, 19.8, 586, 997, 575, 977, 565, 983, 563, 980, 560, 982, 575, 1009, + 589, 1001 + ], + [50, 11.3, -122, -518, -151, -568, -193, -546, -164, -495], + [50, 11, -605, -947, -596, -930, -590, -933, -600, -950], + [ + 50.1, 21.9, 554, 147, 563, 142, 561, 137, 570, 132, 572, 137, 579, 133, + 578, 131, 581, 129, 573, 116, 545, 131 + ], + [ + 50.1, 4, -1379, -141, -1386, -153, -1395, -149, -1415, -137, -1408, -125, + -1388, -135 + ], + [50.1, 3.4, -1467, -93, -1474, -105, -1503, -89, -1496, -76, -1486, -81], + [50.1, 13.4, -282, -445, -307, -441, -296, -421, -280, -430], + [ + 50.1, 11.6, -576, -392, -581, -402, -584, -401, -586, -405, -583, -406, + -589, -417, -616, -402, -610, -392, -607, -393, -604, -388, -608, -387, + -603, -378 + ], + [ + 50.1, 13.1, -226, -55, -229, -77, -232, -78, -259, -64, -256, -58, -272, + -49, -263, -34 + ], + [50.2, 17.7, 293, -123, 284, -138, 265, -127, 274, -111, 294, -122], + [50.2, 18, 218, 1458, 178, 1485, 184, 1496, 227, 1473], + [50.2, 18.9, 411, 883, 417, 879, 402, 853, 389, 861, 403, 887], + [50.2, 15.8, 1044, 773, 1042, 770, 986, 801, 1017, 856, 1073, 825], + [ + 50.2, 11.9, -739, 553, -768, 500, -802, 519, -787, 545, -807, 556, -792, + 582 + ], + [50.3, 13.1, -61, -105, -73, -127, -82, -122, -69, -99], + [50.3, 8.2, 62, -1301, 44, -1291, 65, -1254, 83, -1264], + [50.3, 22.6, 534, 74, 529, 64, 521, 68, 519, 65, 511, 70, 518, 82], + [ + 50.3, 12.8, -374, -928, -381, -940, -383, -939, -390, -952, -411, -940, + -400, -917, -397, -916, -395, -915 + ], + [50.3, 7.3, 80, -1068, 54, -1053, 65, -1034, 91, -1049], + [ + 50.3, 7.9, -1104, -779, -1115, -798, -1128, -791, -1138, -809, -1151, + -802, -1130, -765 + ], + [ + 50.3, 9.8, 600, -298, 592, -312, 588, -310, 585, -316, 557, -301, 572, + -276, 602, -292 + ], + [ + 50.3, 12.2, -304, -613, -339, -594, -346, -606, -352, -603, -366, -627, + -379, -620, -365, -595, -368, -594, -361, -581, -365, -579, -358, -565, + -301, -597, -303, -614 + ], + [50.4, 18, 478, 969, 465, 945, 450, 954, 464, 979, 479, 971], + [ + 50.4, 13.7, -319, 729, -303, 720, -308, 712, -305, 710, -313, 695, -364, + 724, -351, 747 + ], + [ + 50.4, 19.5, 426, -102, 424, -105, 437, -113, 429, -127, 416, -119, 414, + -123, 407, -118, 418, -98 + ], + [ + 50.4, 17.1, 1313, 238, 1301, 217, 1255, 243, 1267, 264, 1271, 262, 1270, + 260, 1303, 242, 1307, 239, 1308, 241 + ], + [50.5, 20.7, 155, 416, 143, 393, 128, 401, 141, 424], + [ + 50.5, 11.3, 194, -603, 183, -624, 178, -621, 175, -626, 131, -602, 145, + -576 + ], + [ + 50.5, 15.8, 486, -189, 500, -166, 499, -165, 501, -162, 497, -159, 506, + -143, 525, -153, 500, -197 + ], + [50.5, 11.9, -663, 655, -656, 651, -670, 625, -698, 640, -683, 666], + [ + 50.5, 14.9, 763, 169, 755, 154, 751, 157, 753, 161, 748, 165, 745, 160, + 732, 167, 741, 181 + ], + [ + 50.5, 5.5, -1136, -272, -1142, -282, -1138, -284, -1133, -274, -1109, + -286, -1115, -297, -1112, -299, -1115, -305, -1157, -282, -1148, -265 + ], + [ + 50.5, 11.3, -182, -1065, -167, -1074, -180, -1098, -213, -1080, -202, + -1061, -185, -1070 + ], + [ + 50.5, 13.7, -221, 356, -233, 333, -247, 340, -263, 311, -283, 322, -272, + 342, -258, 335, -241, 367 + ], + [ + 50.6, 12.5, -370, 438, -381, 418, -365, 410, -371, 399, -393, 411, -387, + 422, -391, 424, -380, 443 + ], + [ + 50.6, 5.8, 370, -1279, 369, -1282, 386, -1292, 380, -1302, 364, -1293, + 361, -1297, 380, -1309, 374, -1320, 343, -1303, 360, -1273 + ], + [50.6, 9.4, -753, -630, -766, -653, -776, -647, -763, -624], + [50.6, 9.1, -834, -634, -842, -648, -868, -634, -853, -608, -827, -622], + [50.6, 9.8, -738, -638, -751, -661, -766, -653, -753, -630], + [50.7, 10.7, -537, -288, -550, -311, -576, -297, -563, -273], + [ + 50.7, 15.5, -38, 1347, -43, 1338, -51, 1342, -54, 1337, -46, 1333, -52, + 1321, -61, 1326, -77, 1340, -65, 1362 + ], + [ + 50.7, 16.5, 1321, 283, 1309, 262, 1304, 264, 1306, 266, 1279, 281, 1272, + 285, 1271, 282, 1267, 285, 1279, 307 + ], + [50.7, 9.4, 552, -539, 543, -555, 519, -542, 528, -526], + [ + 50.8, 18.3, 660, 1, 666, -2, 671, 7, 687, -2, 673, -27, 648, -13, 648, + -14, 635, -8, 650, 19, 665, 10 + ], + [ + 50.8, 10.4, 101, -731, 88, -754, 80, -750, 79, -752, 77, -750, 71, -760, + 73, -762, 65, -778, 41, -765, 70, -712, 102, -730 + ], + [50.8, 14, -279, 618, -292, 595, -324, 612, -311, 636], + [ + 50.8, 12.2, 194, -246, 181, -270, 171, -265, 177, -253, 152, -239, 159, + -226 + ], + [50.9, 2.4, -1538, -11, -1545, -24, -1572, -10, -1565, 3], + [50.9, 13.1, 1435, 317, 1424, 296, 1398, 310, 1410, 331], + [50.9, 13.4, -422, -1282, -426, -1291, -461, -1271, -457, -1263], + [50.9, 15.5, 104, 1019, 116, 1043, 135, 1033, 122, 1009], + [50.9, 8.8, -728, 85, -742, 59, -762, 70, -747, 96], + [ + 50.9, 5.2, -1387, -538, -1403, -566, -1384, -576, -1382, -572, -1377, + -575, -1379, -579, -1376, -581, -1387, -601, -1419, -584, -1418, -582, + -1433, -573, -1455, -561, -1456, -563, -1466, -558, -1456, -540, -1431, + -553, -1430, -550, -1431, -549, -1426, -541, -1425, -542, -1423, -538, + -1442, -528, -1433, -512 + ], + [ + 51, 11, -612, -457, -627, -485, -654, -470, -641, -447, -627, -455, -625, + -450 + ], + [ + 51, 10.4, 557, -850, 550, -863, 527, -848, 534, -835, 550, -844, 558, -849 + ], + [51.1, 9.1, -670, 53, -683, 30, -685, 31, -686, 29, -715, 44, -700, 70], + [ + 51.1, 10.7, 440, -832, 427, -855, 365, -820, 379, -794, 406, -809, 405, + -810, 436, -828, 435, -829 + ], + [ + 51.2, 10.1, -708, -997, -735, -1046, -756, -1034, -746, -1016, -742, + -1019, -735, -1006, -739, -1004, -729, -986 + ], + [51.2, 12.8, -44, -172, -48, -170, -45, -165, -23, -177, -26, -182], + [51.2, 12.8, -69, -99, -82, -122, -100, -112, -87, -89], + [51.2, 9.4, 85, -810, 71, -836, 44, -822, 58, -795], + [51.2, 5.5, 670, -1045, 702, -1062, 681, -1101, 648, -1084], + [51.2, 11, 756, -129, 777, -141, 762, -167, 736, -152, 751, -126], + [51.3, 11.6, 560, -633, 591, -650, 579, -671, 548, -654], + [ + 51.3, 7.6, 63, -1139, 60, -1145, 39, -1133, 44, -1124, 47, -1126, 52, + -1116, 55, -1117, 56, -1115, 69, -1122, 62, -1134, 65, -1136 + ], + [ + 51.4, 10.4, -204, -1141, -220, -1132, -223, -1136, -232, -1130, -230, + -1126, -226, -1128, -212, -1102, -189, -1115 + ], + [51.5, 16.2, 173, 1008, 162, 987, 147, 995, 158, 1016], + [ + 51.5, 7.3, 153, -1532, 159, -1521, 162, -1523, 163, -1525, 161, -1527, + 166, -1530, 164, -1532, 168, -1534, 167, -1530, 173, -1520, 171, -1515, + 175, -1513, 147, -1497, 154, -1484, 151, -1483, 155, -1475, 199, -1499, + 172, -1547, 151, -1535 + ], + [51.6, 10.7, -433, 617, -419, 610, -434, 583, -454, 594, -439, 621], + [ + 51.7, 13.4, 992, 597, 989, 590, 985, 592, 982, 588, 994, 581, 996, 586, + 993, 587, 997, 594, 1013, 585, 1006, 573, 1005, 574, 1002, 570, 1007, 567, + 1001, 557, 962, 579, 976, 606 + ], + [ + 51.7, 11, 128, -347, 120, -361, 91, -345, 104, -322, 116, -328, 115, -330, + 120, -333, 117, -339, 113, -338, 110, -342, 112, -343, 113, -343, 120, + -346, 127, -334, 133, -337 + ], + [51.8, 11, -471, 494, -485, 468, -519, 486, -505, 512], + [51.8, 15, -1398, 367, -1407, 349, -1441, 368, -1431, 385], + [51.8, 22.3, 232, 428, 245, 421, 231, 395, 200, 412, 214, 438], + [ + 51.8, 8.5, -840, -405, -823, -415, -832, -431, -845, -423, -838, -411, + -842, -409 + ], + [ + 51.8, 10.4, 730, -196, 716, -188, 727, -168, 754, -183, 745, -199, 733, + -193 + ], + [51.8, 9.1, -853, 153, -827, 141, -837, 124, -849, 130, -860, 139], + [51.8, 20.1, 103, 293, 95, 297, 106, 318, 115, 314], + [ + 51.9, 12.8, -269, -355, -289, -352, -288, -350, -290, -349, -284, -338, + -268, -347 + ], + [ + 51.9, 7, 200, -1163, 203, -1165, 197, -1175, 200, -1177, 194, -1188, 190, + -1186, 188, -1193, 185, -1191, 181, -1197, 190, -1203, 184, -1215, 154, + -1199, 163, -1183, 169, -1186, 171, -1181, 168, -1179, 174, -1168, 178, + -1170, 180, -1165, 175, -1162, 180, -1152 + ], + [51.9, 21.3, 707, 1262, 708, 1262, 694, 1236, 681, 1243, 695, 1269], + [51.9, 18.9, 50, 295, 37, 272, 25, 278, 38, 302], + [ + 52, 12.8, -70, -232, -57, -239, -62, -248, -95, -229, -92, -223, -71, -234 + ], + [ + 52, 13.1, -317, -533, -319, -536, -315, -538, -321, -549, -313, -553, + -307, -542, -295, -548, -299, -573, -303, -575, -336, -557, -322, -531 + ], + [ + 52, 14.3, -219, 444, -233, 419, -256, 432, -253, 436, -255, 437, -244, 457 + ], + [52.1, 8.5, -997, -838, -1009, -859, -1028, -848, -1017, -827], + [52.1, 18.3, 419, -147, 424, -150, 420, -157, 394, -142, 398, -135], + [ + 52.1, 12.8, -326, -1160, -338, -1181, -362, -1167, -360, -1161, -341, + -1164, -342, -1166, -338, -1168, -332, -1157 + ], + [ + 52.1, 14.6, -950, 641, -953, 636, -943, 631, -952, 615, -948, 613, -954, + 603, -986, 621, -974, 641, -972, 639, -969, 645, -971, 646, -969, 651 + ], + [52.2, 19.2, 90, 541, 82, 525, 55, 540, 64, 555], + [ + 52.3, 6.7, 676, -974, 691, -982, 697, -970, 720, -983, 713, -995, 729, + -1004, 714, -1030, 653, -996, 670, -967, 676, -971, 674, -973 + ], + [52.3, 11.3, 389, -663, 393, -657, 414, -669, 410, -675], + [52.3, 22.9, 447, 43, 418, 59, 419, 61, 414, 64, 425, 85, 460, 66], + [52.3, 9.8, -680, -580, -695, -607, -708, -600, -693, -573], + [ + 52.4, 10.1, -796, -302, -781, -276, -787, -273, -773, -248, -740, -265, + -761, -301, -760, -301, -769, -317 + ], + [52.4, 11.6, -452, 449, -464, 428, -476, 434, -464, 456], + [52.4, 17.7, 230, 16, 202, -35, 117, 12, 146, 63], + [52.4, 23.8, 339, 223, 328, 202, 314, 210, 326, 231, 340, 224], + [ + 52.4, 11, -611, -1339, -622, -1358, -620, -1359, -622, -1363, -620, -1365, + -626, -1376, -646, -1365, -647, -1363, -628, -1330 + ], + [ + 52.5, 11.6, -431, -717, -447, -746, -443, -749, -441, -747, -435, -750, + -436, -752, -418, -762, -431, -786, -474, -762, -445, -710 + ], + [ + 52.5, 20.4, 615, 971, 582, 989, 586, 997, 588, 994, 591, 999, 593, 999, + 621, 983 + ], + [ + 52.5, 7.3, -913, -452, -925, -475, -950, -460, -952, -463, -967, -455, + -965, -452, -972, -449, -959, -426, -953, -429, -954, -431, -933, -441, + -933, -442, -920, -449, -919, -448 + ], + [ + 52.6, 5.5, 624, -1142, 650, -1156, 635, -1182, 597, -1161, 600, -1155, + 581, -1144, 592, -1124 + ], + [ + 52.6, 18.3, 146, 876, 133, 851, 128, 853, 129, 855, 125, 857, 124, 855, + 114, 861, 131, 892, 150, 882 + ], + [ + 52.6, 11.9, 520, -793, 508, -815, 506, -814, 505, -816, 509, -818, 502, + -832, 499, -830, 500, -828, 499, -827, 498, -829, 485, -822, 498, -800, + 500, -801, 509, -786 + ], + [ + 52.7, 11.6, -788, -288, -796, -302, -829, -284, -821, -269, -819, -271, + -814, -262, -786, -277, -791, -286 + ], + [52.8, 11.9, 1266, 864, 1240, 878, 1254, 904, 1280, 890], + [52.8, 21.3, 819, 1055, 804, 1028, 790, 1036, 805, 1062], + [52.9, 18.6, 468, 1067, 453, 1041, 428, 1055, 442, 1082], + [ + 52.9, 12.5, 241, -403, 256, -412, 254, -416, 263, -421, 254, -437, 228, + -423, 240, -403 + ], + [ + 52.9, 11, -54, -499, -29, -513, -40, -533, -65, -519, -69, -526, -82, + -518, -78, -511, -74, -514, -70, -505, -73, -503, -70, -496, -57, -504 + ], + [ + 53, 10.1, 206, -733, 181, -719, 185, -712, 183, -711, 194, -692, 220, -707 + ], + [ + 53, 4.3, -757, 869, -749, 886, -758, 891, -749, 908, -736, 901, -735, 903, + -733, 901, -731, 906, -719, 899, -741, 860 + ], + [53, 23.2, 519, 172, 508, 152, 487, 164, 491, 170, 497, 167, 503, 181], + [53, 18.6, 481, 1060, 466, 1034, 453, 1041, 468, 1067], + [ + 53, 7.9, -1079, -830, -1079, -831, -1060, -841, -1071, -860, -1097, -845, + -1086, -826 + ], + [ + 53, 14, -847, 504, -851, 497, -854, 499, -860, 487, -857, 485, -872, 459, + -876, 461, -878, 458, -904, 472, -877, 521, -874, 520, -872, 523, -865, + 519, -867, 516, -856, 510, -855, 513, -847, 509, -849, 506 + ], + [ + 53, 18.6, 573, 738, 559, 712, 544, 719, 548, 726, 522, 740, 532, 757, 534, + 758 + ], + [ + 53, 9.1, 474, -973, 488, -980, 474, -1004, 448, -990, 450, -986, 440, + -980, 445, -970, 448, -972, 450, -967, 469, -977, 470, -976, 472, -976 + ], + [ + 53.1, 9.1, -871, -1217, -857, -1225, -867, -1243, -899, -1225, -889, -1207 + ], + [ + 53.1, 12.2, 463, -679, 453, -696, 482, -713, 472, -731, 454, -721, 453, + -724, 427, -710, 449, -671 + ], + [53.1, 14.6, -260, 733, -275, 705, -308, 724, -293, 752], + [ + 53.1, 9.1, 264, -939, 247, -968, 227, -957, 237, -941, 241, -943, 251, + -925, 266, -933 + ], + [ + 53.2, 22.9, 225, 143, 229, 141, 237, 155, 245, 150, 246, 152, 252, 149, + 237, 123, 192, 148, 198, 158 + ], + [53.2, 19.5, 790, 960, 771, 969, 780, 985, 799, 975], + [ + 53.3, 7.9, 501, -1040, 519, -1050, 516, -1054, 522, -1057, 513, -1073, + 504, -1069, 498, -1080, 512, -1087, 503, -1104, 492, -1098, 490, -1102, + 463, -1087, 492, -1035 + ], + [53.3, 14.9, -9, 205, 2, 225, 10, 221, -1, 200], + [ + 53.3, 20.1, 335, 779, 322, 756, 319, 758, 302, 728, 284, 738, 296, 759, + 305, 754, 323, 786 + ], + [ + 53.3, 6.4, -985, -707, -1001, -698, -998, -693, -995, -694, -993, -690, + -1011, -681, -1008, -676, -1009, -675, -1003, -665, -971, -682 + ], + [53.4, 10.7, -130, -1008, -144, -1034, -164, -1023, -149, -997], + [ + 53.4, 13.4, 1065, 703, 1062, 698, 1048, 705, 1037, 684, 1024, 691, 1038, + 718 + ], + [ + 53.6, 15.2, 1325, 400, 1318, 389, 1308, 394, 1304, 389, 1300, 391, 1298, + 389, 1290, 394, 1299, 410, 1297, 413, 1303, 423, 1305, 424, 1314, 419, + 1314, 416, 1329, 408 + ], + [ + 53.6, 15.8, 1135, 358, 1143, 374, 1149, 371, 1151, 374, 1161, 368, 1159, + 366, 1162, 364, 1153, 348 + ], + [ + 53.6, 10.7, -624, 902, -627, 896, -622, 893, -633, 873, -657, 886, -643, + 912 + ], + [ + 53.7, 4.3, 892, -816, 919, -829, 909, -847, 922, -854, 928, -844, 932, + -846, 933, -845, 940, -850, 934, -860, 946, -867, 956, -849, 968, -856, + 967, -857, 990, -870, 966, -912, 943, -899, 943, -901, 931, -895, 941, + -877, 930, -871, 927, -878, 924, -876, 920, -884, 918, -884, 909, -878, + 913, -870, 911, -869, 914, -863, 904, -857, 894, -874, 883, -868, 884, + -866, 861, -854, 866, -844, 889, -856, 901, -835, 878, -822, 884, -812 + ], + [ + 53.8, 11.6, -650, 555, -663, 531, -676, 539, -662, 563, -661, 562, -660, + 563, -649, 557 + ], + [ + 53.8, 10.4, -67, -582, -75, -578, -89, -603, -105, -594, -76, -542, -52, + -555 + ], + [53.8, 10.7, 744, -734, 732, -755, 716, -746, 728, -725], + [53.8, 14.9, -85, 191, -115, 139, -153, 160, -154, 163, -126, 214], + [ + 53.8, 9.8, -858, -289, -868, -309, -872, -307, -879, -320, -876, -322, + -887, -341, -940, -312, -929, -293, -926, -295, -918, -281, -922, -279, + -911, -260 + ], + [ + 53.8, 8.8, 72, -1347, 90, -1356, 91, -1354, 106, -1362, 99, -1375, 97, + -1374, 94, -1379, 85, -1373, 77, -1387, 87, -1393, 86, -1394, 89, -1396, + 80, -1412, 64, -1403, 65, -1401, 48, -1390, 52, -1382, 55, -1384, 70, + -1357, 68, -1355 + ], + [53.8, 7.6, -1089, -708, -1096, -720, -1152, -689, -1145, -677], + [53.9, 15.5, 171, 1270, 164, 1257, 146, 1266, 153, 1280], + [ + 53.9, 12.2, -500, -1037, -538, -1016, -537, -1015, -542, -1012, -539, + -1007, -496, -1030 + ], + [54, 9.1, -686, 29, -684, 27, -699, 1, -711, 8, -696, 34], + [ + 54, 13.7, -288, 441, -281, 437, -280, 439, -261, 429, -273, 406, -318, + 430, -305, 455, -302, 453, -303, 452, -287, 443 + ], + [54.1, 18, 628, 667, 616, 646, 578, 668, 592, 693, 605, 686, 602, 681], + [54.1, 13.1, -303, -371, -313, -390, -340, -376, -327, -352, -300, -367], + [54.1, 18, 131, 892, 117, 866, 97, 877, 112, 903], + [ + 54.1, 12.2, -526, -1219, -524, -1217, -518, -1220, -530, -1243, -569, + -1222, -562, -1209, -530, -1227 + ], + [54.2, 9.4, -723, 172, -737, 146, -751, 154, -736, 180], + [54.2, 23.8, 408, 153, 405, 147, 401, 149, 397, 142, 370, 157, 377, 170], + [ + 54.3, 6.7, 943, -742, 939, -749, 954, -757, 952, -759, 986, -778, 974, + -800, 908, -763, 920, -742, 927, -746, 929, -743, 930, -744, 934, -736 + ], + [ + 54.3, 12.2, -391, -839, -422, -822, -419, -817, -417, -818, -416, -816, + -386, -832, -390, -840 + ], + [54.3, 12.2, -384, 625, -399, 598, -419, 609, -405, 636], + [ + 54.3, 11, -167, -1074, -187, -1063, -185, -1060, -198, -1053, -213, -1080, + -220, -1077, -205, -1050, -212, -1046, -200, -1024, -153, -1050 + ], + [54.3, 11.3, -21, -501, -47, -486, -39, -473, -13, -487], + [54.3, 15.2, -241, 779, -232, 774, -247, 748, -260, 755, -245, 781], + [ + 54.3, 7, -1013, -707, -1020, -719, -1038, -709, -1024, -686, -1020, -688, + -1021, -690, -1008, -697 + ], + [54.3, 11.9, -505, -1229, -517, -1250, -530, -1243, -519, -1222], + [ + 54.4, 7.3, 566, -395, 551, -421, 528, -409, 534, -399, 536, -400, 539, + -394, 534, -391, 539, -381 + ], + [ + 54.5, 15.5, 1355, 215, 1373, 205, 1358, 179, 1312, 205, 1323, 226, 1310, + 233, 1313, 238 + ], + [ + 54.5, 7.6, 92, -1140, 91, -1143, 88, -1141, 85, -1143, 83, -1148, 87, + -1150, 82, -1159, 59, -1146, 63, -1139, 66, -1141, 73, -1127, 70, -1125, + 73, -1120, 96, -1134 + ], + [54.5, 10.7, -515, 518, -529, 492, -548, 502, -534, 528], + [54.6, 15.8, -199, 948, -183, 940, -197, 915, -218, 925, -204, 951], + [54.6, 11.9, -419, 609, -406, 602, -420, 576, -434, 583], + [ + 54.6, 6.4, 306, -1125, 293, -1148, 290, -1147, 292, -1142, 288, -1140, + 290, -1137, 286, -1135, 291, -1126, 289, -1126, 292, -1122, 295, -1123, + 297, -1120 + ], + [ + 54.6, 4.6, -1351, -333, -1363, -326, -1354, -310, -1355, -309, -1350, + -299, -1321, -314, -1323, -319, -1311, -325, -1310, -323, -1301, -328, + -1310, -342, -1313, -341, -1315, -344, -1335, -334, -1338, -340 + ], + [ + 54.6, 13.1, -165, -140, -164, -138, -152, -144, -166, -169, -180, -162, + -168, -141, -166, -142 + ], + [ + 54.7, 18, 703, 63, 695, 49, 673, 61, 689, 88, 706, 78, 700, 68, 702, 66, + 701, 64 + ], + [54.7, 19.8, 907, 1228, 898, 1213, 878, 1224, 889, 1243, 909, 1232], + [54.7, 14.6, 147, 1120, 150, 1118, 135, 1092, 123, 1099, 137, 1126], + [54.7, 14, -252, 462, -265, 439, -282, 448, -270, 471], + [54.8, 12.8, -728, 601, -743, 576, -765, 588, -750, 613], + [54.8, 12.5, -375, 619, -390, 593, -399, 598, -384, 625], + [54.8, 3.4, -1512, 130, -1545, 149, -1532, 173, -1498, 154], + [ + 54.8, 12.2, 1104, 682, 1093, 688, 1094, 690, 1086, 695, 1100, 718, 1126, + 704, 1113, 680, 1105, 684 + ], + [ + 54.9, 8.5, -907, -1255, -921, -1280, -914, -1284, -931, -1314, -964, + -1295, -935, -1244, -930, -1243 + ], + [ + 54.9, 10.4, -565, 456, -576, 437, -578, 438, -582, 431, -593, 438, -579, + 463 + ], + [ + 54.9, 8.2, -746, -28, -740, -32, -754, -57, -787, -39, -776, -19, -774, + -19, -773, -17, -755, -27, -753, -24 + ], + [54.9, 12.5, 1393, 258, 1391, 255, 1379, 262, 1392, 285, 1404, 278], + [ + 54.9, 10.4, -947, 207, -949, 203, -931, 195, -930, 197, -913, 188, -924, + 168, -938, 177, -937, 179, -939, 181, -942, 176, -945, 164, -941, 162, + -947, 151, -940, 147, -945, 137, -969, 150, -964, 160, -957, 156, -950, + 167, -947, 165, -943, 177, -949, 180, -946, 185, -950, 187, -951, 184, + -965, 191, -955, 211 + ], + [55, 11, 175, -626, 161, -652, 117, -628, 131, -602], + [ + 55, 14, -240, 1062, -218, 1050, -233, 1023, -286, 1053, -275, 1072, -244, + 1055 + ], + [55.1, 11.6, -405, 636, -419, 609, -433, 617, -418, 643], + [55.1, 13.4, -335, 775, -351, 747, -361, 753, -345, 781], + [55.2, 17.7, -43, 223, -31, 243, -19, 237, -31, 216], + [55.2, 22.9, 424, 47, 444, 36, 433, 15, 401, 34, 409, 49, 422, 42], + [55.2, 11.3, -681, 843, -647, 825, -662, 799, -696, 817], + [55.2, 12.2, -395, 418, -410, 391, -445, 411, -430, 437], + [ + 55.2, 4, 854, -1209, 856, -1211, 877, -1173, 839, -1152, 835, -1159, 818, + -1149, 822, -1142, 798, -1129, 799, -1126, 794, -1123, 793, -1126, 789, + -1123, 778, -1142, 775, -1152, 767, -1161, 759, -1156, 757, -1159, 753, + -1156, 754, -1154, 735, -1143, 737, -1140, 710, -1125, 717, -1114, 713, + -1112, 716, -1107, 726, -1089, 729, -1091, 736, -1079, 759, -1091, 760, + -1089, 801, -1111, 800, -1113, 829, -1129, 830, -1128, 835, -1130, 834, + -1132, 841, -1136, 842, -1134, 847, -1137, 846, -1139, 876, -1155, 877, + -1153, 923, -1179, 922, -1181, 928, -1187, 931, -1193, 933, -1206, 929, + -1218, 923, -1224, 916, -1228, 916, -1230, 906, -1231, 892, -1226, 890, + -1228, 867, -1215, 867, -1216, 862, -1214, 860, -1218, 851, -1213 + ], + [ + 55.2, 19.5, 667, 923, 674, 919, 659, 893, 619, 915, 626, 926, 652, 911, + 661, 926 + ], + [ + 55.2, 9.4, 330, -464, 328, -463, 323, -472, 306, -464, 316, -447, 327, + -453, 332, -445, 338, -449 + ], + [ + 55.2, 13.1, 795, 31, 801, 28, 785, -1, 757, 17, 765, 28, 772, 24, 779, 34, + 785, 31, 785, 32, 788, 31, 790, 34 + ], + [ + 55.2, 4.9, -1390, -403, -1393, -408, -1389, -410, -1398, -426, -1415, + -416, -1404, -396 + ], + [ + 55.3, 18.9, 112, 127, 102, 109, 75, 124, 84, 140, 86, 139, 90, 146, 105, + 138, 102, 132 + ], + [ + 55.4, 18.6, 517, 950, 504, 926, 502, 927, 501, 925, 478, 937, 479, 940, + 477, 941, 490, 965 + ], + [55.4, 9.4, -722, 48, -696, 34, -711, 8, -742, 25, -728, 51], + [55.4, 11.3, 47, -377, 33, -403, 8, -389, 22, -363], + [55.4, 11, -477, 556, -466, 550, -482, 521, -505, 533, -489, 562], + [55.4, 19.5, 786, 952, 780, 942, 759, 954, 764, 964], + [55.5, 12.5, -319, 59, -328, 43, -332, 45, -323, 61], + [ + 55.5, 10.4, 578, -926, 575, -933, 574, -934, 575, -938, 570, -938, 564, + -947, 566, -953, 565, -954, 557, -949, 552, -951, 548, -948, 546, -944, + 555, -930, 560, -930, 558, -924, 559, -922, 560, -923, 568, -908, 567, + -908, 568, -906, 574, -904, 584, -909, 585, -915 + ], + [ + 55.5, 12.2, -243, -1214, -266, -1202, -260, -1191, -292, -1175, -278, + -1149, -224, -1179 + ], + [55.5, 18.9, 548, 661, 535, 638, 521, 645, 534, 669], + [55.5, 11.6, -437, 534, -411, 519, -427, 490, -457, 507, -441, 536], + [55.6, 11.3, -563, 868, -577, 841, -597, 852, -582, 879], + [55.6, 9.4, -707, 74, -722, 48, -735, 56, -721, 82], + [55.7, 11.3, -418, 643, -433, 617, -453, 628, -438, 654], + [ + 55.7, 10.4, 650, -798, 641, -815, 636, -817, 626, -811, 624, -806, 633, + -790, 639, -788, 648, -793 + ], + [55.7, 12.8, -357, 698, -371, 672, -381, 677, -366, 704], + [ + 55.8, 16.2, -30, 92, -18, 113, -24, 116, -17, 127, -13, 125, -2, 145, 19, + 133, -10, 81 + ], + [ + 55.8, 5.5, -1274, 11, -1286, -7, -1275, -13, -1282, -26, -1305, -13, + -1300, -3, -1298, -4, -1291, 8, -1293, 9, -1284, 26, -1270, 19 + ], + [ + 55.8, 14, -285, 659, -299, 633, -301, 634, -300, 637, -330, 654, -317, 677 + ], + [56, 12.5, -378, -413, -391, -437, -418, -422, -404, -398], + [ + 56.1, 21.6, 499, 12, 498, 9, 500, 8, 495, -2, 500, -5, 499, -7, 503, -9, + 498, -18, 485, -11, 483, -12, 470, -5, 484, 21 + ], + [56.1, 11.3, 853, -4, 867, 22, 881, 15, 866, -12], + [56.1, 8.8, -761, 104, -775, 78, -789, 85, -774, 111], + [56.2, 14, -303, 758, -319, 729, -351, 747, -335, 775], + [ + 56.2, 21, 650, 1034, 623, 1049, 618, 1040, 602, 1049, 617, 1076, 660, 1052 + ], + [56.3, 23.5, 345, 219, 336, 202, 329, 205, 339, 223], + [ + 56.4, 11.3, 1433, 408, 1425, 394, 1422, 395, 1421, 392, 1394, 407, 1395, + 410, 1392, 412, 1400, 427 + ], + [ + 56.4, 18.6, 295, -57, 282, -80, 275, -76, 281, -65, 277, -63, 278, -61, + 256, -49, 278, -10, 303, -24, 302, -26, 306, -28, 299, -39, 295, -37, 287, + -51, 287, -53 + ], + [56.4, 19.8, 348, 772, 336, 750, 323, 757, 335, 779], + [56.4, 12.5, -462, -879, -476, -903, -503, -888, -489, -864], + [ + 56.4, 9.8, -88, -1217, -69, -1227, -77, -1241, -102, -1227, -96, -1217, + -94, -1218, -92, -1215 + ], + [ + 56.4, 4.9, -1316, 44, -1323, 33, -1325, 34, -1330, 24, -1328, 23, -1338, + 5, -1352, 13, -1342, 31, -1340, 30, -1335, 39, -1346, 45, -1339, 58 + ], + [ + 56.4, 9.8, 619, -852, 626, -858, 627, -865, 622, -875, 616, -877, 610, + -874, 603, -875, 593, -870, 591, -864, 594, -862, 601, -848, 607, -846, + 617, -853 + ], + [56.5, 19.5, 646, 143, 633, 120, 612, 131, 625, 155], + [56.5, 16.2, -67, 210, -56, 229, -43, 222, -54, 203], + [ + 56.5, 23.5, 321, 175, 346, 161, 342, 155, 302, 177, 317, 203, 330, 195, + 320, 176 + ], + [ + 56.7, 13.4, -352, 1043, -332, 1031, -339, 1019, -359, 1031, -371, 1009, + -378, 1013, -363, 1039, -358, 1037, -358, 1038, -355, 1037 + ], + [56.7, 22.3, 545, 409, 541, 402, 516, 416, 519, 423], + [56.7, 11.9, -542, -1493, -551, -1488, -535, -1461, -525, -1467], + [56.7, 16.8, 1299, 367, 1296, 362, 1278, 373, 1288, 390, 1306, 380], + [56.8, 13.1, -321, -228, -336, -255, -349, -247, -335, -221], + [56.8, 9.4, 96, -817, 84, -837, 73, -831, 85, -810], + [56.8, 3.4, 1039, -456, 1028, -476, 1010, -466, 1020, -446], + [ + 56.9, 10.4, -691, -1319, -700, -1335, -747, -1309, -737, -1291, -690, + -1318 + ], + [56.9, 9.4, -785, -472, -812, -458, -789, -417, -762, -432], + [56.9, 8.2, 476, -354, 465, -374, 440, -360, 451, -340], + [ + 57, 13.4, -976, 828, -961, 854, -929, 836, -941, 812, -970, 828, -971, 825 + ], + [57, 13.1, 1340, 444, 1336, 437, 1316, 448, 1327, 467, 1347, 456], + [57, 12.2, -490, -1406, -537, -1380, -524, -1362, -523, -1361, -479, -1385], + [ + 57.1, 9.1, -706, -16, -715, -33, -719, -31, -721, -34, -724, -33, -728, + -40, -734, -37, -719, -9 + ], + [57.1, 15.2, -229, 716, -243, 691, -251, 695, -237, 721], + [57.2, 13.1, -319, 59, -370, 87, -341, 140, -234, 81, -263, 28], + [57.2, 18, 1212, 368, 1231, 357, 1209, 317, 1184, 331, 1204, 372], + [57.2, 10.4, -91, -1516, -68, -1529, -79, -1550, -104, -1536, -93, -1516], + [57.3, 14.6, 137, 1126, 123, 1099, 91, 1117, 97, 1127, 75, 1139, 84, 1155], + [57.3, 9.8, -670, -79, -644, -93, -655, -112, -681, -98], + [ + 57.3, 7, 578, -1233, 577, -1227, 582, -1218, 585, -1220, 591, -1209, 593, + -1210, 598, -1208, 609, -1214, 608, -1216, 609, -1222, 604, -1230, 601, + -1228, 595, -1240, 593, -1239, 588, -1240, 577, -1234 + ], + [ + 57.3, 7.9, -1107, -1082, -1109, -1086, -1112, -1084, -1122, -1102, -1158, + -1082, -1128, -1027, -1105, -1040, -1115, -1054, -1113, -1055, -1117, + -1062, -1114, -1064, -1117, -1069, -1103, -1076 + ], + [57.3, 17.4, -33, 720, -62, 736, -56, 766, -27, 750, -33, 741, -24, 736], + [57.3, 17.7, 667, 776, 653, 750, 642, 755, 645, 761, 640, 764, 652, 785], + [57.4, 11.6, -682, 700, -697, 674, -723, 688, -709, 714], + [57.4, 13.7, -990, 681, -1000, 663, -1014, 670, -1004, 688], + [ + 57.4, 11.3, -534, -1411, -541, -1423, -623, -1378, -613, -1360, -607, + -1364, -606, -1363, -578, -1378, -578, -1379, -575, -1381, -577, -1385, + -571, -1388, -569, -1385, -531, -1406 + ], + [ + 57.4, 6.4, 1020, -171, 1021, -168, 1024, -169, 1027, -165, 1028, -164, + 1026, -163, 1029, -157, 1044, -165, 1030, -191, 1028, -190, 1026, -194, + 1012, -185, 1019, -177, 1022, -172 + ], + [ + 57.4, 13.7, 1222, 465, 1213, 449, 1209, 451, 1210, 454, 1199, 460, 1196, + 459, 1193, 460, 1202, 476 + ], + [ + 57.6, 9.8, -433, 1294, -443, 1277, -448, 1279, -449, 1278, -444, 1275, + -463, 1241, -487, 1254, -457, 1308 + ], + [57.6, 5.8, 1406, 751, 1421, 778, 1436, 770, 1421, 743], + [ + 57.6, 12.2, 1240, 878, 1266, 864, 1251, 837, 1228, 850, 1229, 851, 1224, + 854, 1238, 879 + ], + [ + 57.6, 12.2, -400, 221, -412, 200, -438, 215, -433, 225, -416, 216, -411, + 226 + ], + [57.6, 14.3, 242, -136, 231, -156, 205, -142, 216, -122], + [ + 57.7, 11.3, -709, -380, -717, -394, -723, -391, -726, -396, -734, -392, + -722, -373 + ], + [ + 57.7, 8.2, -1165, -1029, -1179, -1021, -1177, -1017, -1179, -1016, -1177, + -1014, -1184, -1010, -1178, -999, -1155, -1012 + ], + [57.7, 13.4, -323, 680, -337, 654, -348, 660, -334, 686], + [ + 57.8, 9.1, -43, -1450, -46, -1455, -28, -1464, -52, -1508, -75, -1495, + -70, -1484, -68, -1486, -66, -1484, -63, -1478, -69, -1475, -52, -1445 + ], + [57.8, 11.9, -576, -1276, -585, -1293, -600, -1285, -591, -1268], + [ + 57.8, 13.1, 1115, 47, 1116, 46, 1113, 40, 1115, 39, 1107, 25, 1116, 21, + 1118, 24, 1134, 15, 1132, 11, 1141, 7, 1137, 0, 1140, -1, 1139, -5, 1133, + -15, 1121, -8, 1123, -4, 1091, 12, 1090, 9, 1077, 17, 1099, 56 + ], + [57.8, 11.9, -389, 538, -402, 514, -412, 520, -399, 544], + [57.9, 9.8, -741, -183, -759, -216, -773, -208, -755, -175], + [ + 57.9, 12.2, -443, -1123, -497, -1093, -482, -1066, -431, -1094, -432, + -1096, -430, -1098 + ], + [58, 20.7, 128, 204, 120, 188, 106, 195, 121, 222, 134, 214], + [58, 18.9, 65, 248, 52, 225, 35, 234, 48, 259, 65, 249], + [ + 58, 7.3, 1427, 569, 1423, 561, 1390, 580, 1411, 619, 1438, 604, 1430, 591, + 1437, 587 + ], + [58, 13.4, 1212, 829, 1201, 809, 1174, 824, 1189, 850, 1215, 835], + [ + 58.1, 7.9, 863, -188, 856, -202, 852, -199, 840, -195, 832, -196, 822, + -199, 808, -190, 808, -188, 822, -180, 837, -177, 856, -181, 865, -186 + ], + [ + 58.1, 7.6, -1149, -941, -1142, -927, -1115, -941, -1130, -968, -1157, + -954, -1152, -945, -1141, -951, -1139, -947 + ], + [58.2, 10.7, -475, -240, -484, -256, -495, -250, -486, -234], + [58.2, 19.8, 877, 1316, 890, 1338, 896, 1335, 883, 1312], + [58.2, 16.5, 79, 70, 106, 55, 90, 26, 62, 41], + [ + 58.3, 9.8, -32, -1576, -50, -1566, -34, -1539, -11, -1552, -20, -1567, + -22, -1566, -26, -1573, -30, -1571 + ], + [ + 58.4, 17.7, 464, 979, 450, 956, 448, 957, 447, 954, 430, 964, 431, 966, + 429, 968, 442, 991 + ], + [58.4, 11.3, -671, 782, -685, 756, -705, 767, -691, 793], + [58.4, 19.2, 383, 898, 403, 887, 389, 861, 367, 873, 382, 899], + [58.6, 12.2, -730, 692, -710, 681, -725, 655, -747, 667, -732, 693], + [58.7, 10.1, -613, -522, -621, -537, -634, -529, -626, -515], + [ + 58.8, 13.4, -1023, 517, -1049, 473, -1045, 471, -1048, 467, -1061, 474, + -1064, 482, -1084, 492, -1059, 537 + ], + [ + 58.8, 10.1, -89, -936, -105, -927, -102, -922, -118, -914, -122, -922, + -133, -917, -134, -919, -139, -916, -123, -887, -76, -913 + ], + [58.8, 13.4, -115, -202, -128, -225, -140, -218, -127, -195], + [ + 58.8, 11.6, 268, -418, 268, -420, 280, -427, 273, -441, 257, -432, 265, + -417 + ], + [58.8, 8.2, -833, -125, -847, -151, -866, -140, -852, -114], + [ + 58.9, 8.8, 398, -381, 380, -371, 378, -374, 375, -373, 374, -376, 371, + -374, 384, -350, 410, -365, 401, -383 + ], + [ + 59.1, 8.8, -31, -1062, -13, -1072, -26, -1097, -47, -1086, -40, -1073, + -38, -1074 + ], + [59.1, 15.8, 485, -176, 479, -186, 444, -166, 453, -151, 488, -170], + [59.1, 14.6, -263, 984, -204, 951, -218, 925, -324, 984, -309, 1010], + [ + 59.2, 5.5, -1157, -136, -1158, -143, -1147, -145, -1149, -158, -1164, + -156, -1169, -186, -1155, -188, -1158, -202, -1169, -200, -1169, -202, + -1171, -202, -1172, -211, -1183, -209, -1182, -197, -1196, -195, -1193, + -181, -1182, -183, -1182, -181, -1181, -181, -1179, -171, -1182, -170, + -1181, -165, -1178, -166, -1176, -156, -1177, -155, -1176, -153, -1188, + -151, -1185, -137, -1171, -140, -1168, -130, -1157, -133 + ], + [ + 59.2, 6.7, -1115, 61, -1120, 51, -1110, 45, -1117, 33, -1129, 40, -1144, + 13, -1132, 6, -1138, -6, -1148, 0, -1149, -2, -1150, -2, -1155, -10, + -1164, -5, -1160, 6, -1172, 13, -1166, 25, -1156, 20, -1155, 22, -1154, + 21, -1149, 30, -1151, 32, -1148, 37, -1146, 35, -1141, 47, -1151, 52, + -1144, 64, -1131, 57, -1130, 59, -1129, 59, -1125, 66 + ], + [ + 59.2, 16.5, -157, 1504, -172, 1477, -174, 1478, -177, 1473, -168, 1468, + -180, 1447, -223, 1470, -208, 1497, -185, 1484, -170, 1511 + ], + [ + 59.3, 9.1, -1006, 45, -1020, 53, -1012, 66, -1025, 73, -1018, 85, -1008, + 80, -1002, 89, -992, 83, -996, 76, -995, 75, -996, 73, -984, 66, -991, 54, + -1000, 59, -1001, 57, -1003, 58, -1008, 49, -1005, 47 + ], + [59.4, 14, -243, 300, -263, 311, -251, 333, -231, 322], + [ + 59.5, 8.5, -921, 12, -925, 4, -924, 4, -925, 2, -913, -5, -919, -17, -929, + -12, -930, -14, -932, -13, -944, -36, -943, -37, -944, -39, -934, -44, + -941, -56, -954, -50, -955, -51, -956, -51, -960, -59, -970, -54, -965, + -43, -975, -37, -968, -25, -956, -32, -941, -6, -954, 1, -947, 14, -937, + 8, -936, 10, -935, 9, -930, 17 + ], + [ + 59.5, 6.4, 235, -1353, 261, -1366, 262, -1364, 272, -1369, 266, -1380, + 263, -1378, 260, -1384, 257, -1382, 248, -1399, 251, -1401, 248, -1406, + 250, -1408, 245, -1418, 235, -1413, 236, -1410, 220, -1401, 228, -1388, + 234, -1391, 243, -1375, 230, -1369, 231, -1367, 228, -1366 + ], + [ + 59.5, 21, 197, 482, 192, 472, 190, 473, 185, 465, 187, 464, 183, 457, 174, + 461, 174, 462, 169, 465, 173, 473, 175, 472, 184, 489 + ], + [ + 59.7, 9.4, -76, -1224, -80, -1222, -60, -1188, -50, -1193, -54, -1201, + -59, -1199, -61, -1203, -57, -1205, -61, -1213, -65, -1210, -67, -1214, + -63, -1217, -67, -1224, -74, -1221 + ], + [59.8, 23.8, 338, 191, 357, 181, 351, 171, 329, 183, 335, 193], + [ + 59.8, 7.3, -998, -134, -1001, -138, -997, -139, -1000, -151, -994, -154, + -999, -164, -1012, -158, -1017, -168, -1030, -162, -1023, -149, -1033, + -142, -1027, -132, -1019, -137, -1018, -136, -1016, -137, -1011, -127 + ], + [ + 59.9, 6.7, -1177, -37, -1171, -39, -1176, -47, -1174, -47, -1175, -49, + -1166, -55, -1172, -67, -1179, -63, -1181, -67, -1187, -62, -1193, -72, + -1198, -67, -1199, -68, -1202, -66, -1197, -56, -1198, -56, -1197, -54, + -1206, -48, -1199, -36, -1187, -43, -1186, -41, -1185, -42, -1180, -33 + ], + [ + 60, 17.7, 425, 1091, 412, 1066, 410, 1067, 409, 1065, 390, 1076, 391, + 1077, 389, 1078, 396, 1091, 398, 1089, 400, 1094, 398, 1095, 403, 1103 + ], + [ + 60, 6.1, -1086, -179, -1078, -186, -1077, -185, -1076, -186, -1069, -180, + -1062, -188, -1069, -194, -1068, -195, -1069, -196, -1060, -207, -1070, + -216, -1077, -208, -1079, -209, -1080, -209, -1087, -215, -1085, -218, + -1089, -222, -1092, -220, -1099, -226, -1098, -227, -1100, -229, -1092, + -237, -1102, -246, -1112, -236, -1121, -243, -1129, -235, -1121, -226, + -1129, -218, -1118, -209, -1109, -219, -1086, -198, -1096, -188 + ], + [ + 60.1, 4.6, -1253, -183, -1260, -195, -1248, -203, -1253, -213, -1263, + -207, -1264, -208, -1266, -207, -1271, -217, -1284, -210, -1277, -197, + -1287, -191, -1281, -181, -1270, -186, -1265, -176 + ], + [ + 60.1, 19.2, 40, 1576, 32, 1562, 19, 1569, 12, 1557, 25, 1550, 20, 1540, 7, + 1547, 5, 1543, -9, 1551, 13, 1590 + ], + [60.1, 17.7, 668, 741, 653, 750, 667, 776, 683, 768], + [60.4, 13.4, -284, 922, -297, 899, -318, 911, -306, 933], + [ + 60.4, 13.1, -409, -1258, -448, -1236, -452, -1242, -454, -1241, -459, + -1251, -464, -1249, -463, -1246, -469, -1242, -457, -1221, -404, -1250 + ], + [60.4, 9.8, 1412, 480, 1411, 477, 1378, 495, 1391, 519, 1424, 501], + [ + 60.5, 8.5, 598, -331, 590, -346, 568, -334, 574, -322, 580, -325, 581, + -324, 584, -326, 587, -321, 588, -322, 590, -318, 588, -318, 600, -298, + 612, -305 + ], + [ + 60.6, 7.9, -886, -466, -904, -497, -908, -495, -908, -493, -929, -481, + -913, -452 + ], + [60.6, 9.8, -693, 116, -705, 94, -719, 102, -707, 123], + [60.6, 8.5, -762, 70, -755, 67, -770, 41, -783, 48, -769, 74], + [ + 60.7, 11.6, -614, -1235, -618, -1241, -636, -1232, -628, -1217, -610, + -1227 + ], + [60.7, 5.8, -887, 1318, -897, 1300, -917, 1311, -907, 1329], + [ + 60.7, 12.8, -460, -1251, -464, -1259, -462, -1260, -467, -1268, -425, + -1291, -429, -1299, -477, -1273, -464, -1249 + ], + [60.8, 10.4, -643, 644, -663, 655, -649, 681, -629, 670], + [60.8, 9.4, 437, -290, 448, -296, 419, -349, 380, -327, 409, -275], + [ + 60.9, 10.7, -539, 490, -551, 469, -571, 481, -558, 504, -550, 500, -551, + 497 + ], + [60.9, 19.5, 92, 509, 100, 505, 84, 476, 61, 488, 77, 517], + [ + 61, 18.9, 492, 921, 482, 903, 469, 909, 464, 913, 473, 929, 476, 927, 481, + 935, 492, 929, 490, 925, 494, 924 + ], + [ + 61, 7.6, 101, -1295, 110, -1280, 133, -1293, 128, -1301, 119, -1298, 116, + -1303 + ], + [61, 11.9, -523, 846, -516, 842, -531, 815, -557, 830, -542, 856], + [61, 14, 1072, 776, 1082, 771, 1084, 775, 1092, 770, 1081, 750, 1063, 761], + [61.1, 12.8, -394, 771, -371, 758, -384, 735, -418, 753, -404, 777], + [61.2, 12.8, 1380, 438, 1366, 412, 1339, 426, 1354, 452], + [61.3, 19.8, 221, 708, 210, 688, 155, 719, 170, 745, 225, 715], + [ + 61.3, 7.9, 5, -1071, 14, -1076, -5, -1109, -26, -1097, -13, -1072, -9, + -1074, -7, -1070, 2, -1075 + ], + [ + 61.3, 10.7, -93, -1422, -111, -1455, -108, -1456, -107, -1454, -105, + -1455, -102, -1449, -65, -1469, -79, -1493, -163, -1446, -137, -1398 + ], + [61.3, 11.6, -476, -782, -490, -806, -517, -791, -504, -767], + [ + 61.4, 22.9, 242, 299, 239, 298, 172, 336, 202, 390, 271, 352, 265, 341, + 267, 340, 245, 300 + ], + [61.4, 20.1, 894, 1194, 884, 1175, 864, 1186, 874, 1205], + [61.4, 19.8, 106, 226, 93, 203, 80, 210, 93, 233], + [61.4, 11.3, -441, 536, -457, 507, -472, 515, -456, 544], + [61.4, 11.6, -439, 442, -430, 437, -445, 411, -467, 423, -452, 449], + [ + 61.5, 18, 606, 810, 595, 789, 593, 790, 590, 784, 571, 795, 567, 789, 553, + 797, 571, 829 + ], + [ + 61.6, 10.7, -482, -177, -495, -201, -508, -193, -504, -186, -503, -187, + -502, -183, -497, -176, -498, -175, -495, -170 + ], + [61.6, 12.5, 52, -206, 49, -210, 47, -209, 45, -212, 5, -190, 10, -182], + [ + 61.6, 12.5, -360, -894, -359, -895, -361, -899, -345, -907, -335, -908, + -337, -927, -389, -899, -380, -883 + ], + [ + 61.6, 7.6, -1143, 236, -1297, 321, -1292, 329, -1309, 338, -1280, 391, + -1068, 273, -1096, 221, -1138, 244 + ], + [61.7, 20.7, 139, 298, 125, 274, 101, 288, 114, 312], + [ + 61.7, 15.5, -1017, 602, -1028, 581, -1052, 594, -1046, 605, -1045, 605, + -1043, 607, -1047, 609, -1043, 617 + ], + [ + 61.8, 12.5, -451, -917, -437, -924, -451, -949, -502, -921, -491, -900, + -482, -905, -487, -915, -482, -918, -477, -908, -462, -916, -467, -926, + -459, -931 + ], + [61.9, 11.9, -705, 644, -690, 670, -683, 666, -698, 640], + [61.9, 12.2, 188, -365, 190, -366, 176, -392, 165, -387, 180, -361], + [ + 61.9, 18.3, 27, 307, 38, 302, 26, 281, 22, 283, 21, 281, 19, 282, 20, 284, + 16, 286 + ], + [61.9, 14.6, -213, 495, -201, 489, -215, 463, -280, 499, -266, 525], + [61.9, 13.7, -103, 1257, -83, 1246, -97, 1220, -137, 1242, -122, 1268], + [62, 18, -28, 516, -42, 491, -62, 502, -48, 527], + [62.1, 11.9, -399, 544, -412, 520, -427, 528, -414, 552], + [ + 62.1, 10.4, -545, 445, -558, 422, -561, 423, -562, 420, -577, 429, -576, + 432, -578, 433, -565, 456 + ], + [62.2, 12.5, 439, -755, 432, -767, 403, -752, 410, -739], + [ + 62.2, 5.5, 320, -1167, 330, -1173, 326, -1181, 324, -1180, 323, -1182, + 336, -1188, 337, -1187, 335, -1185, 339, -1177, 350, -1183, 345, -1192, + 344, -1191, 343, -1192, 355, -1199, 356, -1197, 354, -1196, 358, -1188, + 369, -1194, 354, -1220, 332, -1208, 335, -1202, 329, -1198, 326, -1204, + 315, -1198, 313, -1196, 316, -1190, 310, -1187, 308, -1192, 305, -1190, + 303, -1192, 284, -1181, 291, -1168, 294, -1169, 301, -1156, 311, -1162, + 307, -1170, 305, -1169, 304, -1171, 316, -1178, 317, -1176, 315, -1175 + ], + [62.2, 19.5, 91, 451, 76, 424, 66, 430, 81, 457], + [62.2, 13.7, -247, 370, -260, 347, -280, 358, -267, 381], + [62.3, 11.3, -438, 654, -453, 628, -470, 638, -456, 664], + [62.3, 15.5, 120, -46, 107, -66, 81, -52, 93, -31], + [62.3, 19.5, 93, 320, 104, 314, 95, 298, 78, 308, 88, 322], + [ + 62.3, 11.9, 141, -520, 128, -545, 108, -533, 113, -523, 116, -525, 124, + -511 + ], + [62.4, 9.8, -561, 699, -565, 690, -579, 698, -564, 724, -551, 716], + [62.5, 12.2, 18, -347, 12, -358, 2, -352, 16, -326, 26, -331], + [ + 62.5, 20.1, 477, -34, 470, -48, 475, -51, 483, -37, 488, -39, 469, -70, + 458, -64, 456, -68, 441, -60, 460, -24, 467, -27 + ], + [ + 62.5, 22.3, 455, 517, 427, 467, 411, 476, 410, 474, 385, 488, 384, 492, + 393, 509, 407, 502, 404, 497, 404, 495, 416, 489, 426, 491, 444, 524 + ], + [62.6, 11.6, -417, 374, -432, 348, -447, 357, -432, 383], + [ + 62.6, 8.5, -6, -1043, -20, -1068, -31, -1062, -28, -1058, -32, -1056, -28, + -1049, -25, -1051, -17, -1036, -6, -1042 + ], + [ + 62.6, 14.6, 1162, 865, 1147, 838, 1149, 837, 1134, 811, 1101, 830, 1130, + 882 + ], + [62.8, 11.6, -399, 598, -375, 585, -390, 559, -420, 576, -406, 602], + [62.8, 8.5, -1034, -920, -1053, -955, -1080, -940, -1061, -905], + [62.8, 3.7, -1478, -43, -1504, -90, -1537, -72, -1508, -20, -1475, -38], + [62.8, 8.2, 793, -534, 892, -589, 882, -608, 782, -553], + [62.9, 11, -525, 434, -539, 408, -560, 419, -545, 445], + [62.9, 7.6, 1474, 512, 1459, 486, 1453, 489, 1467, 515], + [63, 11, -493, 472, -508, 446, -526, 456, -512, 482], + [63.1, 4.6, 569, -1304, 543, -1290, 557, -1264, 583, -1278], + [63.1, 18.9, 473, 842, 462, 821, 453, 825, 465, 846], + [63.1, 14, -1092, 730, -1085, 743, -1058, 728, -1065, 715], + [ + 63.1, 11, -631, 760, -644, 737, -651, 741, -653, 739, -662, 744, -661, + 746, -663, 748, -665, 745, -685, 756, -671, 782 + ], + [63.2, 18, 474, 1029, 486, 1023, 471, 996, 458, 1003, 473, 1030], + [ + 63.2, 10.1, -105, -927, -89, -936, -105, -965, -132, -951, -118, -926, + -107, -932 + ], + [ + 63.2, 14.6, -10, 1241, -25, 1215, -29, 1217, -44, 1190, -57, 1198, -42, + 1224, -76, 1243, -91, 1216, -97, 1220, -68, 1273 + ], + [ + 63.2, 18.9, 534, 1028, 521, 1004, 506, 1012, 507, 1015, 504, 1016, 518, + 1040, 536, 1030 + ], + [63.3, 11.3, -573, 784, -588, 758, -609, 769, -595, 796], + [63.3, 10.7, -529, 492, -512, 482, -526, 456, -551, 469, -536, 496], + [63.4, 13.1, -143, -330, -156, -354, -169, -346, -156, -323], + [ + 63.4, 17.7, 390, 1018, 376, 993, 350, 1008, 351, 1011, 346, 1014, 349, + 1019, 352, 1017, 353, 1021, 351, 1022, 359, 1037, 384, 1024, 383, 1022 + ], + [63.4, 21.6, 570, 365, 554, 336, 539, 345, 554, 374], + [63.4, 6.1, -1261, -776, -1287, -826, -1319, -808, -1292, -759], + [ + 63.4, 4.9, -1356, -169, -1328, -119, -1295, -137, -1324, -189, -1357, -171 + ], + [ + 63.4, 11, -419, -533, -428, -549, -430, -550, -433, -554, -444, -548, + -432, -526 + ], + [63.4, 8.2, 788, -660, 887, -715, 877, -734, 777, -679], + [ + 63.5, 8.2, -1034, -1185, -1050, -1215, -1048, -1216, -1061, -1241, -1088, + -1226, -1073, -1199, -1089, -1191, -1074, -1163 + ], + [63.5, 14, -123, -15, -137, -41, -148, -35, -134, -9], + [63.5, 11.3, -504, -186, -506, -188, -519, -181, -511, -166, -497, -173], + [63.6, 15.2, 1099, 56, 1106, 69, 1126, 58, 1119, 45], + [ + 63.6, 13.1, -341, 1110, -345, 1103, -347, 1104, -348, 1101, -346, 1100, + -352, 1089, -386, 1108, -374, 1129 + ], + [ + 63.6, 8.5, -1065, 175, -1056, 170, -1060, 161, -1059, 161, -1060, 159, + -1051, 154, -1057, 141, -1070, 148, -1071, 146, -1072, 147, -1077, 136, + -1087, 142, -1082, 152, -1083, 153, -1082, 155, -1092, 160, -1085, 172, + -1072, 165 + ], + [63.6, 11.9, -399, 688, -414, 662, -428, 670, -414, 696], + [ + 63.7, 11.3, -624, -1411, -640, -1440, -638, -1441, -653, -1468, -693, + -1446, -662, -1391 + ], + [ + 63.7, 19.5, 897, 1353, 900, 1351, 895, 1343, 899, 1341, 898, 1338, 865, + 1357, 871, 1367 + ], + [ + 63.9, 13.7, 467, -258, 419, -231, 436, -201, 485, -229, 482, -235, 483, + -235, 469, -260 + ], + [ + 63.9, 11.9, -541, -1110, -566, -1096, -564, -1093, -569, -1089, -563, + -1078, -532, -1094 + ], + [ + 63.9, 18.9, 442, 863, 429, 839, 402, 853, 416, 877, 426, 872, 424, 868, + 429, 865, 431, 869 + ], + [ + 64, 7.9, 250, -1033, 263, -1041, 257, -1052, 266, -1057, 261, -1066, 238, + -1053 + ], + [64, 9.1, -717, -54, -691, -69, -701, -87, -727, -72], + [ + 64, 7.3, 738, -298, 777, -319, 762, -346, 723, -324, 722, -318, 725, -313, + 729, -315 + ], + [64, 7.6, 135, -1032, 155, -1042, 141, -1068, 121, -1057], + [ + 64, 8.5, -754, -57, -746, -43, -739, -47, -738, -45, -731, -49, -730, -47, + -717, -54, -727, -72 + ], + [64, 5.5, 323, -1135, 340, -1144, 328, -1166, 311, -1157], + [ + 64, 11.3, 400, -687, 396, -694, 367, -678, 375, -665, 390, -673, 386, -679 + ], + [ + 64, 11, -204, -1141, -216, -1162, -242, -1149, -237, -1139, -227, -1144, + -220, -1132 + ], + [ + 64.2, 14, -144, 31, -158, 5, -150, 0, -164, -26, -195, -9, -196, -6, -193, + 20, -167, 13, -164, 18, -168, 20, -163, 29, -167, 31, -162, 40 + ], + [ + 64.2, 8.5, 140, -930, 134, -941, 130, -938, 125, -947, 129, -948, 110, + -982, 97, -975, 126, -922 + ], + [64.2, 18, 32, 356, 19, 334, -8, 349, 4, 372], + [64.2, 17.1, 275, -76, 249, -62, 256, -49, 278, -61, 277, -63, 281, -65], + [ + 64.3, 8.8, -1006, 45, -1007, 42, -1010, 44, -1015, 35, -1015, 33, -1005, + 27, -1012, 15, -1025, 22, -1031, 13, -1041, 18, -1036, 26, -1038, 26, + -1036, 28, -1046, 34, -1039, 46, -1027, 39, -1020, 53 + ], + [64.3, 11.3, -487, 818, -498, 798, -504, 801, -492, 821], + [ + 64.3, 13.1, 1164, 937, 1169, 949, 1171, 948, 1172, 950, 1254, 904, 1240, + 878, 1190, 906, 1171, 911, 1173, 915, 1154, 925, 1158, 934, 1163, 932 + ], + [64.5, 18.9, 487, 837, 474, 814, 462, 821, 475, 844], + [ + 64.5, 9.8, -765, -1050, -779, -1075, -809, -1058, -816, -1069, -833, + -1059, -813, -1024 + ], + [64.6, 17.7, 243, -24, 228, -50, 202, -35, 216, -9], + [64.6, 6.1, -1233, -27, -1248, -53, -1275, -38, -1260, -12], + [ + 64.6, 23.2, 534, 200, 519, 172, 508, 178, 512, 185, 507, 188, 510, 195, + 493, 204, 494, 208, 491, 210, 498, 223, 526, 207, 528, 209, 534, 206 + ], + [64.6, 11.3, -414, 696, -428, 670, -455, 685, -441, 711], + [64.6, 7.3, 536, -371, 525, -390, 512, -384, 523, -364], + [ + 64.6, 6.7, 1359, 634, 1379, 623, 1363, 594, 1338, 608, 1337, 610, 1342, + 619, 1345, 618, 1348, 623, 1351, 622, 1352, 623, 1346, 627, 1351, 635, + 1357, 631 + ], + [64.7, 8.5, -1169, -1152, -1180, -1175, -1203, -1163, -1190, -1140], + [ + 64.7, 21.6, 378, -22, 384, -12, 375, -6, 388, 17, 396, 13, 397, 14, 423, + -1, 403, -36 + ], + [64.7, 9.8, 287, -856, 304, -866, 289, -894, 267, -882, 282, -855], + [ + 64.8, 18, 584, 698, 592, 693, 578, 668, 556, 680, 565, 696, 570, 694, 575, + 703 + ], + [64.8, 18.9, 480, 789, 465, 763, 445, 774, 460, 800], + [64.8, 13.4, -361, 753, -351, 747, -364, 724, -384, 735, -371, 758], + [64.8, 12.5, 129, -226, 106, -213, 113, -200, 137, -213], + [64.9, 21.6, 216, 112, 210, 102, 177, 119, 184, 132, 217, 114], + [64.9, 6.7, 788, -395, 774, -421, 679, -368, 693, -342], + [64.9, 11, 831, 20, 841, 37, 868, 22, 858, 5], + [ + 64.9, 11.3, -610, -282, -599, -262, -567, -279, -575, -294, -596, -282, + -599, -288 + ], + [65, 24.4, 357, 181, 338, 191, 341, 197, 335, 201, 346, 220, 371, 206], + [ + 65, 8.5, -882, 74, -889, 61, -887, 60, -888, 59, -880, 55, -885, 45, -893, + 50, -894, 49, -896, 50, -901, 40, -913, 47, -907, 59, -909, 60, -908, 61, + -918, 67, -913, 77, -903, 71, -902, 72, -900, 71, -895, 81 + ], + [65, 20.1, 132, 380, 123, 365, 106, 374, 119, 398, 137, 389], + [65.1, 12.2, 129, -226, 107, -265, 78, -249, 87, -232, 93, -236, 106, -213], + [65.1, 18.6, 235, 1489, 192, 1513, 219, 1567, 264, 1542], + [ + 65.1, 14.3, 1194, 446, 1181, 423, 1155, 438, 1167, 461, 1177, 455, 1182, + 464, 1192, 459, 1187, 450 + ], + [ + 65.2, 13.7, 1112, 406, 1122, 400, 1108, 373, 1047, 406, 1076, 460, 1117, + 437, 1103, 411 + ], + [65.2, 11.6, 85, -406, 81, -412, 87, -415, 79, -429, 53, -414, 64, -394], + [65.2, 12.5, -381, 677, -377, 675, -391, 649, -414, 662, -399, 688], + [ + 65.2, 13.1, -104, -294, -106, -298, -97, -302, -101, -308, -98, -310, + -102, -317, -104, -315, -108, -321, -136, -306, -137, -309, -146, -304, + -132, -278 + ], + [65.3, 10.7, -464, 579, -477, 556, -502, 569, -489, 593], + [ + 65.3, 13.1, -41, -115, -54, -139, -56, -137, -58, -140, -68, -134, -54, + -108 + ], + [ + 65.4, 10.7, 2, -709, 28, -724, 25, -729, 5, -718, -6, -739, -33, -724, + -21, -703, -7, -710, 0, -708 + ], + [65.4, 19.8, 124, 523, 111, 499, 92, 509, 105, 533], + [65.5, 11.9, -484, 378, -493, 383, -479, 408, -452, 394, -467, 368], + [ + 65.5, 6.4, 251, -1538, 244, -1551, 250, -1554, 239, -1574, 230, -1569, + 228, -1572, 205, -1560, 207, -1556, 206, -1556, 225, -1523, 226, -1523, + 228, -1520, 250, -1532, 248, -1536 + ], + [ + 65.5, 11.3, -500, 1107, -511, 1087, -532, 1098, -518, 1125, -500, 1115, + -503, 1109 + ], + [65.6, 12.5, -300, -970, -313, -994, -325, -987, -319, -958, -299, -969], + [ + 65.7, 12.2, -339, -665, -311, -680, -314, -701, -334, -737, -397, -702, + -382, -673, -390, -669, -391, -670, -396, -668, -382, -642 + ], + [65.8, 15.2, 1165, 411, 1150, 384, 1116, 403, 1131, 430], + [65.8, 16.2, 1187, 166, 1180, 152, 1159, 164, 1188, 217, 1209, 205], + [65.8, 15.8, 165, 1019, 144, 1030, 159, 1057, 180, 1046], + [65.8, 7, 137, -1121, 156, -1131, 147, -1149, 127, -1138], + [ + 65.9, 11, -499, 419, -513, 393, -537, 407, -535, 409, -538, 411, -525, 434 + ], + [65.9, 11, 70, -445, 61, -461, 55, -458, 50, -468, 29, -456, 43, -430], + [ + 65.9, 9.1, -17, -1036, -20, -1042, -25, -1039, -32, -1056, -41, -1051, + -42, -1053, -39, -1056, -41, -1059, -44, -1058, -46, -1060, -39, -1064, + -46, -1077, -43, -1078, -47, -1086, -69, -1073, -65, -1065, -62, -1067, + -55, -1055, -47, -1059, -46, -1057, -49, -1054, -47, -1051, -44, -1052, + -43, -1050, -55, -1043, -51, -1036, -47, -1039, -45, -1035, -43, -1037, + -41, -1034, -44, -1033, -42, -1030, -46, -1028, -43, -1021 + ], + [ + 65.9, 9.8, 252, -908, 225, -956, 152, -915, 155, -909, 144, -903, 147, + -899, 142, -896, 163, -858 + ], + [66, 9.1, -742, 59, -728, 51, -742, 25, -764, 37, -750, 63], + [66, 12.8, -339, 190, -312, 176, -325, 152, -358, 171, -345, 194], + [ + 66, 4.9, 366, -1622, 382, -1631, 371, -1650, 349, -1638, 350, -1636, 338, + -1629, 348, -1613 + ], + [ + 66.1, 8.2, 140, -964, 153, -971, 150, -977, 157, -981, 153, -988, 147, + -985, 144, -989, 148, -991, 147, -993, 150, -994, 146, -1001, 125, -990, + 129, -982, 135, -986, 139, -981, 132, -977 + ], + [ + 66.1, 9.1, -721, 160, -745, 116, -758, 123, -748, 141, -742, 138, -728, + 164 + ], + [66.1, 12.8, -346, 603, -360, 577, -385, 591, -370, 617], + [ + 66.1, 10.7, -518, -670, -527, -687, -547, -676, -552, -685, -560, -680, + -574, -707, -622, -680, -593, -628 + ], + [66.1, 13.4, -87, -90, -101, -113, -120, -102, -107, -79], + [ + 66.1, 21.6, 781, 1076, 755, 1029, 753, 1030, 749, 1023, 698, 1052, 697, + 1055, 724, 1104, 728, 1105 + ], + [66.1, 11.3, -485, 468, -464, 456, -478, 429, -508, 446, -493, 472], + [66.2, 19.2, 79, 413, 69, 395, 55, 403, 68, 426, 80, 419, 77, 414], + [66.2, 19.5, 105, 533, 92, 509, 77, 517, 90, 541], + [66.2, 18.9, 517, 857, 504, 832, 477, 847, 491, 872], + [ + 66.3, 18.9, 333, 863, 324, 847, 322, 848, 319, 844, 311, 848, 326, 875, + 336, 869 + ], + [ + 66.3, 10.4, 151, -668, 136, -694, 120, -685, 124, -677, 113, -672, 116, + -667, 100, -658, 108, -644 + ], + [66.3, 13.4, -345, -305, -358, -328, -384, -314, -370, -289, -344, -304], + [66.3, 13.1, 555, -207, 567, -214, 558, -229, 523, -210, 532, -194], + [66.4, 20.4, 159, 376, 146, 352, 135, 359, 148, 382], + [66.4, 12.5, 182, -448, 161, -437, 158, -428, 169, -409, 196, -424], + [ + 66.4, 19.2, 435, 814, 428, 802, 427, 803, 413, 778, 419, 775, 410, 759, + 384, 773, 392, 788, 398, 785, 419, 823 + ], + [66.6, 14, 20, -100, -7, -85, 10, -54, 37, -69], + [66.8, 11.6, -458, -8, -444, -16, -458, -42, -486, -27, -471, -1], + [66.8, 4, -1583, -457, -1541, -479, -1548, -492, -1590, -469], + [ + 66.8, 10.4, -550, 77, -579, 24, -605, 39, -592, 62, -587, 59, -584, 65, + -589, 68, -583, 79, -585, 80, -578, 92 + ], + [ + 66.8, 20.1, 688, 944, 674, 919, 667, 923, 672, 931, 639, 949, 649, 968, + 689, 946 + ], + [66.8, 19.8, 61, 315, 69, 330, 87, 320, 84, 315, 82, 316, 77, 307], + [ + 66.8, 9.8, -492, -195, -482, -177, -480, -177, -468, -184, -482, -208, + -485, -206, -482, -201, -489, -197, -491, -203, -495, -201 + ], + [ + 67, 9.8, -608, 19, -617, 3, -597, -9, -603, -18, -629, -4, -626, 0, -632, + 4, -620, 26 + ], + [67, 11.9, -425, 468, -439, 442, -485, 468, -471, 494], + [ + 67, 17.1, -15, 742, -29, 717, -33, 720, -24, 736, -33, 741, -27, 750, -56, + 766, -49, 796, 0, 769 + ], + [67, 10.7, -699, -1395, -728, -1379, -717, -1360, -688, -1376], + [ + 67, 19.2, 496, 1142, 560, 1107, 531, 1054, 449, 1100, 473, 1142, 492, + 1132, 494, 1135, 493, 1140 + ], + [67.1, 10.4, 990, -25, 999, -9, 1009, -15, 1019, 1, 1033, -6, 1014, -39], + [67.1, 3.7, -1617, -519, -1576, -542, -1582, -554, -1624, -531], + [67.1, 15.8, 1350, 306, 1338, 284, 1276, 318, 1289, 342, 1351, 308], + [67.1, 7.3, 1454, 651, 1450, 645, 1435, 653, 1440, 659], + [67.5, 15.8, 1334, 276, 1322, 255, 1309, 262, 1321, 283], + [67.7, 14.3, -304, -264, -296, -251, -285, -257, -293, -271], + [ + 67.7, 15.2, -118, 354, -143, 368, -139, 397, -137, 398, -93, 374, -98, + 364, -107, 369, -108, 366, -110, 367 + ], + [67.7, 11.3, -546, 803, -561, 777, -594, 795, -580, 822], + [ + 67.7, 10.7, -121, -1107, -125, -1113, -123, -1114, -130, -1126, -153, + -1114, -143, -1095 + ], + [ + 67.9, 14.6, -1012, 662, -998, 654, -1004, 644, -1001, 643, -1007, 632, + -1038, 649, -1033, 657, -1031, 656, -1024, 668 + ], + [ + 68, 16.5, -68, 240, -55, 264, -28, 249, -43, 223, -49, 226, -48, 229, -50, + 230, -52, 228, -60, 232, -58, 235, -60, 236, -62, 233, -69, 237 + ], + [ + 68, 12.2, 150, -239, 151, -240, 152, -239, 175, -252, 168, -265, 143, -251 + ], + [ + 68, 12.8, -53, -232, -80, -218, -76, -211, -70, -215, -63, -203, -43, -214 + ], + [ + 68.1, 13.4, -295, -542, -316, -530, -311, -522, -318, -518, -324, -529, + -335, -523, -321, -497, -291, -514 + ], + [ + 68.2, 15.2, 1162, 127, 1143, 92, 1140, 93, 1135, 84, 1137, 82, 1133, 75, + 1115, 85, 1144, 137 + ], + [ + 68.3, 21, 727, 997, 720, 985, 699, 996, 706, 1008, 679, 1023, 687, 1037, + 734, 1011 + ], + [ + 68.3, 12.8, -288, -115, -289, -118, -266, -125, -265, -122, -237, -131, + -239, -142, -312, -120, -306, -110 + ], + [68.3, 18.9, 243, -24, 216, -9, 230, 16, 257, 2], + [ + 68.4, 11, 917, -15, 934, -23, 928, -35, 920, -30, 915, -39, 900, -30, 911, + -10, 917, -14 + ], + [68.5, 13.4, -272, 342, -283, 322, -301, 331, -289, 352], + [68.5, 12.8, 1136, 293, 1140, 293, 1149, 286, 1142, 274, 1129, 281], + [ + 68.5, 12.8, -138, -61, -152, -87, -154, -85, -159, -94, -153, -97, -163, + -116, -176, -109, -156, -73, -158, -72, -149, -55 + ], + [ + 68.5, 7, 735, -923, 759, -936, 752, -949, 744, -945, 744, -946, 751, -950, + 748, -956, 737, -950, 736, -952, 726, -947, 729, -941, 713, -932, 717, + -925, 720, -926, 728, -911, 738, -917 + ], + [68.6, 11, -633, 851, -645, 830, -678, 848, -666, 869], + [ + 68.6, 24.1, 424, 176, 412, 154, 409, 155, 408, 153, 377, 170, 392, 196, + 422, 179, 422, 178 + ], + [68.6, 15.5, 189, 1281, 187, 1278, 161, 1293, 175, 1320, 202, 1305], + [68.7, 23.8, 401, 335, 433, 317, 418, 291, 380, 312, 395, 338], + [68.7, 12.5, -327, 43, -356, -10, -374, 0, -345, 53], + [ + 68.8, 12.5, 182, -448, 166, -477, 145, -465, 154, -448, 157, -450, 162, + -441, 165, -442, 166, -439 + ], + [68.9, 22.9, 481, 103, 476, 95, 463, 102, 468, 111], + [68.9, 23.2, 432, 440, 420, 417, 403, 426, 415, 449], + [ + 68.9, 8.5, 1466, 842, 1492, 828, 1478, 802, 1452, 816, 1453, 818, 1449, + 821, 1449, 822, 1448, 822, 1446, 820, 1439, 824, 1453, 850 + ], + [69, 9.1, -707, 123, -719, 102, -738, 112, -726, 134], + [ + 69.1, 19.2, 909, 1358, 906, 1353, 899, 1357, 897, 1353, 871, 1367, 879, + 1383, 911, 1366, 907, 1359 + ], + [ + 69.1, 6.7, 666, -1051, 659, -1063, 653, -1060, 652, -1062, 647, -1059, + 648, -1057, 646, -1058, 644, -1057, 645, -1055, 644, -1054, 642, -1057, + 638, -1054, 638, -1052, 633, -1049, 640, -1036, 655, -1042 + ], + [69.2, 20.4, 101, 349, 118, 340, 110, 324, 92, 334], + [69.2, 23.8, 425, 409, 411, 385, 397, 392, 411, 417], + [ + 69.2, 2.1, 968, -524, 994, -538, 979, -566, 977, -567, 945, -550, 959, + -524, 966, -528 + ], + [ + 69.4, 14.9, -251, 695, -255, 687, -248, 683, -258, 665, -293, 684, -280, + 708, -275, 705, -274, 708 + ], + [ + 69.4, 8.2, -1215, -1094, -1204, -1101, -1220, -1130, -1231, -1124, -1229, + -1120, -1232, -1118, -1234, -1120, -1245, -1114, -1230, -1086 + ], + [ + 69.4, 9.4, 1373, 499, 1351, 510, 1381, 563, 1404, 550, 1401, 545, 1404, + 543, 1378, 496 + ], + [69.5, 11.6, -399, 722, -414, 696, -441, 711, -427, 737], + [ + 69.7, 10.4, -661, -319, -671, -337, -677, -333, -679, -337, -700, -326, + -688, -304 + ], + [69.8, 18.9, 59, 342, 46, 319, 30, 328, 43, 350], + [ + 69.8, 15.8, 1199, 393, 1184, 366, 1176, 370, 1161, 344, 1153, 348, 1168, + 375, 1150, 384, 1165, 411 + ], + [69.8, 18.3, 5, 198, 17, 220, 34, 211, 21, 187, 4, 197], + [69.9, 20.4, 700, 1357, 685, 1331, 670, 1339, 684, 1366], + [ + 69.9, 7.6, -1095, -904, -1106, -925, -1125, -914, -1120, -904, -1116, + -905, -1111, -896 + ], + [69.9, 11, -640, 650, -633, 663, -606, 648, -614, 635], + [ + 70, 17.4, 388, 1077, 397, 1072, 396, 1069, 398, 1068, 385, 1044, 368, + 1053, 381, 1077, 387, 1074 + ], + [70.1, 22.3, 499, 12, 484, 21, 499, 47, 526, 32, 511, 6], + [ + 70.1, 12.8, -290, 394, -302, 373, -312, 379, -315, 373, -342, 388, -327, + 414 + ], + [ + 70.1, 17.1, 114, 957, 127, 950, 112, 923, 106, 927, 109, 932, 104, 934, + 102, 929, 96, 932, 111, 959 + ], + [70.1, 13.4, -381, 795, -348, 776, -360, 755, -393, 774], + [ + 70.1, 18.9, 926, 1405, 932, 1401, 921, 1382, 889, 1399, 896, 1413, 922, + 1398 + ], + [70.1, 4.6, 557, -1264, 543, -1290, 498, -1265, 513, -1239], + [70.1, 21.6, 202, 442, 207, 439, 194, 415, 178, 424, 191, 448], + [70.1, 9.4, -652, -1, -639, -8, -649, -26, -662, -19], + [ + 70.2, 15.2, 1228, 414, 1221, 401, 1181, 423, 1194, 446, 1231, 426, 1228, + 420, 1231, 419 + ], + [ + 70.4, 7.3, 386, -1101, 410, -1115, 397, -1139, 353, -1115, 361, -1101, + 380, -1112 + ], + [70.4, 11.3, -671, 687, -652, 676, -661, 660, -680, 670], + [ + 70.4, 5.8, -1116, -378, -1139, -365, -1133, -354, -1136, -353, -1126, + -333, -1099, -348 + ], + [ + 70.4, 8.8, 52, -912, 36, -941, 31, -938, 32, -935, 29, -933, 26, -935, 21, + -932, 37, -904 + ], + [ + 70.4, 12.2, 144, -513, 141, -520, 124, -511, 128, -504, 107, -493, 119, + -471, 156, -492 + ], + [ + 70.4, 13.1, -156, -354, -165, -370, -161, -372, -159, -368, -136, -380, + -144, -395, -183, -373, -169, -346 + ], + [ + 70.5, 12.8, -237, -488, -234, -489, -240, -500, -245, -497, -254, -513, + -268, -506, -263, -473 + ], + [70.6, 10.4, -584, -173, -598, -199, -618, -188, -603, -162], + [70.7, 11.6, 64, -565, 53, -586, -17, -548, 7, -505, 76, -545], + [ + 70.7, 12.2, 41, -249, 25, -279, 19, -276, 23, -268, 9, -260, 3, -270, 14, + -276, 2, -297, -42, -273, -12, -220 + ], + [ + 70.8, 10.7, 50, -468, 62, -474, 59, -480, 66, -484, 55, -504, 15, -482, + 29, -456 + ], + [ + 70.9, 9.8, -679, -31, -692, -54, -725, -36, -724, -33, -721, -34, -719, + -31, -715, -33, -706, -16 + ], + [70.9, 12.2, -228, -314, -212, -323, -219, -336, -242, -323, -239, -308], + [70.9, 15.2, -210, 990, -225, 963, -263, 984, -248, 1011], + [ + 71, 13.7, 783, 114, 781, 111, 776, 114, 771, 105, 776, 103, 773, 96, 754, + 106, 758, 113, 763, 110, 768, 119, 763, 121, 766, 129, 785, 118 + ], + [ + 71, 12.8, -446, -1541, -469, -1536, -468, -1532, -465, -1534, -457, -1520, + -461, -1518, -455, -1506, -442, -1513 + ], + [ + 71, 18.6, 1248, 274, 1241, 261, 1246, 258, 1241, 249, 1239, 250, 1237, + 246, 1212, 260, 1227, 286 + ], + [ + 71, 10.7, -81, -808, -33, -834, -62, -886, -88, -872, -85, -868, -113, + -853, -147, -834, -149, -838, -175, -824, -156, -791, -133, -804, -124, + -784 + ], + [ + 71.2, 9.1, 134, -855, 130, -863, 131, -864, 130, -866, 129, -866, 124, + -877, 121, -880, 118, -881, 115, -880, 116, -878, 113, -877, 112, -878, + 108, -876, 108, -874, 102, -872, 109, -858, 113, -860, 119, -850, 118, + -850, 119, -847 + ], + [71.3, 12.2, 14, -303, 3, -297, 11, -282, 22, -288], + [71.3, 17.7, 27, 306, 15, 284, -14, 299, -1, 322], + [ + 71.3, 15.5, 1142, 1293, 1117, 1308, 1118, 1310, 1113, 1313, 1127, 1337, + 1157, 1320 + ], + [71.4, 12.5, -1089, 890, -1049, 868, -1064, 842, -1111, 868, -1096, 894], + [71.4, 11.9, 207, -476, 223, -485, 213, -503, 194, -492, 204, -475], + [71.5, 18.6, 66, 1445, 65, 1444, 49, 1452, 58, 1469, 74, 1460], + [ + 71.6, 7.6, 241, -1105, 226, -1097, 225, -1100, 215, -1095, 217, -1092, + 214, -1090, 221, -1078, 248, -1093 + ], + [ + 71.6, 8.8, 1446, 673, 1442, 675, 1457, 702, 1488, 685, 1477, 666, 1464, + 673, 1460, 665 + ], + [71.6, 18.9, 638, -65, 627, -85, 606, -73, 617, -53], + [ + 71.6, 15.5, 1168, 117, 1156, 96, 1169, 89, 1155, 63, 1133, 75, 1137, 82, + 1135, 84, 1140, 93, 1143, 92, 1162, 127, 1170, 122 + ], + [71.8, 4.3, -1653, -584, -1612, -606, -1618, -619, -1660, -596], + [71.9, 11.6, -620, 844, -634, 817, -647, 825, -633, 851], + [71.9, 6.7, 307, -1091, 294, -1084, 307, -1060, 320, -1067], + [ + 71.9, 17.7, 451, -147, 445, -158, 448, -159, 443, -169, 420, -157, 426, + -147, 429, -148, 435, -138 + ], + [72.2, 18.9, 491, 872, 480, 853, 463, 862, 473, 881], + [ + 72.2, 5.2, -164, -1704, -176, -1722, -192, -1713, -189, -1707, -191, + -1705, -184, -1692 + ], + [ + 72.2, 17.7, 306, 1428, 301, 1420, 291, 1425, 287, 1419, 297, 1413, 291, + 1402, 287, 1405, 288, 1407, 266, 1419, 271, 1429, 277, 1426, 280, 1432, + 268, 1438, 265, 1434, 267, 1433, 257, 1417, 263, 1414, 250, 1390, 223, + 1405, 253, 1458 + ], + [ + 72.3, 21.3, 386, -27, 403, -36, 394, -53, 374, -42, 375, -40, 372, -39, + 377, -30, 379, -31, 381, -28, 382, -29, 384, -27 + ], + [72.4, 14, 1238, 1274, 1224, 1249, 1209, 1256, 1224, 1283, 1238, 1275], + [72.5, 11.6, -115, -462, -123, -476, -146, -462, -139, -448], + [72.6, 12.2, -943, 294, -958, 268, -1017, 301, -1002, 327], + [ + 72.7, 10.7, 531, -902, 523, -918, 519, -916, 511, -931, 495, -922, 500, + -914, 502, -914, 513, -894, 512, -893, 514, -891, 501, -884, 509, -870, + 536, -885, 528, -900 + ], + [ + 72.7, 11.9, -536, -1262, -542, -1274, -544, -1272, -547, -1277, -545, + -1279, -550, -1289, -593, -1267, -578, -1238, -535, -1262 + ], + [72.8, 11.3, 822, 4, 831, 20, 857, 5, 849, -11], + [72.8, 11.6, -726, 635, -693, 617, -708, 591, -741, 609], + [72.8, 10.4, -872, -347, -844, -297, -778, -333, -807, -385, -873, -349], + [73.1, 14, -220, 408, -205, 400, -219, 375, -235, 384, -221, 409], + [73.1, 11.6, 187, -546, 175, -566, 159, -557, 171, -537], + [73.2, 11.9, 1098, 675, 1107, 669, 1097, 652, 1088, 656], + [73.2, 19.5, 82, 418, 89, 415, 90, 417, 100, 412, 89, 393, 73, 402], + [ + 73.2, 10.4, -536, 1135, -523, 1128, -526, 1121, -522, 1117, -530, 1102, + -537, 1104, -539, 1102, -564, 1116, -549, 1142 + ], + [73.2, 24.4, 370, 297, 356, 271, 343, 278, 357, 304], + [73.3, 14.9, 182, -60, 153, -112, 132, -100, 162, -49], + [ + 73.4, 16.8, 274, -111, 260, -137, 255, -134, 256, -133, 253, -131, 238, + -159, 231, -155, 253, -116, 227, -102, 235, -88 + ], + [73.4, 4.9, -978, 1390, -968, 1407, -941, 1392, -951, 1375], + [ + 73.5, 8.2, 235, -991, 209, -1036, 188, -1024, 196, -1009, 204, -1013, 213, + -997, 205, -992, 212, -979 + ], + [73.5, 10.1, 472, -536, 484, -543, 475, -558, 461, -548, 468, -534], + [73.5, 20.1, 489, 581, 487, 577, 491, 575, 473, 543, 462, 549, 482, 585], + [73.5, 11.9, -541, -327, -548, -340, -563, -332, -556, -319], + [ + 73.7, 20.7, 558, 1220, 587, 1273, 637, 1245, 629, 1230, 624, 1233, 612, + 1210, 616, 1207, 608, 1192 + ], + [73.8, 12.5, -366, 704, -381, 677, -414, 696, -399, 722], + [ + 73.8, 9.8, -583, 644, -613, 593, -633, 604, -618, 630, -608, 625, -606, + 629, -615, 633, -602, 655 + ], + [ + 73.8, 17.1, 1173, 316, 1159, 289, 1164, 287, 1149, 260, 1139, 266, 1167, + 319 + ], + [74.1, 18.3, 466, 1033, 452, 1007, 434, 1017, 448, 1042], + [ + 74.2, 10.4, 676, -807, 678, -810, 696, -818, 697, -824, 692, -833, 686, + -835, 667, -824, 666, -819, 671, -810, 670, -807 + ], + [ + 74.2, 12.5, -212, -517, -220, -531, -253, -513, -246, -500, -228, -510, + -227, -508 + ], + [74.3, 18.6, 521, 1004, 540, 993, 526, 966, 500, 980, 515, 1007], + [ + 74.4, 9.8, 616, -877, 619, -879, 621, -885, 611, -903, 605, -905, 595, + -900, 594, -894, 604, -878, 603, -877, 604, -875, 610, -874 + ], + [74.6, 18.3, 652, -39, 646, -50, 620, -36, 627, -24], + [74.6, 13.7, 943, 499, 929, 472, 908, 484, 923, 510], + [ + 74.7, 20.7, 695, 1485, 736, 1463, 724, 1439, 704, 1450, 688, 1420, 639, + 1447, 657, 1480, 650, 1483, 653, 1488, 659, 1484, 668, 1500 + ], + [ + 74.8, 12.2, 240, -309, 255, -317, 243, -340, 215, -325, 226, -305, 238, + -312 + ], + [ + 74.9, 12.2, -424, -41, -432, -56, -458, -42, -429, 10, -424, 7, -425, 6, + -403, -6, -403, -5, -397, -8, -413, -38, -420, -34 + ], + [ + 75, 18, -79, 1572, -64, 1598, -49, 1590, -46, 1597, -47, 1597, -38, 1614, + -37, 1613, -34, 1617, -14, 1605, -44, 1552 + ], + [75, 11, -629, 780, -617, 801, -611, 798, -622, 777], + [75, 18.6, 49, 529, 55, 540, 79, 527, 73, 516], + [ + 75, 5.8, 1031, -649, 1034, -651, 1037, -646, 1077, -668, 1059, -702, 1032, + -687, 1026, -697, 1009, -688, 1015, -678, 968, -652, 984, -623 + ], + [ + 75, 5.8, 1007, -748, 1004, -753, 990, -746, 976, -772, 956, -761, 981, + -716, 1000, -727, 993, -741 + ], + [75.1, 14, -792, 582, -807, 556, -859, 584, -845, 611], + [ + 75.2, 8.8, -1063, 360, -1078, 333, -1086, 348, -1154, 380, -1141, 403, + -1109, 386, -1108, 389, -1103, 386, -1105, 383 + ], + [ + 75.2, 13.7, -341, 1784, -353, 1763, -354, 1763, -358, 1756, -357, 1755, + -369, 1733, -409, 1754, -397, 1776, -387, 1771, -383, 1776, -379, 1774, + -373, 1784, -379, 1787, -371, 1802, -341, 1786 + ], + [ + 75.3, 12.5, -285, -1807, -299, -1834, -319, -1824, -309, -1806, -311, + -1805, -310, -1803, -322, -1797, -314, -1782, -301, -1789, -303, -1792, + -282, -1803 + ], + [75.3, 11.3, -660, 598, -674, 574, -696, 586, -682, 611], + [ + 75.4, 11.6, 1237, 935, 1252, 961, 1273, 950, 1287, 977, 1319, 959, 1289, + 906 + ], + [ + 75.6, 12.2, -267, -1256, -266, -1256, -287, -1294, -322, -1275, -311, + -1255, -296, -1264, -286, -1245 + ], + [75.6, 9.8, -470, 638, -439, 621, -454, 594, -494, 616, -479, 643], + [ + 75.6, 1.8, -1824, -244, -1835, -264, -1860, -250, -1864, -246, -1862, -223 + ], + [75.6, 12.2, 219, -527, 210, -543, 175, -523, 184, -507], + [75.6, 18, 586, 730, 572, 704, 559, 712, 573, 738], + [75.7, 17.7, 758, 716, 733, 670, 674, 702, 704, 756, 762, 724], + [75.7, 12.8, 1010, 552, 1036, 538, 1022, 512, 995, 527], + [ + 75.9, 11.3, -665, 558, -676, 539, -689, 546, -682, 560, -675, 556, -672, + 561 + ], + [ + 75.9, 18, 357, 1400, 327, 1347, 250, 1390, 263, 1414, 290, 1400, 306, 1428 + ], + [75.9, 11.6, -443, -72, -455, -95, -477, -83, -464, -60], + [ + 76, 21.3, 177, 455, 164, 431, 159, 434, 159, 435, 134, 448, 146, 471, 153, + 468, 150, 463, 162, 457, 164, 461 + ], + [ + 76, 12.2, 1054, 291, 1036, 260, 1054, 251, 1052, 248, 1048, 250, 1038, + 231, 991, 257, 1001, 274, 1008, 271, 1024, 301, 1018, 305, 1021, 310 + ], + [ + 76.1, 5.2, 430, -1193, 431, -1191, 436, -1194, 432, -1200, 434, -1201, + 422, -1223, 396, -1208, 411, -1183 + ], + [76.2, 12.2, -696, 659, -705, 644, -725, 655, -717, 670], + [76.2, 11.3, -695, 570, -680, 563, -689, 546, -704, 554], + [ + 76.2, 2.4, -1757, -335, -1747, -338, -1728, -349, -1728, -350, -1752, + -395, -1755, -397, -1769, -389, -1770, -387, -1765, -380, -1776, -382, + -1779, -381, -1783, -379, -1785, -369, -1789, -377, -1792, -377, -1835, + -353, -1836, -351, -1824, -328, -1786, -349, -1773, -324, -1762, -330 + ], + [ + 76.2, 2.4, -1759, -17, -1762, -22, -1776, -15, -1788, -38, -1801, -30, + -1797, -23, -1818, -12, -1792, 34, -1732, 1, -1746, -24 + ], + [ + 76.2, 7, 131, -1241, 146, -1214, 165, -1225, 156, -1243, 147, -1241, 143, + -1248 + ], + [ + 76.3, 12.2, 174, -145, 152, -184, 129, -171, 136, -158, 122, -151, 137, + -125 + ], + [ + 76.3, 21.3, 1347, 127, 1318, 76, 1303, 84, 1310, 96, 1317, 92, 1322, 100, + 1314, 104, 1322, 117, 1329, 113, 1334, 121, 1326, 125, 1333, 137, 1348, + 129 + ], + [76.4, 19.5, 83, 1641, 76, 1629, 63, 1636, 59, 1628, 40, 1638, 52, 1659], + [76.4, 19.8, 122, 434, 108, 408, 87, 419, 88, 421, 83, 424, 96, 448], + [ + 76.5, 10.4, -732, -1251, -743, -1271, -763, -1260, -771, -1258, -759, + -1236 + ], + [76.5, 23.5, 468, 270, 477, 286, 483, 282, 475, 267], + [ + 76.5, 12.8, -378, 799, -391, 776, -402, 782, -403, 780, -410, 783, -395, + 809 + ], + [ + 76.5, 16.2, -190, 538, -178, 558, -184, 562, -181, 567, -228, 593, -213, + 619, -137, 577, -144, 564, -139, 562, -145, 551, -140, 548, -146, 537, + -143, 536, -148, 517, -151, 517 + ], + [76.6, 15.2, -86, 229, -83, 228, -90, 215, -117, 229, -110, 242], + [ + 76.8, 83.2, 132, -1344, 147, -1315, 178, -1333, 177, -1335, 179, -1336, + 171, -1349, 177, -1351, 177, -1350, 189, -1356, 182, -1369, 167, -1360, + 166, -1363 + ], + [ + 77, 12.5, -344, -968, -372, -953, -375, -959, -387, -952, -374, -928, + -342, -946, -340, -949 + ], + [ + 77.1, 11, -620, 750, -608, 743, -606, 747, -564, 724, -579, 698, -619, + 720, -633, 694, -699, 730, -685, 756, -653, 739, -651, 741, -644, 737, + -631, 760, -618, 753 + ], + [ + 77.1, 11.3, -427, 737, -440, 714, -449, 719, -442, 732, -459, 741, -453, + 752 + ], + [77.2, 11.6, -213, -1531, -127, -1579, -158, -1635, -244, -1588], + [ + 77.3, 21.3, 194, 456, 205, 477, 219, 470, 209, 452, 208, 453, 203, 444, + 191, 451 + ], + [ + 77.4, 12.2, -918, 919, -932, 893, -945, 900, -959, 874, -997, 895, -968, + 947 + ], + [ + 77.4, 2.1, 1044, -795, 1045, -787, 1050, -786, 1061, -766, 1065, -768, + 1067, -765, 1065, -764, 1068, -758, 1074, -762, 1065, -828, 1042, -815 + ], + [77.7, 8.2, 23, -969, 63, -991, 49, -1017, 28, -1006, 14, -1032, -6, -1021], + [ + 77.7, 15.5, 106, 1257, 80, 1213, 70, 1218, 75, 1238, 87, 1267, 82, 1270, + 86, 1278, 110, 1265 + ], + [77.8, 10.4, 362, -338, 347, -364, 326, -352, 341, -326], + [77.8, 16.5, -175, 752, -201, 766, -191, 785, -164, 771], + [ + 77.8, 11.6, -582, -1183, -605, -1170, -602, -1164, -607, -1161, -609, + -1164, -626, -1154, -615, -1134, -569, -1160 + ], + [ + 78, 11.3, -505, -38, -516, -58, -518, -56, -519, -58, -528, -54, -531, + -57, -553, -45, -551, -43, -554, -41, -542, -18 + ], + [78, 20.4, 126, 369, 136, 387, 147, 381, 137, 363], + [78.1, 20.1, 615, 971, 607, 956, 581, 971, 583, 976, 577, 980, 582, 989], + [78.2, 10.7, -452, 714, -459, 701, -476, 710, -469, 724], + [ + 78.2, 17.7, 1300, 43, 1275, -3, 1259, 5, 1267, 18, 1275, 14, 1278, 20, + 1270, 25, 1277, 38, 1285, 33, 1289, 39, 1281, 44, 1288, 57, 1303, 49 + ], + [78.3, 17.7, -5, 683, 6, 677, -8, 652, -19, 657], + [78.3, 20.7, 479, 587, 447, 605, 456, 621, 485, 605, 482, 599, 485, 597], + [ + 78.4, 10.1, 181, -719, 206, -733, 192, -759, 161, -742, 169, -729, 171, + -730, 179, -717 + ], + [ + 78.4, 23.8, 480, 293, 476, 295, 472, 287, 476, 285, 473, 280, 446, 295, + 456, 313, 483, 298 + ], + [ + 78.5, 10.7, 881, 172, 872, 156, 851, 167, 852, 169, 847, 172, 864, 203, + 890, 188 + ], + [ + 78.6, 9.4, 493, -322, 487, -333, 485, -332, 484, -334, 481, -332, 474, + -345, 477, -347, 475, -351, 477, -352, 476, -354, 451, -340, 469, -308 + ], + [ + 78.6, 8.5, -1140, 581, -1137, 580, -1136, 583, -1122, 575, -1125, 570, + -1087, 549, -1101, 524, -1107, 527, -1150, 449, -1154, 451, -1162, 436, + -1232, 474, -1165, 595 + ], + [ + 78.6, 17.7, 350, 1008, 379, 992, 364, 967, 309, 995, 322, 1019, 346, 1006, + 348, 1009 + ], + [ + 78.6, 20.1, 361, 765, 349, 744, 347, 745, 344, 739, 368, 726, 353, 700, + 316, 721, 325, 738, 328, 736, 348, 772 + ], + [ + 78.6, 2.4, -1606, 179, -1617, 159, -1622, 162, -1626, 156, -1638, 163, + -1627, 183, -1626, 182, -1623, 189 + ], + [78.7, 16.2, -142, 711, -151, 695, -166, 704, -158, 719], + [78.7, 18.9, 839, 943, 832, 931, 809, 944, 820, 963, 843, 951], + [78.7, 23.8, 439, 329, 433, 317, 401, 335, 404, 340, 418, 332, 422, 339], + [ + 78.9, 12.2, -309, 583, -324, 557, -318, 554, -321, 547, -296, 533, -307, + 513, -380, 554, -368, 575, -346, 563, -341, 573, -352, 579, -340, 600 + ], + [ + 78.9, 9.1, 1062, -111, 1047, -103, 1048, -100, 1043, -97, 1042, -98, 1037, + -95, 1026, -81, 1032, -69, 1046, -77, 1043, -82, 1059, -90, 1060, -88, + 1080, -99, 1071, -116 + ], + [ + 78.9, 15.5, 750, 355, 739, 336, 724, 345, 723, 343, 716, 330, 731, 321, + 721, 303, 693, 318, 722, 370 + ], + [ + 78.9, 5.5, 494, -1126, 480, -1152, 507, -1167, 501, -1177, 462, -1155, + 456, -1166, 442, -1158, 439, -1152, 449, -1134, 446, -1132, 450, -1124, + 455, -1123, 456, -1121, 467, -1127, 473, -1115 + ], + [79.1, 5.8, -1385, -863, -1598, -746, -1568, -692, -1355, -809], + [79.2, 17.1, 142, 199, 132, 181, 120, 188, 130, 208, 140, 203, 139, 201], + [ + 79.2, 13.4, -362, -1595, -388, -1580, -391, -1612, -429, -1590, -418, + -1525, -364, -1556 + ], + [79.2, 19.8, 276, 858, 265, 839, 232, 857, 243, 877], + [79.2, 13.4, -388, -1580, -362, -1595, -363, -1628, -391, -1612], + [ + 79.6, 19.2, 938, 1226, 923, 1199, 898, 1213, 907, 1228, 916, 1223, 923, + 1234 + ], + [79.6, 9.1, 957, -932, 942, -959, 867, -918, 881, -891], + [79.6, 19.2, 534, 669, 521, 645, 481, 667, 495, 691], + [ + 79.6, 7.6, -903, -122, -897, -124, -911, -150, -944, -131, -933, -113, + -906, -128 + ], + [ + 79.7, 11.9, -188, -1286, -200, -1307, -211, -1301, -207, -1292, -211, + -1290, -215, -1297, -246, -1279, -234, -1258, -187, -1284 + ], + [ + 79.9, 10.4, -629, -4, -603, -18, -608, -28, -630, -16, -639, -32, -649, + -26, -635, -1 + ], + [79.9, 20.7, 641, 1267, 640, 1265, 621, 1276, 632, 1297, 651, 1286], + [79.9, 14.9, 1161, 1499, 1146, 1472, 1133, 1479, 1148, 1507], + [80, 11, -643, 644, -618, 630, -633, 604, -670, 625, -656, 651], + [ + 80, 15.5, 1117, 1308, 1142, 1293, 1127, 1267, 1095, 1286, 1108, 1308, + 1109, 1307, 1110, 1310 + ], + [80.1, 12.2, 4, -190, 45, -212, 36, -228, -6, -205, 3, -189], + [ + 80.1, 13.1, -296, -421, -310, -447, -317, -443, -314, -439, -319, -437, + -321, -441, -323, -440, -309, -414 + ], + [80.3, 18, 652, 785, 638, 761, 631, 765, 644, 789], + [ + 80.4, 7.6, 130, -1028, 116, -1053, 84, -1036, 81, -1040, 66, -1032, 82, + -1001 + ], + [80.4, 10.4, -579, -101, -602, -142, -629, -127, -600, -74, -573, -89], + [ + 80.4, 3, 763, -1307, 764, -1319, 752, -1321, 750, -1308, 745, -1309, 746, + -1319, 737, -1320, 736, -1316, 734, -1316, 733, -1310, 736, -1310, 732, + -1286, 725, -1289, 722, -1286, 717, -1293, 711, -1289, 716, -1282, 712, + -1279, 711, -1272, 677, -1277, 675, -1265, 686, -1263, 684, -1250, 676, + -1250, 677, -1252, 673, -1253, 672, -1247, 644, -1231, 690, -1149, 696, + -1152, 704, -1152, 708, -1155, 709, -1160, 720, -1166, 717, -1171, 714, + -1182, 716, -1183, 720, -1208, 734, -1206, 733, -1195, 745, -1190, 759, + -1187, 761, -1200, 781, -1196, 782, -1201, 788, -1200, 813, -1214, 819, + -1256, 790, -1260, 791, -1268, 796, -1268, 796, -1272, 782, -1273, 781, + -1265, 779, -1265, 779, -1269, 771, -1270, 773, -1284, 771, -1284, 769, + -1271, 760, -1272, 759, -1268, 756, -1269, 762, -1293 + ], + [ + 80.5, 10.4, -690, -1494, -698, -1508, -680, -1517, -693, -1539, -734, + -1517, -714, -1481 + ], + [ + 80.7, 20.4, 848, 1151, 862, 1177, 880, 1167, 882, 1172, 884, 1171, 887, + 1176, 885, 1177, 894, 1194, 914, 1183, 885, 1130 + ], + [80.8, 16.8, -65, 448, -82, 416, -110, 432, -92, 463], + [80.8, 15, 144, 238, 155, 232, 146, 215, 134, 221], + [ + 80.9, 11, 76, -590, 96, -601, 90, -613, 50, -591, 64, -565, 81, -575, 74, + -589 + ], + [81.1, 23.2, 452, 429, 439, 404, 434, 406, 435, 409, 427, 413, 439, 436], + [ + 81.2, 12.2, 1569, 1028, 1578, 1043, 1584, 1040, 1587, 1042, 1602, 1069, + 1618, 1060, 1593, 1015 + ], + [ + 81.2, 9.8, -559, 623, -570, 604, -594, 617, -593, 619, -596, 621, -586, + 638 + ], + [81.4, 16.5, 2, 225, -9, 205, -25, 213, -14, 234], + [ + 81.5, 12.8, -780, 430, -790, 413, -796, 416, -797, 413, -804, 417, -803, + 420, -809, 423, -800, 441 + ], + [81.5, 20.1, 887, 1240, 878, 1224, 871, 1228, 880, 1244], + [ + 81.6, 10.7, 1356, 895, 1345, 876, 1316, 892, 1346, 944, 1372, 930, 1357, + 903, 1360, 902 + ], + [ + 81.7, 9.8, -644, -93, -663, -82, -652, -63, -659, -59, -652, -46, -626, + -60 + ], + [81.7, 18.9, 820, 713, 787, 731, 817, 785, 850, 766], + [ + 81.7, 18.6, 529, 603, 541, 624, 543, 622, 548, 630, 554, 627, 568, 651, + 606, 629, 577, 576 + ], + [81.7, 12.5, -1089, 641, -1117, 590, -1157, 612, -1128, 663], + [ + 81.7, 6.4, 559, -1112, 566, -1116, 564, -1120, 576, -1127, 575, -1128, + 577, -1134, 572, -1143, 570, -1142, 565, -1144, 557, -1139, 558, -1137, + 546, -1131, 547, -1129, 545, -1123, 551, -1113, 553, -1114 + ], + [81.7, 18.3, 720, 861, 747, 911, 759, 905, 732, 855], + [ + 81.9, 9.8, 33, -872, 22, -892, 5, -883, 3, -888, -23, -874, -7, -847, 34, + -869 + ], + [ + 82, 18.9, 504, 832, 496, 818, 522, 804, 516, 792, 514, 792, 474, 814, 489, + 840 + ], + [82, 1.2, 865, -1106, 896, -1123, 884, -1142, 800, -1096, 811, -1076], + [ + 82.1, 3, -1748, 79, -1760, 85, -1747, 108, -1735, 102, -1738, 96, -1737, + 95, -1743, 83, -1745, 84 + ], + [ + 82.1, 16.2, 1049, 1220, 1062, 1245, 1052, 1251, 1068, 1279, 1119, 1251, + 1089, 1198 + ], + [ + 82.2, 17.4, -42, 583, -43, 580, -61, 590, -60, 592, -64, 595, -65, 593, + -70, 596, -66, 602, -92, 616, -87, 639, -29, 607 + ], + [82.3, 12.2, -601, 799, -634, 817, -620, 844, -580, 822, -594, 795], + [82.6, 4, -1721, -700, -1694, -715, -1710, -743, -1737, -728], + [ + 83.1, 18.3, 473, 1142, 449, 1100, 386, 1134, 416, 1187, 476, 1154, 478, + 1149, 476, 1147, 473, 1147, 471, 1143 + ], + [ + 83.2, 3.7, -1779, -507, -1775, -500, -1748, -515, -1746, -510, -1693, + -538, -1719, -588, -1799, -543 + ], + [ + 83.2, 10.4, -456, 664, -468, 641, -477, 645, -479, 643, -485, 646, -484, + 649, -488, 651, -490, 648, -506, 657, -490, 683 + ], + [ + 83.4, 17.4, 403, 1103, 388, 1077, 383, 1080, 379, 1074, 359, 1085, 377, + 1118 + ], + [83.5, 19.8, 287, 806, 257, 753, 194, 788, 223, 841], + [83.5, 9.1, -787, -39, -827, -18, -798, 35, -758, 13], + [ + 83.5, 10.4, -594, 617, -570, 604, -573, 600, -581, 604, -583, 602, -585, + 603, -593, 589, -604, 595, -598, 605, -605, 608, -599, 619 + ], + [ + 83.5, 13.1, -263, -1576, -343, -1532, -349, -1466, -345, -1460, -232, + -1522 + ], + [ + 83.5, 10.1, -513, 785, -529, 756, -522, 752, -535, 729, -575, 751, -562, + 774, -536, 759, -520, 789 + ], + [ + 83.5, 14, 1233, 1529, 1232, 1527, 1237, 1524, 1239, 1526, 1264, 1512, + 1249, 1485, 1214, 1505, 1229, 1532 + ], + [ + 83.5, 11, -460, -666, -432, -614, -422, -620, -433, -640, -428, -643, + -430, -648, -434, -646, -448, -673 + ], + [ + 83.6, 12.5, -287, -977, -298, -999, -291, -1003, -294, -1008, -289, -1011, + -301, -1032, -331, -1015, -325, -987, -313, -994, -300, -970 + ], + [83.8, 13.7, 923, 510, 938, 536, 958, 525, 943, 499], + [84, 14, -235, 415, -222, 408, -235, 384, -251, 393, -237, 416], + [ + 84.1, 10.7, -163, -956, -120, -979, -118, -987, -130, -1008, -156, -993, + -151, -985, -179, -970, -170, -953 + ], + [ + 84.1, 5.2, 991, -953, 1013, -966, 1015, -963, 1033, -973, 1031, -976, + 1035, -978, 1030, -988, 1031, -989, 1019, -1011, 996, -998, 998, -994, + 993, -991, 990, -995, 973, -985 + ], + [ + 84.4, 7.9, 1062, -111, 1061, -114, 1063, -115, 1049, -140, 1036, -136, + 1049, -112, 1050, -113, 1054, -107 + ], + [ + 84.4, 11, -618, -1241, -615, -1243, -635, -1278, -672, -1258, -663, -1242, + -658, -1245, -653, -1237, -638, -1235, -636, -1232 + ], + [ + 84.5, 11.6, -107, -526, -117, -545, -121, -543, -128, -556, -124, -558, + -135, -577, -151, -568, -143, -554, -140, -556, -132, -543, -135, -541, + -122, -518 + ], + [ + 84.6, 11, -485, -495, -499, -522, -485, -530, -499, -556, -540, -533, + -511, -481 + ], + [ + 84.6, 11, -85, -539, -95, -557, -99, -555, -106, -568, -102, -570, -113, + -589, -135, -577, -127, -563, -123, -565, -113, -547, -117, -545, -107, + -526 + ], + [ + 84.8, 11.3, -158, -1217, -145, -1224, -158, -1248, -154, -1250, -168, + -1276, -226, -1243, -210, -1215, -170, -1237 + ], + [84.8, 18, 710, 630, 705, 633, 704, 631, 685, 642, 699, 669, 724, 655], + [84.8, 11.6, 108, -376, 99, -393, 97, -392, 88, -408, 64, -394, 82, -361], + [ + 84.8, 10.4, -501, -576, -515, -602, -527, -596, -541, -622, -578, -601, + -563, -575, -552, -581, -555, -587, -536, -598, -533, -593, -538, -589, + -524, -563 + ], + [84.9, 11, 1382, 917, 1373, 901, 1360, 909, 1369, 924], + [ + 85, 15.5, 893, 1773, 907, 1799, 919, 1792, 929, 1810, 927, 1811, 933, + 1822, 999, 1787, 1000, 1783, 972, 1730, 968, 1729, 896, 1768, 898, 1771 + ], + [85.1, 11.3, 367, -317, 366, -319, 312, -289, 341, -237, 395, -267], + [ + 85.2, 12.2, -782, 473, -811, 421, -857, 446, -846, 466, -849, 468, -847, + 471, -845, 474, -843, 473, -829, 498 + ], + [85.3, 22.3, 437, 527, 426, 508, 401, 523, 411, 542], + [85.3, 19.2, 76, 515, 61, 488, 35, 503, 49, 529], + [ + 85.4, 13.1, 1225, 886, 1211, 860, 1209, 861, 1211, 864, 1191, 875, 1204, + 898 + ], + [ + 85.5, 7.9, 640, -408, 627, -432, 622, -427, 608, -452, 581, -437, 584, + -432, 588, -435, 611, -394, 627, -403, 628, -401 + ], + [ + 85.6, 10.1, -628, -192, -638, -211, -666, -196, -654, -175, -634, -186, + -635, -188 + ], + [85.6, 22.6, 604, 1873, 591, 1849, 579, 1855, 594, 1882, 606, 1875], + [ + 85.7, 8.8, 60, -1432, 42, -1465, 20, -1453, 43, -1413, 57, -1420, 53, + -1428 + ], + [ + 85.8, 9.4, 1670, 536, 1666, 527, 1644, 541, 1633, 545, 1633, 547, 1643, + 564, 1644, 565, 1654, 560, 1655, 561, 1664, 557, 1661, 551, 1669, 547, + 1670, 549, 1676, 546 + ], + [85.8, 16.8, 1146, 205, 1127, 216, 1142, 243, 1161, 232], + [ + 86, 12.8, -200, -496, -227, -481, -228, -484, -234, -481, -237, -488, + -263, -473, -259, -444, -256, -443, -190, -479 + ], + [86, 17.1, 291, -188, 320, -136, 342, -148, 312, -200], + [ + 86, 17.7, 645, 754, 668, 741, 654, 714, 602, 743, 614, 764, 639, 750, 641, + 753, 643, 752 + ], + [86, 16.8, 1052, 1251, 1062, 1245, 1049, 1220, 1024, 1234, 1037, 1259], + [86.2, 11.3, -470, -156, -477, -169, -494, -160, -486, -147], + [ + 86.3, 12.2, 1177, 494, 1163, 468, 1137, 482, 1131, 472, 1127, 474, 1132, + 485, 1100, 502, 1115, 529 + ], + [86.3, 12.5, -393, 411, -371, 399, -383, 377, -410, 391, -398, 413], + [86.3, 7, -1365, -932, -1358, -936, -1373, -963, -1398, -949, -1383, -922], + [86.6, 11.3, -717, 700, -723, 688, -757, 707, -742, 733, -709, 714], + [86.6, 15.2, 169, -83, 182, -60, 212, -77, 196, -107, 172, -93, 176, -87], + [ + 86.7, 13.7, 788, 210, 795, 206, 792, 199, 805, 192, 794, 173, 750, 197, + 761, 218, 784, 206, 787, 211 + ], + [ + 86.8, 17.4, -18, 331, -31, 309, -32, 310, -35, 304, -40, 307, -52, 284, + -77, 297, -48, 349, -18, 332 + ], + [ + 86.9, 9.1, -582, 687, -570, 681, -571, 680, -565, 677, -574, 661, -593, + 672, -584, 688 + ], + [ + 86.9, 12.8, -238, -828, -247, -844, -250, -842, -251, -844, -254, -843, + -253, -841, -265, -834, -267, -835, -273, -847, -270, -849, -275, -858, + -279, -856, -280, -858, -282, -856, -282, -855, -290, -850, -289, -846, + -291, -846, -290, -843, -288, -843, -287, -836, -288, -835, -288, -832, + -286, -833, -283, -822, -285, -821, -284, -819, -283, -819, -281, -811, + -283, -811, -282, -808, -280, -809, -279, -805, -268, -811, -267, -809, + -265, -811, -266, -812, -256, -818, -255, -816, -253, -817, -254, -819, + -243, -825, -243, -823, -241, -824, -241, -826 + ], + [ + 86.9, 23.5, 400, 412, 393, 400, 390, 401, 389, 400, 382, 404, 383, 405, + 379, 407, 386, 420 + ], + [ + 87, 10.1, -544, 713, -548, 706, -521, 692, -529, 678, -555, 693, -559, + 687, -565, 690, -551, 716 + ], + [ + 87, 15.2, 1139, 1491, 1137, 1487, 1135, 1488, 1131, 1480, 1147, 1472, + 1132, 1445, 1099, 1463, 1128, 1517, 1148, 1507 + ], + [ + 87.2, 10.7, 679, -142, 700, -154, 686, -179, 672, -172, 676, -165, 668, + -161 + ], + [ + 87.2, 12.5, -273, -1606, -232, -1628, -245, -1651, -271, -1636, -272, + -1638, -286, -1630 + ], + [87.3, 16.5, -56, 229, -67, 210, -87, 220, -76, 240], + [87.4, 13.7, 1397, 310, 1370, 325, 1382, 346, 1409, 331], + [ + 87.5, 6.4, 1006, -673, 1005, -675, 1006, -675, 1002, -683, 1004, -687, + 997, -702, 982, -700, 979, -696, 974, -694, 960, -720, 974, -728, 970, + -736, 955, -729, 947, -743, 926, -732, 971, -654 + ], + [ + 87.6, 18.6, 876, 1441, 863, 1448, 871, 1461, 864, 1465, 856, 1452, 845, + 1458, 845, 1457, 843, 1458, 845, 1462, 847, 1460, 853, 1473, 851, 1474, + 858, 1486, 891, 1467 + ], + [87.8, 10.7, -526, 11, -532, -1, -552, 10, -545, 22], + [ + 87.9, 8.8, 530, -970, 566, -990, 558, -1005, 561, -1006, 543, -1037, 504, + -1015, 529, -970 + ], + [87.9, 23.5, 429, 1761, 449, 1750, 442, 1737, 416, 1751, 423, 1764], + [88.1, 19.8, 817, 1508, 845, 1493, 830, 1466, 802, 1482], + [ + 88.1, 9.8, -610, -158, -628, -192, -635, -188, -634, -186, -654, -175, + -649, -164, -633, -173, -622, -152 + ], + [88.1, 15.8, 696, 227, 711, 253, 744, 235, 730, 209], + [ + 88.2, 19.5, 940, 1134, 946, 1130, 945, 1128, 949, 1126, 950, 1128, 960, + 1123, 946, 1096, 906, 1118, 921, 1144 + ], + [ + 88.3, 14.9, -170, 402, -176, 356, -179, 354, -219, 375, -205, 400, -201, + 398, -192, 414 + ], + [ + 88.5, 19.5, 560, 72, 556, 74, 560, 83, 566, 80, 569, 86, 564, 89, 569, 98, + 592, 85, 578, 59, 574, 60, 573, 59, 570, 61, 571, 62, 561, 68, 562, 70 + ], + [ + 88.6, 11.9, -93, -444, -108, -470, -110, -468, -109, -465, -139, -448, + -126, -426 + ], + [88.6, 11, -487, 754, -513, 768, -506, 781, -480, 766], + [88.7, 22.6, 270, 441, 257, 418, 240, 428, 253, 451, 270, 442], + [88.7, 17.7, -35, 580, -40, 572, -34, 568, -45, 547, -58, 554, -42, 583], + [ + 88.8, 18.3, 630, 822, 643, 846, 670, 831, 685, 857, 722, 837, 714, 823, + 712, 824, 699, 799, 700, 798, 693, 784, 629, 820 + ], + [ + 88.8, 13.1, -315, 373, -297, 363, -300, 358, -292, 354, -303, 333, -356, + 362, -342, 388 + ], + [88.9, 21.9, 250, 1816, 277, 1801, 270, 1776, 238, 1794], + [ + 88.9, 8.8, 457, -391, 455, -395, 511, -426, 510, -427, 513, -429, 517, + -423, 538, -435, 515, -476, 494, -464, 498, -455, 486, -449, 486, -451, + 471, -444, 447, -429, 439, -443, 430, -439, 428, -442, 402, -428, 430, + -376 + ], + [89, 19.5, 322, 695, 293, 642, 273, 653, 302, 706], + [89.2, 11, -565, 895, -573, 880, -586, 888, -578, 902], + [ + 89.2, 11.6, -479, 408, -493, 383, -484, 378, -499, 351, -539, 374, -525, + 400, -513, 393, -499, 419 + ], + [ + 89.4, 18, 1003, 1133, 990, 1109, 993, 1107, 985, 1092, 962, 1104, 970, + 1119, 961, 1123, 964, 1129, 958, 1132, 969, 1152 + ], + [89.4, 10.4, 1271, -23, 1277, -27, 1248, -78, 1224, -65, 1253, -13], + [89.6, 17.7, 628, 667, 602, 681, 605, 686, 584, 698, 598, 724, 645, 698], + [89.6, 23.8, 464, 373, 457, 359, 432, 373, 439, 386], + [89.9, 18, 993, 1230, 978, 1204, 960, 1214, 974, 1240], + [89.9, 7, 187, -1078, 173, -1102, 153, -1091, 168, -1067], + [ + 90, 20.4, 593, 1711, 583, 1693, 595, 1687, 580, 1660, 540, 1693, 565, 1737 + ], + [90.2, 10.4, -622, -152, -633, -173, -649, -164, -637, -143], + [90.2, 11.9, 148, -191, 145, -197, 121, -184, 129, -171, 152, -184], + [ + 90.2, 12.5, -428, -223, -425, -224, -424, -223, -408, -232, -415, -245, + -436, -234, -429, -222 + ], + [90.2, 11, 28, -724, 2, -709, 4, -705, -22, -690, -10, -668, 42, -698], + [ + 90.4, 14.9, -249, 818, -264, 791, -245, 781, -261, 753, -301, 775, -287, + 800, -285, 798, -281, 804, -284, 805, -271, 829 + ], + [ + 90.5, 18.9, 950, 1072, 964, 1065, 949, 1038, 946, 1039, 949, 1045, 945, + 1047, 942, 1042, 935, 1045 + ], + [ + 90.5, 11.3, 1075, -26, 1091, -35, 1093, -34, 1099, -24, 1118, -34, 1095, + -76, 1076, -65, 1081, -55, 1081, -52, 1065, -44, 1065, -45, 1052, -38, + 1063, -17, 1076, -24 + ], + [ + 90.5, 18.9, 969, 1152, 958, 1132, 944, 1140, 940, 1134, 921, 1144, 935, + 1171 + ], + [90.5, 12.8, -332, -156, -322, -138, -289, -156, -295, -168], + [90.6, 13.7, 1078, 334, 1063, 308, 1050, 315, 1079, 368, 1092, 361], + [90.7, 12.5, -237, -562, -273, -543, -270, -527, -267, -526, -228, -547], + [90.7, 24.7, 341, 245, 370, 297, 409, 275, 380, 223], + [ + 90.7, 2.1, -1690, 282, -1691, 282, -1850, 369, -1850, 372, -1834, 426, + -1832, 427, -1662, 332 + ], + [ + 90.8, 15.5, -49, 1429, -43, 1440, -34, 1435, -36, 1431, -28, 1426, -30, + 1424, -25, 1422, -32, 1409, -46, 1416, -50, 1409, -58, 1413 + ], + [ + 90.8, 21.6, 721, 1255, 723, 1259, 739, 1251, 736, 1247, 761, 1234, 746, + 1207, 706, 1229 + ], + [ + 90.9, 15.5, -190, 538, -242, 567, -228, 593, -181, 567, -184, 562, -178, + 558 + ], + [91.1, 19.2, 747, 911, 733, 886, 713, 897, 727, 922], + [91.1, 12.8, 1127, 474, 1120, 462, 1104, 470, 1117, 493, 1132, 485], + [91.2, 18.6, 929, 1411, 922, 1398, 896, 1413, 904, 1426], + [ + 91.4, 11.9, -304, -613, -308, -654, -313, -656, -359, -631, -351, -617, + -332, -628, -326, -617, -339, -610, -332, -597 + ], + [91.4, 20.4, 622, 1791, 613, 1774, 597, 1783, 606, 1800], + [91.4, 19.8, 618, 1707, 604, 1682, 583, 1693, 597, 1718], + [ + 91.5, 12.8, -326, -784, -321, -778, -322, -785, -321, -788, -326, -842, + -329, -844, -351, -832, -352, -829 + ], + [ + 91.5, 14.3, 1171, 911, 1168, 907, 1164, 909, 1160, 901, 1164, 899, 1158, + 889, 1140, 899, 1154, 925, 1173, 915 + ], + [ + 91.5, 14, 1768, 1047, 1764, 1040, 1770, 1037, 1756, 1010, 1735, 1022, + 1736, 1024, 1659, 1064, 1678, 1098, 1705, 1083, 1703, 1080, 1712, 1075, + 1718, 1082, 1716, 1083, 1721, 1092, 1739, 1083, 1734, 1073, 1732, 1074, + 1729, 1069, 1731, 1068, 1729, 1065, 1738, 1060, 1740, 1063 + ], + [91.7, 12.2, 64, -219, 70, -222, 71, -219, 78, -222, 66, -242, 54, -236], + [ + 91.7, 2.7, -1840, -404, -1835, -404, -1831, -401, -1828, -398, -1828, + -394, -1836, -390, -1843, -390, -1841, -373, -1825, -382, -1825, -380, + -1795, -397, -1810, -452, -1846, -432, -1844, -428 + ], + [ + 91.8, 11.9, -237, -1294, -241, -1301, -233, -1305, -229, -1298, -218, + -1304, -230, -1325, -261, -1308, -249, -1287 + ], + [ + 91.8, 11.9, -612, -2018, -643, -2066, -659, -2055, -649, -2041, -679, + -2022, -658, -1989 + ], + [91.9, 11.6, -412, 371, -426, 345, -432, 348, -417, 374], + [ + 92, 18.6, 1226, 252, 1225, 250, 1227, 247, 1225, 247, 1227, 241, 1228, + 241, 1228, 238, 1233, 236, 1228, 227, 1223, 229, 1224, 231, 1210, 239, + 1207, 238, 1202, 241, 1212, 260 + ], + [ + 92, 18.6, 746, 1923, 738, 1908, 735, 1910, 730, 1901, 716, 1909, 721, + 1918, 718, 1919, 726, 1934 + ], + [ + 92.2, 17.1, 1184, 366, 1197, 359, 1194, 353, 1195, 351, 1190, 342, 1178, + 348, 1177, 345, 1166, 351, 1173, 365, 1179, 362, 1180, 365 + ], + [92.2, 18.6, 430, 748, 445, 774, 465, 763, 480, 789, 506, 775, 477, 722], + [92.2, 12.5, -191, 1160, -221, 1108, -247, 1122, -218, 1175], + [ + 92.3, 12.2, -466, -336, -488, -375, -514, -361, -499, -335, -491, -339, + -483, -327 + ], + [ + 92.3, 13.4, 1388, 373, 1380, 358, 1366, 366, 1365, 363, 1352, 370, 1353, + 373, 1347, 377, 1355, 391 + ], + [ + 92.6, 18.9, 358, -79, 375, -88, 356, -121, 335, -110, 342, -98, 349, -103, + 355, -92, 347, -88, 353, -77 + ], + [92.7, 15.8, 136, 1311, 120, 1283, 92, 1298, 104, 1328], + [92.7, 13.7, -270, 471, -284, 446, -304, 457, -289, 482], + [ + 92.7, 24.1, 373, 474, 399, 460, 399, 458, 410, 452, 395, 426, 384, 432, + 387, 437, 376, 444, 372, 438, 358, 445 + ], + [92.7, 12.2, -341, 140, -370, 87, -473, 144, -444, 197], + [ + 92.8, 7.3, 1447, 547, 1455, 543, 1453, 539, 1415, 561, 1417, 564, 1425, + 559, 1429, 567, 1427, 569, 1437, 587, 1464, 572, 1454, 554, 1451, 555 + ], + [92.9, 11.3, -592, 877, -604, 856, -613, 861, -602, 883], + [93, 11.3, -602, 883, -613, 861, -625, 868, -613, 888], + [93, 6.1, 798, -422, 787, -442, 767, -431, 773, -421, 780, -425, 785, -415], + [ + 93.3, 15.2, -147, 1429, -160, 1436, -149, 1455, -131, 1445, -138, 1432, + -143, 1435 + ], + [93.3, 16.2, 854, 604, 884, 657, 956, 617, 927, 564], + [93.4, 16.8, 1067, 1344, 1041, 1359, 1045, 1366, 1071, 1351], + [ + 93.4, 5.2, -909, 1536, -911, 1532, -928, 1541, -939, 1522, -908, 1505, + -916, 1492, -961, 1517, -959, 1520, -962, 1522, -959, 1526, -962, 1527, + -941, 1564, -938, 1563, -936, 1567, -933, 1565, -931, 1568, -868, 1533, + -876, 1518 + ], + [ + 93.5, 10.1, -495, 740, -509, 714, -535, 729, -525, 747, -522, 745, -518, + 753 + ], + [ + 93.6, 18.3, 1267, 316, 1254, 293, 1249, 296, 1247, 298, 1248, 299, 1245, + 301, 1247, 303, 1244, 305, 1247, 310, 1243, 312, 1245, 315, 1243, 316, + 1249, 326 + ], + [ + 93.6, 18.6, 920, 971, 931, 992, 965, 974, 935, 921, 885, 949, 899, 975, + 916, 966 + ], + [ + 93.9, 7.6, 1411, 711, 1421, 706, 1408, 683, 1390, 692, 1399, 708, 1402, + 708, 1406, 714 + ], + [ + 94.2, 10.7, -121, -1107, -143, -1095, -126, -1064, -102, -1077, -119, + -1108 + ], + [94.3, 10.4, -584, 454, -585, 451, -612, 466, -605, 478, -579, 463], + [ + 94.3, 8.5, -736, -1193, -748, -1215, -769, -1204, -766, -1198, -768, + -1197, -752, -1165, -735, -1175, -743, -1189 + ], + [94.3, 15.5, -216, 676, -231, 650, -258, 665, -243, 691], + [94.5, 9.8, -530, -208, -527, -211, -538, -232, -552, -225, -540, -203], + [94.8, 15.2, -158, 465, -213, 495, -198, 521, -152, 495], + [94.8, 11.9, 1228, 557, 1213, 531, 1201, 537, 1216, 564], + [ + 95, 17.7, 984, 1416, 975, 1399, 948, 1414, 943, 1404, 937, 1407, 939, + 1410, 934, 1413, 939, 1423, 923, 1432, 920, 1426, 907, 1432, 918, 1452 + ], + [95, 17.1, -69, 416, -53, 407, -68, 381, -94, 396, -79, 422], + [95.1, 4.3, 976, -833, 993, -802, 1064, -839, 1052, -875], + [95.1, 21.6, 316, 36, 334, 25, 330, 17, 303, 32, 308, 40], + [ + 95.1, 13.4, -1086, 675, -1113, 691, -1099, 716, -1082, 707, -1090, 697, + -1078, 690 + ], + [ + 95.1, 15.5, -99, 1017, -104, 1008, -100, 1006, -120, 973, -123, 975, -128, + 965, -212, 1012, -197, 1039, -160, 1018, -146, 1043, -115, 1028, -116, + 1026 + ], + [ + 95.1, 4.3, 976, -833, 949, -818, 952, -811, 943, -806, 953, -788, 977, + -802, 983, -790, 981, -788, 982, -785, 986, -787, 1035, -698, 1038, -699, + 1042, -693, 1059, -702, 1045, -727, 1049, -729, 1051, -726, 1076, -740, + 1050, -787, 1045, -787, 1044, -796, 1016, -781, 1002, -807, 993, -802 + ], + [ + 95.2, 14.3, 1136, 1582, 1105, 1600, 1106, 1601, 1100, 1605, 1099, 1603, + 1089, 1609, 1103, 1635, 1151, 1609 + ], + [95.2, 18, 710, 630, 694, 601, 669, 614, 685, 642, 704, 631, 705, 633], + [95.3, 16.5, 722, 370, 693, 318, 660, 337, 689, 389], + [ + 96, 10.1, -490, 648, -490, 645, -481, 640, -494, 616, -520, 631, -506, 657 + ], + [96.4, 19.8, 581, 449, 566, 422, 530, 442, 544, 466, 547, 467], + [ + 96.5, 15.2, 1086, 961, 1106, 950, 1105, 948, 1132, 933, 1119, 910, 1079, + 932, 1080, 935, 1073, 940, 1085, 962 + ], + [ + 96.6, 7.9, -1071, -799, -1097, -845, -1127, -829, -1124, -824, -1126, + -823, -1124, -819, -1121, -818, -1115, -807, -1117, -806, -1115, -802, + -1112, -803, -1100, -781 + ], + [ + 96.7, 25.6, 464, 2010, 479, 2036, 505, 2022, 507, 2027, 500, 2032, 503, + 2037, 497, 2041, 500, 2046, 497, 2047, 503, 2058, 525, 2042, 529, 2037, + 529, 2027, 521, 2004, 510, 1984 + ], + [ + 97, 22.9, 306, 1954, 287, 1965, 280, 1951, 229, 1979, 244, 2006, 308, 1970 + ], + [ + 97.1, 2.4, 1108, -474, 1167, -506, 1160, -520, 1157, -519, 1147, -537, + 1149, -539, 1142, -552, 1082, -519, 1092, -501, 1096, -502, 1100, -494, + 1097, -492 + ], + [ + 97.1, 11.9, 1195, 528, 1188, 515, 1156, 532, 1169, 555, 1182, 547, 1185, + 552, 1186, 551, 1191, 556, 1197, 552, 1192, 544, 1189, 545, 1188, 544, + 1192, 542, 1194, 545, 1196, 544, 1193, 538, 1199, 535 + ], + [ + 97.2, 10.7, -561, -23, -549, -31, -551, -35, -553, -34, -555, -38, -554, + -39, -563, -56, -583, -46, -568, -19 + ], + [97.2, 20.4, 640, 237, 626, 211, 640, 203, 625, 177, 584, 200, 613, 252], + [ + 97.4, 11.9, 1179, 644, 1204, 630, 1202, 627, 1237, 608, 1235, 604, 1237, + 603, 1225, 580, 1162, 615 + ], + [97.6, 9.1, 1871, 715, 1838, 733, 1848, 750, 1881, 731], + [ + 97.6, 21, 148, 482, 158, 500, 161, 502, 174, 495, 174, 492, 161, 467, 145, + 476 + ], + [ + 97.7, 13.1, -350, 337, -196, 253, -197, 251, -191, 250, -199, 196, -212, + 199, -215, 194, -393, 293, -393, 296, -368, 340, -353, 331 + ], + [ + 97.8, 14.6, 716, 262, 709, 266, 718, 283, 758, 261, 747, 240, 724, 253, + 726, 257 + ], + [98, 11, 456, -586, 441, -614, 411, -598, 421, -582, 427, -585, 434, -573], + [98, 19.5, 451, 676, 418, 694, 420, 698, 387, 716, 401, 743, 468, 706], + [98, 16.8, -92, 463, -103, 444, -128, 457, -124, 477, -121, 479], + [ + 98, 13.4, 1100, 718, 1089, 699, 1085, 702, 1081, 694, 1038, 718, 1053, 744 + ], + [ + 98.1, 15, -207, 1311, -198, 1328, -175, 1315, -184, 1298, -205, 1309, + -217, 1287, -236, 1298, -225, 1319, -223, 1318, -222, 1320 + ], + [98.1, 11.3, -633, 542, -611, 530, -623, 509, -657, 528, -646, 549], + [98.2, 24.4, 593, 2008, 563, 1955, 537, 1970, 567, 2022], + [ + 98.5, 14.9, 1120, 1584, 1108, 1563, 1104, 1566, 1099, 1573, 1097, 1571, + 1092, 1573, 1104, 1593, 1111, 1594, 1116, 1591, 1114, 1587 + ], + [ + 98.6, 13.4, 799, 229, 788, 210, 787, 211, 784, 206, 761, 218, 779, 250, + 803, 236 + ], + [98.7, 14.3, 789, 440, 841, 411, 811, 356, 739, 396, 769, 451], + [98.7, 10.1, -529, 678, -539, 659, -566, 674, -555, 693], + [ + 98.8, 21.3, 150, 405, 152, 404, 154, 408, 174, 398, 171, 393, 173, 393, + 166, 381, 143, 394 + ], + [98.8, 18.9, 635, 1755, 650, 1781, 669, 1770, 655, 1744], + [ + 98.8, 24.1, 329, 1890, 330, 1892, 329, 1893, 331, 1913, 374, 1896, 361, + 1872 + ], + [98.9, 11, -573, 880, -565, 895, -552, 888, -560, 873], + [ + 99.1, 2.1, 1083, -1065, 1087, -1067, 1089, -1063, 1100, -1069, 1089, + -1086, 1099, -1091, 1090, -1106, 1082, -1101, 1083, -1099, 1079, -1097, + 1077, -1101, 1066, -1095, 1076, -1079, 1067, -1074, 1075, -1058, 1084, + -1063 + ], + [ + 99.2, 14.3, 1462, 1601, 1441, 1563, 1409, 1581, 1419, 1600, 1418, 1601, + 1421, 1606, 1426, 1603, 1434, 1616 + ], + [99.2, 14.3, -144, 56, -145, 53, -185, 75, -180, 115, -170, 135, -116, 105], + [ + 99.4, 10.7, 1590, 897, 1596, 893, 1598, 896, 1609, 889, 1601, 876, 1597, + 879, 1594, 874, 1589, 877, 1581, 863, 1555, 877, 1573, 909, 1581, 905, + 1580, 903 + ], + [ + 99.4, 11.6, -612, -2018, -658, -1989, -633, -1951, -609, -1966, -603, + -1957, -582, -1970 + ], + [ + 99.5, 10.7, -611, 530, -633, 542, -629, 547, -640, 553, -626, 579, -594, + 562 + ], + [99.6, 15.2, -158, 465, -164, 434, -215, 463, -201, 489], + [ + 99.7, 4.6, 851, -432, 859, -437, 860, -435, 873, -443, 872, -445, 888, + -453, 875, -477, 846, -460, 841, -468, 840, -468, 831, -482, 832, -484, + 817, -476, 835, -444, 834, -444, 833, -445, 823, -439, 834, -421, 847, + -428, 846, -430 + ], + [ + 100, 15.5, -143, 310, -122, 298, -120, 300, -114, 297, -144, 244, -160, + 253, -151, 313, -148, 315, -142, 311 + ], + [ + 100, 2.1, 1160, -323, 1204, -348, 1180, -392, 1167, -385, 1148, -332, + 1154, -320 + ], + [ + 100.3, 8.5, 1145, -137, 1167, -149, 1155, -171, 1108, -145, 1094, -171, + 1066, -156, 1080, -130, 1095, -138, 1108, -116 + ], + [ + 100.3, 3, -1434, 318, -1587, 402, -1558, 455, -1531, 440, -1546, 414, + -1419, 344 + ], + [100.3, 24.1, 346, 361, 343, 356, 346, 354, 336, 337, 307, 353, 319, 375], + [ + 100.8, 12.5, -524, -390, -516, -394, -514, -390, -501, -397, -501, -399, + -509, -413, -528, -402, -534, -413, -531, -415, -537, -425, -531, -428, + -537, -439, -542, -436, -545, -441, -556, -435, -541, -409, -549, -404, + -537, -382 + ], + [ + 100.9, 12.5, -330, 471, -352, 483, -366, 457, -411, 482, -400, 503, -383, + 494, -378, 504, -388, 509, -376, 531, -316, 498 + ], + [101, 18, 22, 668, -7, 616, -28, 627, -17, 647, -12, 644, 6, 677], + [101.2, 15.5, 1127, 1337, 1115, 1316, 1096, 1327, 1108, 1348], + [ + 101.2, 12.8, -48, -387, -57, -402, -62, -399, -65, -405, -103, -384, -88, + -358, -45, -382 + ], + [101.2, 7, 1579, 518, 1555, 531, 1562, 544, 1586, 531], + [ + 101.4, 11, 1610, 932, 1610, 931, 1593, 940, 1595, 943, 1594, 944, 1595, + 947, 1597, 946, 1600, 953, 1599, 953, 1600, 956, 1602, 955, 1604, 959, + 1602, 960, 1603, 962, 1605, 961, 1609, 968, 1607, 969, 1612, 974, 1621, + 969, 1622, 970, 1624, 968, 1623, 967, 1636, 960, 1624, 937, 1615, 942 + ], + [ + 101.5, 7.6, 1728, 782, 1711, 791, 1718, 803, 1716, 804, 1719, 809, 1711, + 813, 1716, 822, 1742, 807 + ], + [ + 101.8, 23.5, 312, 2007, 309, 2005, 262, 2031, 261, 2035, 287, 2083, 291, + 2084, 318, 2069, 319, 2065 + ], + [ + 102, 23.5, 372, 438, 383, 432, 380, 427, 388, 422, 383, 414, 375, 419, + 369, 408, 350, 418, 348, 426, 358, 445 + ], + [ + 102.1, 8.2, 1928, 847, 1920, 834, 1901, 845, 1919, 877, 1932, 870, 1926, + 860, 1925, 861, 1921, 855, 1921, 852, 1928, 848 + ], + [102.4, 15, -205, 1309, -194, 1303, -204, 1285, -215, 1291], + [102.5, 12.2, 1022, 512, 1051, 565, 1088, 544, 1059, 491], + [ + 102.5, 15.8, 1336, 406, 1356, 395, 1340, 366, 1347, 362, 1334, 339, 1301, + 357, 1313, 378, 1317, 377, 1320, 384, 1319, 390, 1330, 409 + ], + [ + 102.6, 13.4, -238, 172, -253, 146, -251, 145, -253, 142, -259, 145, -261, + 141, -255, 138, -265, 119, -325, 152, -312, 176, -292, 165, -276, 193 + ], + [ + 102.6, 23.2, 517, 369, 513, 371, 506, 358, 514, 353, 514, 352, 533, 341, + 523, 323, 477, 349, 499, 388, 521, 376 + ], + [102.7, 16.5, -58, 884, -69, 842, -86, 851, -64, 888], + [ + 102.7, 18, -10, 596, -23, 573, -27, 575, -28, 573, -32, 575, -31, 577, + -35, 580, -22, 603 + ], + [ + 102.8, 7.6, 1379, 623, 1358, 635, 1357, 632, 1352, 635, 1366, 660, 1381, + 651, 1382, 652, 1392, 647, 1388, 639, 1387, 639 + ], + [ + 102.8, 18.9, 365, 846, 353, 825, 345, 830, 331, 803, 321, 808, 338, 840, + 324, 848, 333, 863, 350, 856 + ], + [103, 22.9, 472, 387, 446, 400, 460, 425, 485, 411], + [ + 103, 10.7, 531, -287, 526, -295, 522, -292, 526, -284, 523, -282, 536, + -259, 552, -268, 544, -283, 536, -279 + ], + [ + 103.2, 11.6, 1426, 1328, 1434, 1343, 1439, 1342, 1453, 1334, 1452, 1333, + 1455, 1331, 1443, 1309, 1438, 1311, 1442, 1319 + ], + [103.3, 8.8, 1546, 924, 1532, 897, 1505, 912, 1519, 938], + [103.5, 6.1, -863, 1350, -877, 1324, -922, 1348, -907, 1375], + [ + 103.9, 15.8, -185, 872, -198, 847, -210, 854, -211, 852, -214, 854, -228, + 828, -235, 832, -206, 884 + ], + [104.2, 11.3, -613, 888, -625, 868, -633, 873, -622, 893], + [ + 104.2, 14, 1330, 1656, 1341, 1650, 1326, 1623, 1289, 1644, 1296, 1656, + 1299, 1655, 1301, 1660, 1319, 1650, 1325, 1658 + ], + [ + 104.2, 16.5, 814, 1783, 809, 1774, 796, 1781, 780, 1753, 762, 1764, 773, + 1784, 778, 1781, 788, 1798 + ], + [104.2, 13.4, 1705, 655, 1691, 629, 1681, 634, 1696, 660], + [ + 104.3, 10.7, 976, 230, 966, 213, 968, 212, 966, 209, 971, 206, 954, 174, + 926, 189, 955, 241 + ], + [104.4, 11, -736, 379, -707, 432, -676, 414, -704, 362], + [ + 104.5, 16.2, 1052, 1284, 1041, 1266, 1027, 1274, 1025, 1269, 1019, 1271, + 1025, 1282, 1004, 1294, 1013, 1309, 1033, 1298, 1030, 1293, 1048, 1282, + 1050, 1285 + ], + [104.7, 19.8, 204, 76, 194, 58, 181, 65, 191, 83], + [ + 104.8, 11.6, -570, 1852, -545, 1898, -495, 1872, -523, 1821, -525, 1820, + -528, 1820, -555, 1835, -558, 1846, -564, 1849, -568, 1848 + ], + [104.8, 10.4, -684, -296, -712, -349, -742, -332, -713, -280], + [104.9, 10.1, -489, 593, -518, 541, -558, 563, -528, 615], + [104.9, 20.4, 230, 1763, 210, 1774, 225, 1801, 245, 1789], + [105.2, 14, 277, -264, 275, -269, 220, -239, 249, -186, 304, -216], + [ + 105.4, 11, -516, 28, -535, 38, -524, 61, -522, 61, -470, 33, -484, 7, + -516, 24, -514, 26 + ], + [ + 105.4, 12.2, 1356, 1392, 1341, 1365, 1366, 1351, 1351, 1324, 1319, 1342, + 1334, 1368, 1336, 1367, 1351, 1394 + ], + [ + 105.6, 14, 1369, 1557, 1360, 1541, 1337, 1555, 1353, 1584, 1355, 1584, + 1367, 1578, 1368, 1573, 1361, 1562 + ], + [ + 105.7, 23.5, 372, 1844, 342, 1792, 311, 1810, 317, 1821, 312, 1823, 320, + 1848, 331, 1867 + ], + [ + 106, 17.4, -22, 692, -5, 683, -19, 657, -13, 653, -28, 627, -82, 657, -73, + 695, -32, 672 + ], + [ + 106.1, 13.1, 1298, 1287, 1288, 1269, 1282, 1273, 1284, 1276, 1280, 1279, + 1288, 1293 + ], + [ + 106.3, 12.2, 1064, 342, 1050, 315, 1009, 338, 1037, 389, 1067, 373, 1053, + 348 + ], + [106.3, 20.4, 834, 1374, 806, 1389, 820, 1416, 853, 1398, 838, 1372], + [106.4, 13.1, -257, -85, -233, -99, -237, -131, -275, -118], + [ + 106.6, 12.8, -287, -14, -301, -40, -328, -25, -317, -6, -313, -8, -309, -1 + ], + [106.7, 2.4, 2279, -546, 2264, -603, 2193, -584, 2220, -530], + [ + 106.7, 7.3, 656, -346, 652, -344, 650, -348, 646, -345, 648, -342, 641, + -338, 639, -342, 635, -339, 637, -336, 634, -334, 645, -316, 666, -328 + ], + [ + 106.7, 12.5, 715, -78, 735, -89, 728, -103, 708, -92, 711, -86, 709, -85, + 713, -77 + ], + [ + 107.3, 18.6, 1832, 1316, 1816, 1287, 1810, 1290, 1800, 1271, 1781, 1282, + 1791, 1300, 1795, 1298, 1811, 1327 + ], + [ + 107.8, 12.2, -286, 1122, -286, 1121, -284, 1120, -298, 1094, -324, 1109, + -321, 1115, -334, 1123, -338, 1117, -371, 1135, -356, 1161 + ], + [ + 108.2, 2.1, 989, -1261, 993, -1264, 996, -1259, 1009, -1267, 1003, -1276, + 1000, -1274, 997, -1281, 1005, -1285, 997, -1299, 983, -1290, 981, -1294, + 968, -1287, 973, -1278, 976, -1280, 980, -1273, 972, -1269, 979, -1255, + 990, -1260 + ], + [ + 108.3, 8.5, 1886, 696, 1890, 704, 1872, 714, 1884, 737, 1909, 723, 1906, + 717, 1914, 713, 1913, 711, 1916, 710, 1921, 717, 1939, 707, 1909, 654, + 1870, 676, 1874, 682, 1875, 682, 1881, 692, 1883, 691 + ], + [ + 108.4, 2.1, 1081, -1261, 1085, -1263, 1090, -1255, 1104, -1263, 1095, + -1277, 1099, -1279, 1092, -1292, 1083, -1287, 1084, -1284, 1078, -1280, + 1073, -1288, 1059, -1280, 1065, -1271, 1066, -1271, 1069, -1267, 1064, + -1264, 1071, -1251, 1081, -1257, 1079, -1260 + ], + [ + 108.5, 4, -1497, 511, -1439, 479, -1454, 453, -1508, 482, -1504, 489, + -1531, 503, -1520, 522, -1498, 510 + ], + [108.6, 12.5, 1073, 73, 1062, 52, 1058, 54, 1051, 39, 1026, 53, 1046, 88], + [108.8, 12.8, 1699, 624, 1691, 629, 1705, 655, 1715, 650], + [108.9, 23.8, 427, 199, 426, 197, 401, 212, 430, 264, 455, 250], + [ + 109.4, 18.6, 1668, 1587, 1660, 1573, 1657, 1575, 1655, 1572, 1642, 1579, + 1644, 1582, 1638, 1586, 1645, 1599 + ], + [ + 109.4, 12.8, 1665, 1013, 1662, 1007, 1635, 1021, 1650, 1047, 1662, 1041, + 1661, 1039, 1675, 1031 + ], + [109.4, 17.7, 659, 539, 655, 533, 599, 564, 628, 617, 684, 587], + [ + 109.4, 17.1, 1021, 1485, 1008, 1462, 1005, 1464, 988, 1435, 967, 1447, + 985, 1479, 945, 1501, 957, 1521 + ], + [ + 109.7, 9.1, 1505, 787, 1524, 820, 1550, 806, 1546, 798, 1553, 794, 1539, + 770, 1530, 775, 1532, 777, 1523, 782, 1521, 778 + ], + [109.7, 17.4, -63, 591, -43, 580, -58, 554, -102, 578, -96, 601, -67, 585], + [ + 109.8, 14.6, 1134, 1731, 1148, 1756, 1185, 1736, 1200, 1763, 1228, 1747, + 1199, 1695 + ], + [110, 21.9, 219, 470, 247, 455, 234, 432, 207, 448], + [ + 110, 2.7, 1021, -643, 1065, -564, 1090, -578, 1107, -580, 1104, -586, + 1116, -592, 1102, -625, 1087, -674, 1037, -646, 1034, -651 + ], + [110.3, 20.7, 602, 1049, 645, 1025, 631, 999, 578, 1029, 592, 1054], + [ + 110.3, 13.1, -432, -346, -417, -354, -428, -374, -416, -380, -421, -388, + -418, -390, -432, -415, -460, -399, -463, -395, -438, -348, -435, -346 + ], + [ + 110.5, 13.1, 1058, 651, 1044, 624, 1072, 609, 1057, 582, 985, 622, 1015, + 675 + ], + [ + 110.5, 18, 985, 1092, 993, 1107, 990, 1109, 1003, 1133, 1042, 1112, 1013, + 1059, 977, 1079 + ], + [ + 110.6, 11.3, -1124, 906, -1107, 897, -1119, 876, -1145, 890, -1134, 907, + -1131, 905, -1128, 908, -1132, 911, -1115, 937, -1109, 933 + ], + [110.8, 11, 994, 90, 982, 69, 954, 85, 982, 137, 1007, 124, 989, 92], + [ + 110.8, 7.9, 1873, 796, 1849, 783, 1836, 790, 1846, 808, 1847, 807, 1881, + 824, 1894, 817, 1884, 800 + ], + [110.9, 12.5, 1144, 750, 1132, 728, 1105, 743, 1117, 765], + [111.1, 15.8, 1179, 92, 1190, 112, 1221, 94, 1210, 75], + [111.3, 18.3, 312, -73, 303, -88, 290, -81, 298, -66], + [ + 111.6, 17.7, -251, 1646, -261, 1629, -200, 1596, -191, 1613, -178, 1605, + -187, 1589, -181, 1585, -184, 1579, -183, 1578, -192, 1565, -272, 1610, + -281, 1593, -294, 1601, -265, 1654 + ], + [ + 112.2, 21.9, 409, 1643, 394, 1615, 399, 1613, 385, 1587, 365, 1598, 367, + 1601, 345, 1613, 357, 1635, 358, 1634, 359, 1636, 385, 1621, 400, 1648 + ], + [ + 112.4, 7.9, -530, 2246, -526, 2244, -523, 2249, -472, 2221, -480, 2206, + -530, 2233, -529, 2235, -538, 2240, -551, 2216, -533, 2207, -542, 2191, + -566, 2204, -561, 2214, -568, 2218, -561, 2230, -560, 2233, -562, 2234, + -549, 2257 + ], + [ + 112.5, 8.5, 580, -485, 574, -497, 581, -500, 582, -498, 588, -502, 583, + -511, 573, -506, 570, -513, 549, -501, 548, -500, 560, -478, 565, -479, + 569, -477 + ], + [ + 112.8, 5.5, -1332, 359, -1351, 370, -1337, 395, -1363, 409, -1364, 421, + -1358, 433, -1307, 405 + ], + [112.8, 24.1, 342, 1792, 372, 1844, 418, 1818, 388, 1766], + [ + 112.9, 15.5, 2077, 1177, 2071, 1167, 2048, 1179, 2052, 1188, 2053, 1187, + 2054, 1190 + ], + [ + 113, 15.8, 245, 1065, 237, 1070, 222, 1044, 189, 1062, 197, 1076, 199, + 1075, 208, 1091, 212, 1088, 225, 1112, 260, 1092 + ], + [113.7, 12.2, 149, -444, 139, -462, 117, -448, 126, -432], + [ + 113.9, 21.3, 215, 47, 225, 64, 228, 62, 238, 80, 228, 85, 237, 102, 295, + 70, 266, 18 + ], + [114, 14.9, 1602, 1325, 1608, 1322, 1593, 1295, 1576, 1304, 1591, 1331], + [ + 114, 11.3, 1021, 310, 994, 261, 979, 270, 982, 276, 976, 279, 996, 316, + 995, 316, 998, 322 + ], + [ + 114.3, 15.5, -213, 762, -206, 758, -208, 753, -182, 738, -193, 719, -226, + 737 + ], + [ + 114.6, 13.1, -377, -287, -384, -300, -378, -303, -400, -343, -400, -341, + -426, -328, -397, -276 + ], + [ + 114.8, 18.3, 41, 1484, 26, 1458, -13, 1480, -28, 1453, -53, 1467, -24, + 1520 + ], + [114.9, 12.8, 773, -15, 744, -68, 722, -55, 751, -3], + [115.2, 20.1, 362, 673, 347, 647, 359, 640, 345, 614, 293, 642, 322, 695], + [115.2, 19.5, 708, 933, 721, 926, 693, 876, 686, 880, 700, 905, 694, 909], + [ + 115.3, 2.1, 1076, -1154, 1082, -1157, 1087, -1149, 1101, -1157, 1092, + -1171, 1096, -1173, 1089, -1186, 1080, -1181, 1081, -1178, 1075, -1174, + 1070, -1182, 1056, -1175, 1065, -1161, 1061, -1158, 1068, -1146, 1078, + -1151 + ], + [115.5, 11.6, -509, 838, -496, 831, -511, 804, -531, 815, -516, 842], + [115.5, 16.5, 718, 91, 709, 76, 689, 88, 696, 100, 698, 99, 700, 101], + [115.7, 14.6, -85, 54, -79, 50, -93, 24, -111, 34, -97, 60], + [ + 116.1, 7.9, -671, 1141, -686, 1114, -673, 1107, -681, 1093, -715, 1111, + -692, 1151 + ], + [ + 116.4, 14.3, 1319, 1779, 1311, 1764, 1303, 1769, 1300, 1764, 1274, 1778, + 1288, 1804, 1319, 1787, 1315, 1781 + ], + [ + 116.4, 11.6, 1277, 749, 1281, 747, 1291, 765, 1284, 736, 1281, 731, 1278, + 732, 1270, 737 + ], + [ + 116.4, 11.6, 1291, 765, 1281, 747, 1247, 766, 1268, 805, 1313, 782, 1301, + 761, 1292, 767 + ], + [ + 116.5, 16.8, 968, 1605, 953, 1579, 920, 1597, 905, 1571, 879, 1586, 894, + 1612, 910, 1603, 925, 1629 + ], + [ + 116.7, 19.2, 636, 1574, 658, 1562, 660, 1564, 665, 1561, 649, 1532, 617, + 1549, 632, 1576 + ], + [ + 116.7, 13.4, -401, 1096, -361, 1073, -363, 1070, -357, 1066, -368, 1047, + -361, 1043, -378, 1013, -418, 1035, -403, 1061, -416, 1069 + ], + [ + 117, 16.5, 838, 1873, 809, 1819, 803, 1822, 818, 1849, 792, 1863, 806, + 1890 + ], + [ + 117.1, 8.5, 937, -122, 922, -149, 916, -146, 899, -144, 891, -137, 889, + -131, 882, -127, 885, -121, 879, -117, 888, -100, 895, -104, 896, -101, + 902, -103, 900, -107, 901, -107, 904, -102, 932, -117, 931, -119 + ], + [ + 117.1, 3, -1234, 1448, -1231, 1435, -1233, 1431, -1230, 1420, -1227, 1418, + -1223, 1405, -1211, 1398, -1196, 1402, -1193, 1392, -1196, 1391, -1195, + 1388, -1199, 1387, -1198, 1383, -1213, 1378, -1232, 1388, -1235, 1383, + -1326, 1434, -1305, 1467, -1293, 1480 + ], + [ + 117.2, 18.6, 621, 858, 618, 852, 640, 840, 630, 822, 614, 831, 610, 825, + 603, 829, 606, 835, 582, 848, 595, 872 + ], + [117.3, 4.3, -1363, 304, -1393, 321, -1379, 347, -1348, 331], + [117.3, 19.2, 136, 1543, 166, 1596, 192, 1582, 165, 1527], + [117.4, 19.5, 522, 580, 495, 531, 473, 543, 491, 575, 487, 577, 496, 594], + [ + 117.4, 11.9, 1415, 271, 1437, 259, 1423, 233, 1397, 248, 1400, 254, 1398, + 260, 1401, 266, 1406, 269, 1412, 266 + ], + [ + 117.4, 12.8, 1259, 538, 1263, 535, 1264, 537, 1282, 527, 1269, 504, 1251, + 514, 1254, 518, 1249, 521 + ], + [ + 117.5, 13.1, 1935, 946, 1928, 933, 1918, 938, 1921, 943, 1912, 948, 1906, + 940, 1908, 939, 1905, 935, 1886, 946, 1893, 957, 1892, 957, 1893, 959, + 1885, 963, 1882, 958, 1871, 964, 1886, 990, 1896, 984, 1892, 977, 1901, + 972, 1907, 979, 1905, 980, 1909, 988, 1929, 977, 1924, 970, 1923, 971, + 1919, 962, 1928, 957, 1932, 965, 1943, 959 + ], + [ + 117.7, 11.6, 338, -330, 326, -352, 310, -343, 306, -350, 300, -347, 295, + -356, 281, -349, 302, -312, 304, -311 + ], + [ + 117.9, 18, 1707, 1660, 1680, 1613, 1674, 1615, 1673, 1613, 1667, 1616, + 1674, 1628, 1675, 1639, 1665, 1645, 1673, 1659, 1684, 1654, 1693, 1671, + 1699, 1668, 1698, 1666 + ], + [118, 11.6, 1518, 1030, 1532, 1023, 1517, 996, 1503, 1003], + [ + 118.3, 11.9, 1006, 115, 1024, 107, 1025, 108, 1037, 102, 1031, 90, 1027, + 92, 1018, 75, 1015, 77, 1012, 75, 1007, 78, 1013, 84, 1013, 86, 1010, 87, + 1008, 86, 1003, 88, 1009, 96, 1004, 98, 1003, 96, 999, 99, 1005, 105, + 1005, 106, 1001, 108 + ], + [ + 118.3, 18.9, 1915, 1447, 1904, 1427, 1891, 1434, 1907, 1463, 1916, 1458, + 1911, 1449 + ], + [ + 118.4, 14.3, 1268, 1349, 1254, 1322, 1255, 1322, 1252, 1315, 1253, 1314, + 1243, 1294, 1204, 1315, 1234, 1368 + ], + [ + 118.4, 14.3, 1130, 792, 1111, 758, 1102, 763, 1091, 745, 1081, 750, 1092, + 770, 1084, 775, 1082, 771, 1072, 776, 1092, 813 + ], + [118.4, 18.6, 978, 1204, 963, 1177, 945, 1187, 960, 1214], + [118.6, 14.6, 885, 489, 848, 423, 776, 463, 813, 529], + [ + 118.9, 15.5, 1121, 1429, 1107, 1403, 1117, 1398, 1102, 1372, 1087, 1380, + 1099, 1403, 1094, 1406, 1092, 1403, 1071, 1415, 1089, 1448 + ], + [ + 118.9, 2.4, -1859, -409, -1847, -416, -1849, -430, -1891, -408, -1883, + -357, -1880, -356, -1841, -377, -1843, -390, -1847, -393, -1854, -400 + ], + [ + 119, 11, 1411, 999, 1432, 987, 1421, 969, 1413, 966, 1398, 939, 1360, 960, + 1358, 966, 1370, 987, 1374, 989, 1385, 983, 1399, 987, 1405, 998 + ], + [ + 119.2, 23.5, 174, 268, 194, 305, 233, 283, 204, 232, 190, 240, 193, 245, + 192, 246, 193, 249, 191, 250, 192, 253, 176, 261, 179, 266 + ], + [ + 119.5, 21.9, -141, 2504, -170, 2451, -183, 2458, -180, 2464, -175, 2462, + -168, 2474, -194, 2489, -182, 2511, -180, 2510, -179, 2513, -172, 2509, + -168, 2517, -165, 2515, -164, 2517 + ], + [ + 119.6, 11.6, -431, 56, -441, 38, -504, 74, -505, 72, -510, 75, -481, 128, + -406, 86, -416, 67, -423, 71 + ], + [119.7, 18.9, 556, 713, 541, 686, 504, 707, 522, 740, 548, 726, 544, 719], + [ + 119.8, 16.8, -24, 300, -23, 301, -32, 306, -18, 333, -10, 328, -13, 323, + -3, 318, -16, 295 + ], + [ + 119.8, 1.8, 2486, -10, 2487, -7, 2545, -38, 2544, -40, 2546, -41, 2544, + -44, 2569, -52, 2567, -57, 2587, -63, 2577, -105, 2478, -81, 2464, -39, + 2458, -28, 2457, -20, 2461, -12, 2468, -6, 2477, -5 + ], + [ + 119.8, 17.4, -18, 532, 7, 578, 13, 574, 16, 579, 31, 571, 28, 566, 33, + 564, 8, 518 + ], + [ + 119.9, 14.6, -256, 605, -279, 618, -278, 621, -284, 624, -283, 626, -287, + 628, -288, 627, -293, 630, -279, 656, -240, 634 + ], + [ + 120.3, 20.1, 630, 1792, 616, 1766, 642, 1752, 629, 1729, 577, 1758, 589, + 1781, 610, 1769, 625, 1795 + ], + [120.3, 18.9, 874, 886, 892, 919, 921, 903, 895, 857, 867, 873], + [ + 120.9, 14, 1441, 1563, 1465, 1605, 1480, 1597, 1484, 1604, 1489, 1601, + 1488, 1598, 1495, 1594, 1471, 1550, 1462, 1554, 1464, 1558, 1453, 1565, + 1449, 1558 + ], + [ + 121.9, 8.8, 671, -269, 697, -284, 701, -278, 714, -285, 700, -311, 660, + -289 + ], + [121.9, 2.1, 2231, -851, 2360, -884, 2345, -943, 2216, -910], + [121.9, 19.5, 561, 982, 607, 956, 592, 930, 526, 966, 540, 993], + [ + 121.9, 11, 1309, 1006, 1319, 1022, 1308, 1028, 1319, 1049, 1357, 1029, + 1328, 976, 1301, 991 + ], + [ + 122.2, 3.4, 1232, -269, 1226, -279, 1232, -282, 1233, -280, 1251, -291, + 1252, -290, 1255, -291, 1253, -293, 1257, -295, 1250, -308, 1246, -306, + 1245, -307, 1235, -301, 1233, -305, 1230, -303, 1219, -324, 1211, -324, + 1202, -319, 1203, -317, 1197, -314, 1225, -265 + ], + [ + 122.5, 16.5, 6, 1378, -5, 1357, -56, 1385, -48, 1398, -47, 1397, -42, 1405 + ], + [122.5, 18.9, 554, 1017, 540, 993, 521, 1004, 534, 1028], + [122.8, 19.2, 607, 1687, 618, 1708, 631, 1701, 620, 1680], + [122.9, 11, -511, 1087, -496, 1113, -470, 1098, -484, 1072], + [123.1, 18, -14, 743, 1, 770, 21, 759, 6, 732], + [ + 123.1, 11.6, -495, 864, -508, 841, -514, 844, -513, 846, -520, 851, -509, + 871 + ], + [ + 123.2, 15.5, 1142, 243, 1127, 216, 1146, 205, 1132, 179, 1073, 212, 1102, + 265 + ], + [123.4, 10.7, -23, -706, -30, -719, -48, -709, -41, -696], + [123.6, 18.3, 595, 373, 624, 425, 651, 409, 622, 357], + [123.7, 20.7, 162, 1780, 132, 1727, 101, 1744, 131, 1797], + [ + 123.7, 17.4, 760, 1915, 745, 1888, 764, 1878, 750, 1852, 717, 1870, 746, + 1923 + ], + [123.7, 18.9, 526, 1307, 496, 1254, 463, 1272, 493, 1325], + [124.1, 21.3, 462, 549, 427, 569, 442, 595, 474, 577, 470, 571, 473, 569], + [124.1, 13.1, -75, -130, -55, -142, -67, -164, -107, -141, -95, -119], + [124.1, 11.3, 345, -792, 338, -805, 310, -790, 317, -777], + [124.5, 11.9, 985, 168, 959, 183, 983, 226, 1016, 208, 992, 164], + [ + 125, 14.3, 1229, 1448, 1216, 1424, 1188, 1438, 1192, 1444, 1201, 1439, + 1215, 1465, 1233, 1455 + ], + [125, 11.9, -458, -220, -447, -200, -430, -209, -441, -230], + [125, 17.1, -68, 538, -80, 515, -98, 525, -113, 528, -105, 559], + [ + 125.1, 12.2, 1318, 1179, 1327, 1174, 1334, 1187, 1388, 1158, 1373, 1132, + 1294, 1176, 1301, 1188 + ], + [ + 125.3, 12.2, -427, -438, -443, -467, -456, -459, -469, -482, -502, -464, + -473, -413 + ], + [ + 125.4, 13.1, 1497, 1288, 1475, 1300, 1471, 1293, 1465, 1296, 1468, 1302, + 1461, 1305, 1471, 1324, 1506, 1304 + ], + [ + 125.6, 16.2, 33, 946, 15, 914, 23, 910, 11, 889, -19, 905, -10, 921, -16, + 924, -2, 965 + ], + [125.6, 24.4, 237, 2430, 273, 2410, 273, 2394, 231, 2417], + [ + 125.6, 25, 116, 2178, 107, 2162, 102, 2165, 99, 2160, 100, 2159, 99, 2156, + 97, 2157, 85, 2135, 75, 2141, 87, 2163, 85, 2163, 87, 2166, 88, 2165, 91, + 2171, 86, 2175, 94, 2190, 97, 2188, 98, 2190, 113, 2181, 113, 2180 + ], + [ + 125.8, 5.2, 1647, 495, 1732, 448, 1727, 439, 1722, 442, 1721, 439, 1731, + 434, 1720, 413, 1710, 419, 1708, 416, 1713, 414, 1708, 405, 1608, 460, + 1613, 469, 1617, 467, 1618, 470, 1609, 475, 1620, 495, 1629, 490, 1631, + 492, 1627, 494, 1631, 503 + ], + [ + 126.6, 7.9, 2175, 1299, 2184, 1295, 2167, 1264, 2156, 1270, 2155, 1268, + 2151, 1271, 2170, 1305, 2174, 1303, 2173, 1301 + ], + [ + 126.8, 26.2, 77, 2338, 76, 2336, 78, 2334, 69, 2318, 43, 2333, 54, 2355, + 69, 2347, 67, 2343 + ], + [ + 126.8, 18.6, 495, 1051, 512, 1042, 498, 1017, 492, 1020, 477, 993, 471, + 996, 486, 1023, 481, 1026 + ], + [127.4, 18.3, 42, 657, 28, 630, 61, 612, 46, 586, -7, 616, 22, 668], + [ + 127.4, 14.9, 1108, 373, 1122, 400, 1131, 395, 1128, 390, 1139, 383, 1128, + 362 + ], + [127.7, 22.6, 640, 1835, 634, 1825, 591, 1849, 606, 1875, 649, 1851], + [127.7, 9.8, -741, -471, -733, -457, -714, -468, -721, -482], + [ + 127.9, 18, 590, 784, 597, 781, 592, 772, 605, 765, 595, 747, 542, 776, + 553, 797, 567, 789, 571, 795 + ], + [ + 128, 15.2, 196, 1183, 154, 1206, 169, 1232, 178, 1228, 176, 1224, 203, + 1209, 205, 1212, 210, 1210 + ], + [ + 128, 20.4, 684, 1392, 673, 1372, 684, 1366, 673, 1345, 653, 1356, 652, + 1355, 650, 1356, 649, 1354, 613, 1374, 614, 1376, 612, 1377, 636, 1421, + 638, 1420, 639, 1422, 675, 1402, 674, 1400, 676, 1399, 675, 1397 + ], + [ + 128.3, 14.9, -128, 965, -123, 975, -120, 973, -100, 1006, -104, 1008, -98, + 1019, -43, 989, -73, 935 + ], + [ + 128.4, 12.8, 1234, 1006, 1247, 999, 1232, 972, 1252, 961, 1237, 935, 1178, + 968, 1200, 1008, 1226, 993 + ], + [ + 128.6, 16.8, -102, 706, -126, 712, -126, 716, -133, 720, -132, 722, -135, + 724, -139, 716, -155, 725, -138, 756, -96, 733 + ], + [ + 128.6, 18, -18, 471, -34, 479, -40, 469, -24, 461, -30, 450, -56, 465, + -28, 516, -1, 501 + ], + [ + 128.7, 12.2, -707, 432, -736, 379, -782, 404, -770, 425, -779, 430, -778, + 433, -798, 444, -782, 473 + ], + [ + 128.8, 20.1, 597, 1080, 581, 1051, 588, 1048, 578, 1029, 548, 1045, 574, + 1093 + ], + [ + 128.9, 17.1, -11, 727, -6, 736, 5, 730, 20, 758, 34, 751, 5, 699, -22, + 713, -13, 729 + ], + [ + 128.9, 11, 1570, 967, 1543, 981, 1558, 1008, 1582, 995, 1577, 987, 1580, + 985 + ], + [ + 128.9, 18, 1713, 1570, 1707, 1558, 1718, 1552, 1705, 1527, 1693, 1533, + 1692, 1539, 1690, 1539, 1679, 1519, 1668, 1525, 1698, 1578 + ], + [ + 129.2, 20.7, 722, 1289, 707, 1262, 681, 1277, 667, 1251, 642, 1264, 643, + 1266, 641, 1267, 651, 1286, 632, 1297, 649, 1329 + ], + [ + 129.5, 11.3, 964, 341, 972, 336, 943, 283, 917, 298, 923, 310, 918, 313, + 926, 327, 905, 339, 903, 337, 893, 342, 911, 361, 915, 368 + ], + [ + 129.6, 13.4, 1199, 1056, 1190, 1061, 1186, 1054, 1167, 1064, 1181, 1091, + 1211, 1075 + ], + [ + 129.7, 21.9, 437, 511, 426, 491, 416, 489, 404, 495, 404, 497, 407, 502, + 393, 509, 401, 523, 426, 508, 437, 527, 444, 524 + ], + [ + 129.8, 3, 2505, -107, 2509, -135, 2526, -139, 2522, -152, 2498, -145, + 2496, -143, 2492, -144, 2486, -105, 2489, -104, 2489, -102 + ], + [ + 129.8, 3, 2522, -152, 2526, -139, 2509, -135, 2505, -107, 2511, -110, + 2511, -108, 2573, -125, 2567, -148, 2538, -140, 2534, -155 + ], + [130, 5.2, 58, -189, 56, -192, 58, -193, 53, -203, 10, -180, 17, -167], + [130.4, 13.1, 1301, 1331, 1286, 1305, 1271, 1313, 1285, 1340], + [130.6, 11.6, 1569, 1090, 1541, 1039, 1438, 1096, 1467, 1149, 1570, 1092], + [ + 130.7, 4, -990, 1383, -988, 1385, -968, 1374, -981, 1350, -1041, 1383, + -1014, 1433, -1000, 1426, -1017, 1396, -1007, 1392, -1005, 1394, -1002, + 1393, -1000, 1391, -1000, 1388, -997, 1385, -990, 1382 + ], + [ + 130.8, 12.5, 1394, 1447, 1412, 1437, 1406, 1426, 1395, 1431, 1387, 1430, + 1380, 1426, 1374, 1417, 1337, 1437, 1349, 1458, 1378, 1441, 1396, 1473, + 1406, 1468 + ], + [ + 130.8, 12.5, 1009, 462, 1035, 448, 1020, 422, 980, 444, 993, 467, 998, + 465, 999, 467 + ], + [ + 130.8, 19.2, 703, 1565, 691, 1543, 677, 1551, 664, 1529, 651, 1536, 665, + 1561, 660, 1564, 658, 1562, 636, 1574, 643, 1587, 648, 1584, 653, 1593 + ], + [131, 12.2, 1287, 977, 1276, 956, 1235, 978, 1247, 999], + [ + 131.3, 14.3, -213, 887, -227, 861, -221, 857, -235, 832, -301, 868, -287, + 894, -297, 899, -282, 925 + ], + [ + 131.3, 6.4, -921, 1224, -914, 1221, -911, 1224, -893, 1212, -889, 1218, + -885, 1217, -880, 1225, -865, 1217, -867, 1214, -860, 1210, -874, 1184, + -927, 1213 + ], + [131.3, 14.3, -221, 857, -227, 861, -213, 887, -206, 883], + [ + 131.4, 11.6, 1057, 582, 1072, 609, 1044, 624, 1058, 651, 1126, 613, 1097, + 560 + ], + [ + 131.4, 18.9, 938, 1226, 912, 1240, 915, 1245, 899, 1254, 910, 1273, 952, + 1250 + ], + [131.4, 13.7, -436, 376, -446, 358, -466, 369, -456, 387], + [131.6, 11.3, -539, 232, -503, 211, -555, 118, -592, 138], + [ + 131.7, 9.1, -638, 1158, -632, 1169, -634, 1170, -632, 1173, -630, 1172, + -627, 1179, -628, 1180, -626, 1183, -625, 1182, -620, 1191, -611, 1185, + -602, 1201, -604, 1202, -602, 1206, -582, 1195, -588, 1182, -581, 1178, + -580, 1180, -568, 1173, -588, 1136, -591, 1135, -619, 1151, -621, 1148 + ], + [ + 132, 11.6, 2144, 1296, 2098, 1322, 2091, 1308, 2068, 1321, 2090, 1361, + 2166, 1319, 2151, 1292 + ], + [ + 132, 6.4, -827, 1269, -854, 1284, -843, 1304, -849, 1308, -835, 1333, + -827, 1329, -822, 1319, -819, 1320, -814, 1308, -815, 1306, -814, 1302, + -817, 1300, -814, 1291 + ], + [132, 12.8, 1594, 1134, 1580, 1111, 1567, 1118, 1580, 1142], + [ + 132.6, 12.2, 1056, 675, 1070, 699, 1098, 684, 1093, 676, 1090, 677, 1083, + 664, 1079, 666, 1077, 663 + ], + [ + 132.8, 17.1, -48, 527, -62, 502, -52, 496, -66, 470, -119, 500, -113, 528, + -98, 525, -80, 515, -68, 538 + ], + [ + 133.5, 14.3, 1093, 1641, 1078, 1615, 1072, 1618, 1073, 1621, 1066, 1625, + 1065, 1622, 1051, 1630, 1048, 1625, 1022, 1639, 1039, 1670 + ], + [ + 133.5, 22.9, 274, 439, 273, 437, 277, 431, 276, 429, 280, 427, 289, 418, + 300, 411, 299, 408, 302, 407, 280, 368, 231, 395, 245, 421, 256, 415, 270, + 441 + ], + [ + 133.5, 17.7, 691, 1663, 715, 1650, 702, 1627, 706, 1625, 691, 1599, 687, + 1601, 699, 1624, 687, 1630, 689, 1634, 672, 1644, 682, 1661, 688, 1658 + ], + [ + 133.6, 13.1, 939, 443, 918, 404, 912, 402, 908, 395, 875, 413, 874, 416, + 879, 424, 876, 425, 893, 455, 896, 454, 900, 461, 903, 463 + ], + [ + 133.7, 7.6, -722, 1263, -748, 1217, -802, 1247, -802, 1250, -780, 1291, + -775, 1289, -776, 1287, -763, 1279, -760, 1280, -756, 1288, -747, 1283, + -746, 1285, -743, 1283, -744, 1281, -738, 1278, -737, 1280, -733, 1278, + -734, 1276, -722, 1269, -725, 1265 + ], + [ + 133.8, 18.6, 1763, 1758, 1737, 1773, 1751, 1797, 1758, 1794, 1760, 1796, + 1766, 1792, 1775, 1807, 1787, 1800 + ], + [ + 134.1, 2.4, 2093, -1458, 2086, -1491, 2088, -1491, 2090, -1509, 2084, + -1510, 2083, -1511, 2081, -1512, 2080, -1517, 2068, -1518, 2070, -1513, + 2036, -1517, 2041, -1497, 2045, -1496, 2053, -1461, 2082, -1458, 2083, + -1455, 2094, -1454 + ], + [134.4, 22.9, 649, 1977, 619, 1924, 563, 1955, 593, 2008], + [ + 134.4, 12.5, 1287, 520, 1306, 511, 1309, 500, 1298, 481, 1292, 479, 1290, + 482, 1280, 488, 1279, 489, 1285, 500, 1279, 503, 1279, 505, 1282, 515, + 1282, 517 + ], + [134.5, 11, -653, 454, -661, 441, -707, 466, -678, 519, -632, 493], + [ + 134.6, 11.6, 1176, 580, 1161, 552, 1166, 549, 1161, 541, 1156, 544, 1152, + 537, 1127, 551, 1139, 572, 1143, 569, 1155, 592 + ], + [134.6, 10.4, -378, 2077, -407, 2025, -494, 2073, -465, 2126], + [134.7, 16.2, 195, 1276, 228, 1251, 216, 1228, 180, 1248], + [134.7, 11, -78, -809, -81, -808, -72, -791, -69, -793], + [134.7, 11, -69, -793, -137, -755, -108, -704, 4, -766, -24, -818], + [ + 135.3, 17.4, 798, 1700, 835, 1679, 821, 1653, 787, 1671, 775, 1650, 742, + 1668, 755, 1691, 760, 1688, 756, 1681, 764, 1677, 782, 1709 + ], + [ + 136.2, 22.9, 306, 1954, 301, 1913, 295, 1908, 228, 1945, 242, 1972, 280, + 1951, 287, 1965 + ], + [ + 136.2, 21, 636, 1953, 649, 1977, 677, 1961, 659, 1929, 641, 1939, 646, + 1947 + ], + [ + 136.2, 12.2, 82, -579, 83, -577, 86, -578, 88, -573, 83, -571, 86, -566, + 73, -559, 75, -552, 82, -546, 91, -550, 93, -547, 119, -561, 103, -589, + 94, -584, 93, -585, 97, -587, 100, -595, 86, -593, 80, -587 + ], + [136.6, 7.6, -576, 2409, -549, 2394, -525, 2376, -532, 2365, -584, 2394], + [ + 136.6, 23.8, 425, 2524, 427, 2523, 415, 2502, 411, 2504, 406, 2495, 391, + 2503, 402, 2524, 406, 2522, 409, 2527, 413, 2525, 415, 2530 + ], + [ + 137, 11.6, -1001, 964, -1030, 911, -1058, 926, -1056, 930, -1103, 955, + -1102, 959, -1076, 1005 + ], + [137.2, 11.3, -571, -180, -551, -191, -565, -217, -585, -206], + [ + 137.2, 13.4, -152, -60, -158, -72, -156, -73, -174, -105, -205, -87, -200, + -54, -195, -55, -194, -48, -168, -51 + ], + [137.5, 10.1, -594, -503, -565, -451, -538, -466, -567, -519], + [137.6, 20.7, 217, 1640, 213, 1630, 164, 1657, 169, 1666], + [138, 19.8, 393, 1520, 425, 1502, 413, 1481, 381, 1499], + [139, 15.2, 197, -107, 185, -129, 164, -118, 177, -96], + [ + 139.1, 11.9, -18, -404, -25, -416, -28, -414, -31, -418, -46, -411, -46, + -410, -53, -406, -51, -401, -55, -399, -48, -387, -45, -389, -44, -387, + -21, -400, -22, -402 + ], + [139.3, 18.9, 663, 869, 651, 847, 640, 853, 637, 849, 595, 872, 610, 898], + [ + 139.3, 15.8, 1108, 1347, 1096, 1327, 1093, 1328, 1090, 1323, 1071, 1334, + 1074, 1339, 1073, 1340, 1084, 1360 + ], + [ + 139.3, 11.9, 1204, 630, 1184, 641, 1185, 644, 1180, 646, 1192, 666, 1224, + 649, 1213, 628, 1206, 632, 1205, 629 + ], + [ + 139.6, 19.5, -5, 1684, -17, 1663, -29, 1670, -26, 1675, -31, 1678, -34, + 1673, -43, 1678, -28, 1704, -15, 1696, -18, 1691 + ], + [139.8, 17.1, 1065, 1345, 1046, 1313, 1022, 1327, 1041, 1359], + [139.9, 18.3, 685, 857, 670, 831, 648, 843, 663, 869], + [ + 139.9, 8.8, 1182, -131, 1209, -83, 1211, -84, 1213, -81, 1239, -95, 1210, + -146 + ], + [ + 140.5, 15.2, -148, 1402, -134, 1389, -137, 1383, -168, 1399, -160, 1413, + -156, 1411, -157, 1410 + ], + [141.1, 17.1, 26, 398, 12, 372, -24, 392, -10, 418], + [ + 141.1, 14.9, 891, 1843, 876, 1816, 892, 1807, 880, 1786, 846, 1804, 851, + 1814, 860, 1809, 872, 1832, 863, 1837, 872, 1853 + ], + [ + 141.2, 13.1, 1395, 1556, 1380, 1530, 1412, 1513, 1402, 1496, 1370, 1514, + 1372, 1518, 1353, 1528, 1375, 1567 + ], + [141.2, 19.8, 521, 645, 531, 640, 515, 611, 465, 638, 481, 667], + [ + 141.4, 18.9, 1783, 1693, 1795, 1687, 1790, 1678, 1784, 1681, 1783, 1679, + 1776, 1682, 1776, 1681, 1760, 1690, 1768, 1703, 1783, 1694 + ], + [ + 141.6, 11, 1440, 1060, 1436, 1046, 1426, 1031, 1414, 1024, 1406, 1026, + 1403, 1033, 1404, 1045, 1408, 1057, 1416, 1068, 1426, 1075, 1435, 1076, + 1440, 1071 + ], + [ + 141.7, 13.7, 1281, 1620, 1274, 1607, 1254, 1618, 1263, 1636, 1265, 1636, + 1283, 1625 + ], + [141.7, 18.3, 933, 1013, 964, 1065, 1003, 1043, 974, 990], + [ + 142, 16.8, 13, 1340, 42, 1393, 86, 1369, 76, 1344, 74, 1344, 70, 1346, 64, + 1335, 71, 1329, 66, 1317, 63, 1315, 57, 1315 + ], + [ + 142.3, 11.9, 1259, 715, 1249, 695, 1254, 693, 1251, 687, 1252, 687, 1242, + 667, 1207, 686, 1231, 730 + ], + [142.6, 11.3, 50, -680, -59, -620, -31, -568, 79, -629], + [143, 10.4, 1028, -2, 1005, 10, 1014, 25, 1036, 13], + [143.3, 3.4, 1150, -441, 1189, -463, 1179, -481, 1140, -458], + [ + 143.4, 11, 1404, 1166, 1424, 1155, 1403, 1118, 1375, 1134, 1388, 1158, + 1394, 1154, 1402, 1168 + ], + [144.2, 3.4, 2120, -781, 2156, -790, 2151, -813, 2114, -803], + [144.3, 18.9, 869, 664, 840, 612, 749, 663, 779, 715], + [ + 144.8, 17.4, 1800, 1250, 1817, 1240, 1798, 1206, 1782, 1215, 1775, 1202, + 1755, 1213, 1761, 1224, 1751, 1230, 1772, 1266 + ], + [145.2, 21.6, 523, 323, 537, 346, 559, 334, 575, 362, 613, 341, 584, 289], + [ + 145.4, 13.4, 1039, 193, 1107, 157, 1101, 147, 1108, 143, 1099, 128, 1102, + 126, 1088, 100, 1001, 148, 1029, 199 + ], + [145.4, 11.9, 988, 415, 977, 395, 972, 398, 970, 394, 944, 408, 958, 431], + [ + 145.7, 13.7, 78, -101, 73, -111, 77, -113, 73, -119, 78, -121, 68, -139, + 64, -137, 63, -139, 41, -127, 61, -91 + ], + [ + 146, 17.1, 1015, 1364, 991, 1378, 993, 1383, 984, 1388, 996, 1409, 1029, + 1391 + ], + [ + 146, 14.9, 154, 1151, 141, 1128, 119, 1140, 117, 1137, 84, 1155, 95, 1175, + 99, 1178, 103, 1179 + ], + [146, 14.6, 140, -327, 150, -309, 160, -314, 145, -340, 136, -335], + [146.3, 13.4, 1333, 1467, 1321, 1446, 1287, 1464, 1299, 1486], + [146.3, 18.9, 283, 874, 291, 888, 306, 880, 298, 866], + [146.5, 14.6, 1391, 284, 1362, 232, 1322, 255, 1350, 306], + [ + 146.5, 21, 701, 1322, 713, 1343, 717, 1341, 735, 1372, 814, 1329, 785, + 1276 + ], + [146.9, 17.4, 176, 951, 164, 929, 122, 952, 135, 976, 166, 959, 165, 957], + [147.1, 16.5, 77, 977, 99, 965, 84, 939, 53, 956, 68, 982], + [ + 147.1, 16.8, 157, 1406, 181, 1393, 158, 1350, 121, 1371, 142, 1411, 156, + 1404 + ], + [ + 147.3, 11.3, -465, 1026, -482, 996, -475, 993, -488, 970, -529, 993, -500, + 1045 + ], + [ + 147.3, 13.7, -142, 1250, -144, 1246, -170, 1261, -154, 1290, -130, 1277, + -143, 1251 + ], + [ + 147.5, 20.1, 428, 1563, 443, 1590, 447, 1588, 461, 1614, 581, 1548, 552, + 1495 + ], + [ + 147.8, 16.5, 1116, 309, 1103, 286, 1063, 308, 1086, 350, 1094, 345, 1098, + 352, 1105, 348, 1108, 314 + ], + [ + 147.9, 15.8, 2140, 1142, 2125, 1116, 2128, 1114, 2122, 1103, 2098, 1117, + 2102, 1124, 2091, 1130, 2094, 1135, 2090, 1137, 2090, 1135, 2086, 1137, + 2087, 1138, 2079, 1143, 2071, 1140, 2069, 1137, 2065, 1139, 2062, 1150, + 2077, 1177, 2085, 1175, 2084, 1173 + ], + [ + 148, 25.9, -7, 2334, 25, 2316, 16, 2299, 49, 2281, 31, 2249, -48, 2293, + -21, 2341 + ], + [ + 148.9, 15.8, -83, 916, -90, 903, -93, 905, -104, 885, -106, 877, -111, + 871, -117, 870, -123, 872, -127, 875, -129, 879, -144, 888, -131, 911, + -140, 916, -127, 941, -122, 939, -121, 941, -85, 920 + ], + [ + 149, 19.8, 623, 1518, 636, 1510, 628, 1495, 622, 1498, 607, 1472, 584, + 1484, 602, 1516, 607, 1513, 613, 1523 + ], + [149.4, 9.1, 1615, 1421, 1624, 1437, 1648, 1423, 1639, 1407], + [149.9, 20.1, 213, 1630, 200, 1599, 148, 1628, 164, 1657], + [ + 149.9, 19.5, 579, 1446, 613, 1428, 614, 1425, 596, 1394, 594, 1393, 554, + 1415, 553, 1418, 571, 1449, 573, 1450 + ], + [ + 150.3, 21.3, 461, 1614, 447, 1588, 443, 1590, 428, 1563, 385, 1587, 399, + 1613, 394, 1615, 409, 1643 + ], + [ + 150.3, 23.2, 164, 2050, 135, 1997, 125, 2002, 128, 2007, 109, 2017, 115, + 2028, 117, 2028, 119, 2033, 107, 2038, 117, 2055, 128, 2048, 130, 2053, + 129, 2053, 135, 2063, 153, 2053, 155, 2055 + ], + [150.3, 5.5, 442, 991, 412, 938, 378, 957, 393, 984, 398, 981, 412, 1006], + [150.4, 12.8, 1000, 492, 977, 452, 958, 463, 970, 484, 963, 488, 974, 507], + [ + 150.5, 14.3, 1182, 1552, 1196, 1544, 1183, 1522, 1143, 1544, 1154, 1563, + 1181, 1549 + ], + [150.6, 19.2, 494, 531, 523, 584, 567, 559, 538, 507], + [ + 150.6, 20.1, 393, 1520, 381, 1499, 314, 1536, 316, 1541, 310, 1545, 308, + 1548, 308, 1553, 313, 1561, 318, 1559, 318, 1560, 321, 1560, 331, 1595, + 355, 1582, 354, 1579, 359, 1577, 361, 1579, 411, 1551 + ], + [ + 151.5, 12.2, -368, -32, -347, -42, -344, -37, -311, -55, -339, -108, -389, + -81, -382, -54, -380, -54 + ], + [ + 151.7, 21.3, 761, 1234, 736, 1247, 739, 1251, 723, 1259, 736, 1281, 775, + 1259 + ], + [ + 152.2, 16.5, -164, 681, -121, 657, -128, 645, -124, 643, -140, 616, -143, + 617, -150, 605, -194, 630, -187, 642, -191, 644, -175, 671, -172, 670 + ], + [ + 153.2, 14, 1528, 1395, 1523, 1386, 1548, 1372, 1541, 1359, 1457, 1405, + 1463, 1416, 1458, 1419, 1465, 1430 + ], + [ + 153.6, 19.8, 898, 1276, 874, 1233, 856, 1243, 871, 1270, 862, 1274, 872, + 1291 + ], + [ + 153.9, 5.8, 1134, -243, 1131, -250, 1124, -254, 1117, -252, 1102, -243, + 1100, -245, 1104, -248, 1105, -253, 1101, -255, 1096, -252, 1093, -257, + 1089, -257, 1026, -223, 1051, -180, 1064, -176, 1116, -206, 1119, -214, + 1114, -225, 1130, -235 + ], + [ + 153.9, 12.2, 1393, 258, 1400, 254, 1397, 248, 1423, 233, 1408, 207, 1362, + 232, 1379, 262, 1391, 255 + ], + [ + 154.1, 21, 306, 1648, 301, 1639, 261, 1661, 285, 1706, 313, 1691, 293, + 1655 + ], + [ + 154.2, 24.4, 324, 2428, 372, 2402, 344, 2348, 325, 2358, 325, 2394, 328, + 2394, 327, 2409, 324, 2409 + ], + [154.3, 20.4, 884, 961, 883, 958, 836, 984, 858, 1024, 905, 998], + [ + 154.8, 14, -303, -277, -301, -273, -261, -296, -265, -329, -281, -319, + -279, -316, -286, -312, -282, -305, -310, -289 + ], + [ + 155.2, 23.5, 507, 310, 496, 291, 493, 293, 490, 286, 479, 292, 483, 298, + 456, 313, 467, 332 + ], + [155.4, 14.9, -86, 1352, -105, 1315, -132, 1330, -111, 1366], + [155.7, 17.4, -22, 692, -32, 672, -73, 695, -68, 718], + [ + 155.8, 11.3, 809, 223, 819, 218, 824, 225, 852, 209, 831, 170, 859, 155, + 858, 153, 868, 147, 861, 136, 794, 173, 811, 202, 790, 214, 799, 229 + ], + [ + 155.8, 13.1, -276, -197, -303, -183, -289, -160, -263, -172, -264, -179, + -244, -182, -253, -245, -290, -223 + ], + [ + 155.8, 18.6, 184, 918, 164, 929, 177, 953, 227, 925, 226, 923, 229, 921, + 212, 891, 208, 893, 205, 887, 200, 886, 180, 897, 179, 901, 187, 916 + ], + [ + 155.9, 21.6, 736, 1190, 726, 1172, 715, 1178, 706, 1162, 717, 1156, 707, + 1138, 655, 1167, 657, 1171, 648, 1176, 650, 1180, 630, 1191, 653, 1232, + 659, 1233 + ], + [ + 156.1, 22.9, 493, 253, 506, 276, 513, 273, 527, 299, 575, 273, 567, 258, + 560, 261, 548, 240, 555, 236, 546, 221, 492, 251 + ], + [156.3, 10.4, 1514, 91, 1472, 16, 1454, 26, 1496, 101], + [ + 156.5, 3, -1142, 1470, -1146, 1462, -1127, 1451, -1137, 1432, -1211, 1475, + -1197, 1500, -1208, 1506, -1194, 1533, -1160, 1514, -1174, 1488 + ], + [156.9, 15.2, 1227, 1839, 1212, 1812, 1140, 1852, 1155, 1878], + [ + 157, 10.4, 917, 173, 948, 156, 947, 154, 969, 141, 942, 93, 889, 122, 894, + 132, 897, 130, 914, 160, 911, 162 + ], + [ + 157.8, 20.4, 783, 1005, 798, 1032, 804, 1028, 819, 1055, 837, 1045, 807, + 992 + ], + [ + 158.3, 11.3, 1326, 844, 1338, 837, 1332, 827, 1339, 823, 1326, 801, 1284, + 824, 1296, 846, 1313, 837, 1321, 852, 1318, 854, 1324, 864, 1334, 859 + ], + [ + 158.5, 7.6, -859, 1086, -885, 1100, -856, 1153, -838, 1143, -856, 1110, + -848, 1106 + ], + [158.5, 16.2, 186, 1189, 218, 1171, 203, 1144, 171, 1161], + [ + 158.7, 10.7, 888, 100, 932, 75, 904, 24, 859, 48, 866, 61, 860, 64, 868, + 79, 874, 90, 881, 87 + ], + [159.1, 6.4, -1222, 996, -1236, 971, -1261, 986, -1247, 1010], + [ + 160.3, 19.5, 448, 1437, 444, 1429, 450, 1425, 452, 1429, 496, 1405, 475, + 1366, 430, 1391, 432, 1394, 426, 1397, 422, 1389, 370, 1418, 396, 1465 + ], + [ + 160.3, 10.4, 960, -42, 951, -58, 947, -56, 936, -76, 911, -62, 912, -60, + 906, -58, 903, -63, 882, -52, 890, -39, 886, -37, 892, -26, 932, -48, 944, + -26, 946, -25, 962, -34, 963, -36 + ], + [160.6, 15.2, 33, 1202, 17, 1211, 8, 1196, -16, 1210, -1, 1236, 36, 1215], + [ + 160.9, 14, 1167, 1224, 1263, 1170, 1234, 1118, 1135, 1173, 1146, 1193, + 1140, 1196, 1154, 1220, 1160, 1217, 1164, 1225 + ], + [ + 161.1, 16.8, 270, 1335, 265, 1326, 264, 1327, 249, 1302, 186, 1337, 215, + 1388, 277, 1354, 275, 1349, 277, 1348 + ], + [ + 161.2, 20.4, 281, 1580, 264, 1589, 256, 1573, 246, 1579, 255, 1594, 239, + 1603, 251, 1631, 296, 1606 + ], + [161.5, 13.7, 1408, 1646, 1396, 1623, 1380, 1632, 1394, 1656, 1409, 1648], + [ + 161.7, 15.5, 434, -203, 435, -204, 409, -249, 381, -233, 382, -230, 381, + -226, 376, -228, 374, -223, 367, -225, 360, -201, 367, -199, 366, -192, + 401, -183, 402, -187 + ], + [161.8, 14, -248, 1011, -263, 984, -309, 1010, -294, 1037], + [161.8, 14.9, 1134, 1764, 1120, 1738, 1087, 1756, 1101, 1782], + [ + 161.8, 14.3, 1181, 1091, 1167, 1065, 1145, 1077, 1153, 1092, 1145, 1096, + 1141, 1089, 1119, 1101, 1139, 1139, 1162, 1127, 1159, 1119, 1166, 1115, + 1174, 1129, 1196, 1117 + ], + [ + 161.9, 14.9, 1178, 1399, 1167, 1379, 1163, 1381, 1156, 1368, 1160, 1366, + 1155, 1359, 1118, 1379, 1125, 1393, 1130, 1391, 1145, 1417 + ], + [162.5, 24.4, -66, 2515, -77, 2496, -102, 2510, -91, 2529], + [ + 162.5, 15, 1473, 383, 1496, 371, 1495, 364, 1492, 363, 1491, 359, 1488, + 357, 1486, 352, 1484, 351, 1483, 351, 1481, 348, 1477, 350, 1479, 354, + 1462, 363, 1462, 365, 1465, 369, 1463, 370, 1470, 378, 1471, 382 + ], + [162.9, 21.9, 427, 467, 440, 489, 452, 483, 468, 511, 521, 481, 492, 431], + [ + 163.6, 12.8, 1179, 794, 1187, 809, 1197, 803, 1212, 829, 1236, 816, 1213, + 775 + ], + [ + 164.1, 22.6, 554, 374, 541, 350, 540, 351, 541, 353, 516, 366, 521, 376, + 499, 388, 506, 401 + ], + [ + 164.6, 17.1, 1018, 1265, 1021, 1271, 1038, 1261, 1024, 1234, 983, 1257, + 992, 1272, 1015, 1260 + ], + [164.6, 3.4, 1107, -405, 1116, -389, 1164, -415, 1155, -431], + [ + 164.8, 15.8, -168, 856, -162, 852, -159, 857, -145, 849, -147, 846, -128, + 839, -157, 788, -188, 805, -174, 831, -182, 835, -170, 857 + ], + [ + 165.3, 14, -296, 533, -321, 547, -318, 554, -324, 557, -309, 583, -278, + 566 + ], + [ + 165.8, 25, 17, 2416, -4, 2379, -9, 2382, -13, 2375, -26, 2380, -25, 2382, + -30, 2373, -44, 2381, -14, 2434 + ], + [ + 166.2, 20.1, 950, 1072, 921, 1020, 867, 1049, 876, 1065, 896, 1054, 908, + 1075, 888, 1086, 897, 1102 + ], + [ + 166.8, 11, -26, -684, -30, -691, -79, -664, -70, -648, -63, -652, -60, + -646, -29, -663, -32, -669, -21, -675 + ], + [ + 166.9, 18.9, 881, 908, 885, 905, 874, 886, 859, 895, 853, 884, 826, 900, + 841, 926, 832, 931, 839, 943, 847, 938, 848, 940, 876, 925, 869, 914 + ], + [ + 167.2, 19.2, 163, 867, 170, 863, 172, 869, 196, 856, 187, 840, 180, 844, + 168, 822, 175, 818, 167, 803, 139, 818, 142, 824, 123, 834, 146, 876 + ], + [ + 167.8, 16.5, 238, 1051, 245, 1065, 258, 1057, 271, 1080, 307, 1061, 282, + 1016, 246, 1036, 251, 1044 + ], + [ + 168.2, 12.5, 1371, 1487, 1360, 1469, 1356, 1471, 1337, 1437, 1321, 1446, + 1340, 1480, 1331, 1485, 1341, 1504 + ], + [ + 168.6, 11.9, 1434, 353, 1477, 329, 1468, 313, 1441, 328, 1435, 318, 1419, + 327 + ], + [ + 168.8, 22.3, 419, 1693, 467, 1667, 484, 1696, 488, 1694, 457, 1638, 404, + 1667 + ], + [ + 169.2, 7.3, 1485, 530, 1497, 554, 1537, 532, 1535, 527, 1535, 524, 1532, + 520, 1526, 508 + ], + [ + 169.8, 21.3, 805, 1062, 775, 1010, 772, 1011, 776, 1018, 763, 1025, 759, + 1018, 749, 1023, 753, 1030, 755, 1029, 781, 1076 + ], + [ + 171, 24.4, 352, 2316, 372, 2306, 358, 2278, 356, 2278, 353, 2271, 348, + 2274, 344, 2267, 331, 2274, 335, 2281, 330, 2283, 344, 2311, 345, 2311, + 349, 2318 + ], + [ + 171, 12.2, -406, 368, -413, 355, -400, 348, -416, 319, -431, 328, -437, + 317, -455, 327, -440, 353, -426, 345, -412, 371 + ], + [171.8, 11.6, 800, 82, 828, 133, 852, 119, 823, 68, 799, 81], + [ + 171.9, 2.1, 2247, -698, 2237, -737, 2188, -725, 2187, -728, 2167, -723, + 2169, -715, 2170, -715, 2171, -711, 2169, -710, 2173, -702, 2171, -701, + 2173, -696, 2175, -696, 2176, -692, 2174, -691, 2175, -686, 2177, -687, + 2177, -685, 2176, -685, 2177, -680 + ], + [172.8, 8.2, -273, 11, -287, -14, -314, 1, -328, -25, -339, -19, -311, 32], + [173.2, 11.3, 928, 256, 899, 204, 788, 266, 817, 318], + [ + 173.2, 12.5, 1142, 716, 1157, 743, 1163, 739, 1172, 756, 1190, 746, 1171, + 713, 1153, 723, 1148, 713 + ], + [ + 173.2, 19.8, 649, 1329, 621, 1276, 502, 1342, 509, 1354, 515, 1351, 530, + 1378, 524, 1381, 531, 1394 + ], + [ + 173.7, 6.1, -1170, 1145, -1155, 1136, -1169, 1112, -1163, 1109, -1176, + 1086, -1196, 1097 + ], + [173.7, 18.6, 349, 949, 322, 902, 275, 928, 301, 975], + [ + 174, 22.6, 214, 2017, 189, 1972, 184, 1971, 135, 1997, 164, 2050, 213, + 2023 + ], + [174.6, 17.4, 1003, 855, 980, 813, 941, 835, 964, 876], + [ + 174.8, 18.6, 924, 1353, 962, 1334, 963, 1337, 969, 1333, 967, 1330, 987, + 1320, 961, 1272, 915, 1298, 927, 1320, 919, 1324, 920, 1326, 912, 1331 + ], + [174.9, 16.8, 158, 1015, 150, 1001, 125, 1014, 132, 1029], + [ + 175.2, 11.9, 22, -363, 10, -385, -4, -378, 1, -369, 6, -372, 20, -349, 18, + -347, 26, -331, 37, -337 + ], + [ + 175.3, 15.2, 87, 1097, 119, 1080, 104, 1053, 95, 1058, 80, 1032, 31, 1058, + 57, 1106, 84, 1091 + ], + [ + 176, 13.4, -109, 1152, -101, 1166, -81, 1155, -74, 1169, -68, 1166, -61, + 1177, 16, 1135, 12, 1123, 5, 1127, 2, 1121, 7, 1119, 10, 1114, 10, 1109, + 8, 1104, 0, 1100, -8, 1103, -11, 1098, 1, 1091, -2, 1080, -10, 1084, -11, + 1082, -101, 1132, -100, 1133, -104, 1135, -98, 1146 + ], + [ + 178, 11.9, 1565, 1182, 1566, 1184, 1575, 1180, 1560, 1153, 1580, 1142, + 1566, 1116, 1537, 1131, 1543, 1143, 1483, 1176, 1500, 1206, 1560, 1173 + ], + [ + 178.3, 15.5, 1072, 1548, 1105, 1530, 1081, 1487, 1069, 1493, 1063, 1484, + 1032, 1501, 1037, 1511, 1031, 1514, 1052, 1551, 1059, 1547, 1062, 1554 + ], + [ + 178.4, 17.4, 1054, 1196, 1024, 1143, 985, 1165, 999, 1192, 978, 1204, 993, + 1230 + ], + [ + 178.9, 14, -1110, 821, -1084, 806, -1102, 774, -1142, 795, -1127, 822, + -1114, 814 + ], + [ + 179, 18.3, 439, 1354, 464, 1340, 457, 1329, 432, 1343, 429, 1337, 437, + 1332, 422, 1305, 340, 1351, 336, 1342, 327, 1347, 357, 1400 + ], + [179.5, 20.7, 724, 1439, 707, 1410, 688, 1420, 704, 1450], + [ + 180.1, 21.9, 141, 1812, 170, 1865, 233, 1831, 219, 1804, 209, 1810, 194, + 1783 + ], + [ + 180.4, 21.9, 170, 207, 186, 198, 167, 165, 161, 165, 132, 181, 147, 207, + 148, 207, 153, 216 + ], + [ + 180.5, 25.6, 419, 1893, 411, 1878, 438, 1863, 427, 1844, 378, 1871, 389, + 1890, 393, 1888, 405, 1911, 424, 1901 + ], + [ + 181.8, 16.5, 295, 1162, 290, 1154, 328, 1133, 311, 1102, 327, 1093, 320, + 1081, 280, 1103, 285, 1112, 241, 1136, 243, 1139, 233, 1144, 227, 1134, + 204, 1146, 218, 1171, 228, 1166, 242, 1191 + ], + [ + 182.3, 11, -308, 932, -320, 911, -289, 894, -302, 869, -350, 895, -348, + 898, -361, 905, -351, 920, -353, 921, -340, 951, -333, 952, -314, 942, + -317, 937 + ], + [182.9, 11.3, -124, -784, -133, -804, -156, -791, -146, -772], + [182.9, 23.2, 303, 292, 309, 289, 298, 269, 269, 285, 280, 305], + [ + 183.5, 20.7, 688, 1398, 696, 1394, 695, 1391, 697, 1390, 699, 1393, 709, + 1387, 708, 1384, 713, 1382, 715, 1385, 718, 1383, 716, 1380, 719, 1378, + 720, 1380, 734, 1373, 722, 1352, 708, 1360, 706, 1355, 686, 1366, 689, + 1370, 676, 1377 + ], + [ + 183.6, 20.1, 514, 1487, 521, 1484, 516, 1476, 526, 1470, 512, 1444, 502, + 1450, 497, 1442, 443, 1472, 440, 1467, 413, 1481, 425, 1502, 427, 1501, + 445, 1533, 468, 1520, 465, 1515 + ], + [ + 184.3, 14.9, 1146, 959, 1132, 933, 1105, 948, 1106, 950, 1086, 961, 1102, + 989, 1145, 965, 1147, 962 + ], + [ + 184.4, 12.2, -345, 53, -371, 5, -385, 13, -389, 6, -402, 13, -389, 37, + -397, 41, -387, 58, -385, 57, -377, 71 + ], + [ + 185.6, 5.5, 2059, -966, 2109, -1001, 2042, -1034, 2027, -998, 2031, -997, + 2029, -992, 2032, -991, 2031, -988, 2033, -987, 2033, -986, 2043, -980 + ], + [ + 185.6, 15, -938, 1131, -921, 1162, -913, 1157, -901, 1179, -882, 1169, + -912, 1116 + ], + [ + 185.9, 7.6, -712, 1163, -728, 1135, -785, 1166, -794, 1149, -843, 1176, + -819, 1221 + ], + [ + 186, 16.5, 988, 1435, 1005, 1464, 1008, 1462, 1021, 1485, 1069, 1460, + 1039, 1406 + ], + [186.7, 16.5, 990, 684, 965, 639, 868, 692, 893, 737], + [186.8, 23.2, 247, 2074, 233, 2048, 206, 2063, 220, 2089], + [187.1, 16.8, 1081, 841, 973, 900, 1002, 953, 1110, 894], + [ + 187.9, 20.1, 755, 989, 757, 988, 759, 979, 756, 974, 745, 980, 738, 967, + 742, 965, 739, 960, 731, 957, 710, 969, 707, 977, 710, 983, 721, 977, 728, + 990, 724, 992, 727, 997, 736, 1000 + ], + [ + 188.4, 14, 721, 303, 737, 331, 741, 329, 742, 331, 752, 326, 745, 314, + 754, 309, 765, 329, 756, 334, 764, 347, 796, 329, 767, 277 + ], + [ + 188.5, 17.7, -81, 1550, -80, 1548, -79, 1550, -52, 1536, -61, 1520, -64, + 1521, -66, 1511, -75, 1501, -72, 1500, -82, 1483, -108, 1498, -108, 1499, + -121, 1504, -131, 1512, -132, 1511, -159, 1526, -149, 1542, -148, 1541, + -143, 1554, -136, 1561, -138, 1562, -129, 1578, -103, 1564, -104, 1562, + -90, 1557 + ], + [188.6, 24.4, 402, 368, 373, 316, 354, 327, 383, 380, 403, 369], + [ + 189.6, 21.6, 850, 1218, 833, 1187, 836, 1186, 825, 1165, 821, 1167, 820, + 1166, 773, 1192, 790, 1221, 825, 1202, 838, 1225 + ], + [190, 12.5, -403, -163, -373, -110, -348, -124, -377, -176], + [ + 190.5, 8.5, -196, -882, -210, -908, -219, -903, -206, -879, -219, -871, + -204, -843, -183, -855, -198, -881 + ], + [ + 191, 20.1, 281, 715, 297, 706, 291, 694, 294, 692, 275, 657, 271, 659, + 269, 656, 213, 687, 219, 698, 216, 699, 221, 708, 224, 707, 240, 737 + ], + [191.1, 18.3, 50, 742, 21, 690, 5, 699, 34, 751], + [191.1, 18.3, 42, 678, 71, 730, 110, 708, 82, 656], + [ + 192, 10.1, -526, 1060, -536, 1040, -550, 1047, -568, 1014, -581, 1022, + -567, 1048, -571, 1051, -557, 1077 + ], + [ + 192.1, 14.9, 1183, 1033, 1154, 981, 1128, 996, 1137, 1009, 1084, 1039, + 1094, 1056, 1077, 1066, 1088, 1086 + ], + [ + 192.2, 17.4, 717, 281, 709, 266, 716, 262, 696, 227, 692, 240, 656, 260, + 648, 288, 650, 291, 638, 298, 640, 300, 667, 308 + ], + [193.9, 17.7, 926, 1530, 898, 1545, 902, 1552, 930, 1536], + [ + 193.9, 17.7, 902, 1552, 898, 1545, 926, 1530, 915, 1510, 862, 1539, 877, + 1566 + ], + [ + 193.9, 11, 103, -462, 93, -481, 88, -479, 87, -482, 89, -482, 86, -487, + 62, -474, 66, -467, 65, -466, 72, -453, 74, -454, 77, -448 + ], + [ + 194.2, 3.7, -1573, 552, -1545, 537, -1575, 485, -1681, 542, -1666, 569, + -1588, 526 + ], + [196.1, 20.1, 600, 1621, 577, 1579, 520, 1610, 544, 1652], + [196.6, 22.9, 283, 1824, 236, 1850, 266, 1903, 297, 1885], + [ + 198.2, 9.8, 1324, 530, 1293, 547, 1310, 578, 1312, 577, 1321, 591, 1349, + 575 + ], + [ + 199.4, 12.2, 1303, 1052, 1285, 1020, 1279, 1023, 1275, 1014, 1280, 1011, + 1279, 1009, 1222, 1040, 1233, 1061, 1268, 1072 + ], + [ + 201.2, 15.8, -32, 1275, -2, 1327, 53, 1296, 52, 1294, 57, 1290, 54, 1286, + 56, 1285, 44, 1243, 43, 1244, 43, 1240, 40, 1238, 37, 1239, 36, 1241, 33, + 1239 + ], + [ + 202.1, 12.5, -35, -323, -38, -321, -39, -323, -59, -312, -58, -310, -61, + -308, -50, -289, -35, -298, -37, -301, -29, -305, -32, -310, -29, -312 + ], + [202.5, 17.1, 214, 961, 230, 991, 209, 1002, 219, 1020, 271, 992, 245, 944], + [ + 202.7, 16.5, 1015, 1550, 1013, 1545, 1026, 1538, 1011, 1512, 966, 1537, + 983, 1568 + ], + [ + 202.8, 18.9, 10, 1522, 40, 1576, 69, 1560, 66, 1554, 68, 1553, 69, 1554, + 153, 1508, 146, 1494, 126, 1505, 115, 1485, 133, 1475, 127, 1463, 44, + 1509, 45, 1510, 42, 1512, 39, 1506 + ], + [ + 204, 19.8, 624, 425, 595, 373, 552, 396, 552, 397, 547, 400, 555, 413, + 523, 429, 530, 442, 566, 422, 581, 449 + ], + [204.8, 15.8, 862, 1704, 886, 1748, 954, 1710, 929, 1666], + [ + 205.1, -1.8, -1097, 1371, -1098, 1370, -1094, 1368, -1096, 1365, -1091, + 1363, -1103, 1343, -1110, 1347, -1111, 1346, -1124, 1353, -1132, 1339, + -1151, 1350, -1154, 1344, -1178, 1358, -1172, 1368, -1175, 1370, -1167, + 1384, -1153, 1376, -1139, 1399, -1113, 1384, -1115, 1381 + ], + [ + 205.3, 16.8, 352, 1207, 336, 1177, 312, 1191, 305, 1180, 227, 1223, 245, + 1255, 243, 1256, 254, 1276, 293, 1255, 287, 1243 + ], + [ + 209.1, 13.4, 1233, 1529, 1229, 1532, 1214, 1505, 1183, 1522, 1211, 1572, + 1250, 1549, 1237, 1527 + ], + [209.6, 16.5, -77, 810, -92, 752, -128, 772, -100, 823], + [ + 210.4, 14, 1109, 1723, 1190, 1678, 1160, 1625, 1079, 1670, 1087, 1683, + 1080, 1687, 1095, 1713, 1101, 1709 + ], + [210.6, 11.6, 1672, 1217, 1701, 1201, 1672, 1147, 1642, 1164], + [212.1, 16.5, 1029, 750, 1004, 703, 904, 758, 933, 810, 1032, 755], + [213.4, 22.6, 783, 890, 881, 835, 856, 790, 758, 845], + [ + 213.6, 13.4, -84, 1095, -78, 1091, -77, 1093, -75, 1088, -55, 1077, -49, + 1081, -12, 1061, -15, 1054, -8, 1053, -31, 1009, -36, 1014, -41, 1008, + -80, 1029, -77, 1035, -100, 1047, -103, 1044, -103, 1046, -113, 1051, + -110, 1055, -109, 1054, -105, 1061, -107, 1062, -102, 1064, -91, 1084, + -94, 1089, -93, 1089, -88, 1098, -84, 1096 + ], + [ + 214, 22.9, 566, 1828, 551, 1801, 555, 1799, 550, 1789, 523, 1803, 544, + 1840 + ], + [ + 214, 10.4, -1081, 398, -1143, 431, -1119, 476, -1103, 467, -1102, 461, + -1080, 449, -1073, 452, -1056, 443 + ], + [214.8, 20.7, 381, 628, 414, 610, 400, 584, 345, 614, 359, 640], + [216.7, 13.7, 1196, 1117, 1225, 1101, 1211, 1075, 1181, 1091], + [ + 217.9, 25.6, 282, 2228, 271, 2218, 267, 2221, 254, 2197, 258, 2195, 255, + 2178, 257, 2160, 262, 2147, 270, 2133, 267, 2131, 275, 2125, 273, 2122, + 143, 2194, 205, 2305, 281, 2263 + ], + [221.1, 18.3, 770, 741, 714, 772, 743, 824, 795, 796, 797, 789], + [ + 222.1, 11, -611, 357, -603, 353, -601, 357, -569, 339, -566, 344, -534, + 326, -530, 333, -481, 307, -510, 255, -559, 281, -554, 288, -587, 306, + -583, 311, -616, 329, -614, 333, -622, 337 + ], + [ + 224.6, 17.1, 42, 851, 13, 800, -12, 814, -14, 812, -33, 823, -39, 830, + -39, 837, -29, 877, -27, 881, -23, 883, -17, 883 + ], + [224.9, 19.5, 245, 1789, 270, 1776, 262, 1746, 230, 1763], + [ + 225.9, 20.4, 177, 1681, 148, 1628, 137, 1634, 152, 1660, 117, 1679, 102, + 1653, 95, 1657, 110, 1683, 102, 1687, 117, 1714 + ], + [ + 227.5, 18.9, 396, 1465, 370, 1418, 263, 1477, 271, 1491, 274, 1490, 285, + 1509, 282, 1510, 290, 1524 + ], + [ + 228.3, 17.7, 326, 1325, 320, 1315, 390, 1276, 374, 1247, 309, 1282, 303, + 1272, 263, 1294, 277, 1319, 293, 1310, 307, 1335 + ], + [229.6, 23.5, 538, 1843, 508, 1791, 493, 1798, 523, 1851], + [ + 230.1, 10.7, -272, 827, -299, 779, -316, 789, -317, 787, -363, 812, -358, + 821, -372, 828, -376, 821, -393, 829, -389, 836, -401, 843, -380, 883, + -367, 876, -365, 881, -349, 872, -352, 867, -338, 860, -336, 864, -272, + 829 + ], + [ + 233.5, 22.9, 538, 1752, 524, 1726, 511, 1733, 496, 1707, 489, 1711, 504, + 1737, 477, 1752, 480, 1757, 467, 1765, 479, 1785 + ], + [ + 237.1, 10.7, -154, -934, -155, -927, -152, -921, -145, -921, -122, -933, + -131, -949, -151, -938, -150, -936 + ], + [238, 0, 1309, 1724, 1319, 1741, 1335, 1733, 1325, 1715], + [ + 243.5, 14.9, 2075, 1098, 2073, 1094, 2076, 1092, 2068, 1078, 2045, 1090, + 2053, 1105, 2057, 1103, 2060, 1107 + ], + [ + 244.4, 12.8, 1187, 846, 1178, 830, 1173, 833, 1169, 826, 1147, 838, 1162, + 865, 1174, 857, 1172, 855, 1177, 851 + ], + [ + 245.4, 11.9, 48, -317, 38, -312, 39, -310, 28, -305, 40, -282, 48, -286, + 61, -261, 99, -282, 95, -290, 70, -276, 63, -289, 88, -303, 85, -309, 60, + -295 + ], + [ + 245.7, 14.9, 1545, 1474, 1548, 1473, 1551, 1478, 1594, 1454, 1564, 1402, + 1527, 1423, 1528, 1425, 1524, 1427, 1528, 1438, 1533, 1441, 1538, 1449, + 1539, 1459, 1534, 1463, 1528, 1464, 1521, 1459, 1517, 1452, 1517, 1443, + 1510, 1435, 1506, 1437, 1505, 1435, 1454, 1463, 1483, 1516, 1539, 1485, + 1536, 1479 + ], + [ + 254.4, 19.5, 471, 1245, 593, 1177, 587, 1166, 589, 1165, 573, 1137, 571, + 1138, 565, 1127, 443, 1196, 441, 1194, 424, 1204, 450, 1250, 468, 1239 + ], + [261.8, 7.3, 1520, 437, 1517, 432, 1497, 443, 1518, 481, 1539, 470], + [270.6, 18.3, 14, 801, 42, 851, 155, 787, 125, 734, 21, 792, 23, 795], + [ + 274.9, 10.1, -1080, 396, -1081, 398, -1059, 436, -1020, 416, -1021, 415, + -1009, 407, -1029, 371, -1031, 370 + ], + [ + 275.5, 9.1, -1421, 560, -1380, 538, -1401, 500, -1475, 540, -1475, 539, + -1501, 553, -1478, 594, -1454, 580, -1455, 579 + ], + [ + 277.7, 11.9, 1314, 1140, 1326, 1133, 1327, 1135, 1396, 1098, 1381, 1071, + 1356, 1084, 1341, 1058, 1314, 1073, 1315, 1075, 1274, 1097, 1295, 1134, + 1284, 1140, 1282, 1147, 1286, 1156, 1290, 1157, 1303, 1149, 1304, 1145 + ], + [281, 21.6, 405, 671, 418, 694, 451, 676, 439, 653], + [288.6, 12.5, 886, 335, 876, 320, 832, 345, 861, 398, 915, 368, 911, 361], + [ + 290.2, 23.2, 391, 2050, 406, 2076, 439, 2058, 453, 2085, 473, 2074, 444, + 2021 + ], + [304.2, 13.4, -1026, 512, -973, 484, -994, 446, -998, 446, -1048, 474], + [308.2, 12.2, -1185, 635, -1267, 680, -1245, 721, -1163, 676], + [ + 310.5, 14, 537, 1879, 555, 1911, 550, 1914, 562, 1934, 582, 1924, 567, + 1897, 576, 1892, 572, 1884, 590, 1874, 579, 1855 + ], + [313.6, 12.8, -1112, 758, -1139, 710, -1220, 756, -1194, 801], + [316.7, 8.5, -1391, 654, -1432, 677, -1404, 727, -1359, 702], + [ + 320, 20.1, 639, 1516, 668, 1500, 659, 1484, 652, 1488, 650, 1483, 657, + 1480, 653, 1473, 642, 1479, 628, 1452, 604, 1465, 619, 1492, 625, 1489 + ], + [ + 377.6, 15.2, -32, 58, 74, -1, 46, -52, -66, 10, -65, 13, -83, 23, -72, 42, + -55, 33, -54, 35, -53, 34, -38, 61 + ], + [ + 385.6, 15, -1360, 536, -1368, 541, -1290, 660, -1230, 630, -1230, 628, + -1222, 625, -1220, 627, -1193, 611, -1273, 470, -1366, 522, -1365, 524, + -1369, 527 + ], + [425.5, 14.9, 1153, 1469, 1147, 1472, 1162, 1499, 1168, 1496], + [ + 425.5, 14.9, 1194, 1482, 1174, 1445, 1216, 1424, 1205, 1406, 1132, 1445, + 1147, 1472, 1153, 1469, 1168, 1496 + ], + [427, 18.3, 559, 495, 589, 548, 647, 516, 617, 463], + [435.3, 17.7, 686, 1799, 685, 1797, 658, 1811, 688, 1865, 715, 1850], + [ + 472.4, 24.4, 406, 1952, 366, 1974, 373, 1987, 347, 2001, 354, 2014, 368, + 2007, 383, 2034, 435, 2006, 429, 1994, 436, 1990, 424, 1968, 417, 1972 + ] + ] +} diff --git a/mobile/demo/moments/empire-state.json b/mobile/demo/moments/empire-state.json new file mode 100644 index 000000000..533a38aab --- /dev/null +++ b/mobile/demo/moments/empire-state.json @@ -0,0 +1,21406 @@ +{ + "id": "empire-state", + "title": "Climbers on the Empire State Building", + "place": "Midtown Manhattan, New York", + "lon": -73.98566, + "lat": 40.74844, + "time": { "start": 1789766280000, "end": 1789767780000 }, + "illustrative": true, + "illustrativeNote": "Illustrative reconstruction. The event, aircraft, callsigns, people, chat and posts are fictional; the place, building heights and heliports are real.", + "recommendedSpeed": 30, + "groundMslM": 15, + "subject": { + "lon": -73.98566, + "lat": 40.74844, + "altM": 320, + "label": "Empire State Building", + "roofM": 381, + "antennaM": 443, + "decks": [320, 373] + }, + "stage": { "buildings": "midtown-buildings.json", "highlight": "1015862" }, + "wind": { "fromDeg": 290, "kt": 14 }, + "cameraPath": [ + { + "t": 1789766280000, + "lon": -74.012051, + "lat": 40.716228, + "height": 2575, + "heading": 32, + "pitch": -30 + }, + { + "t": 1789766340000, + "lon": -74.009021, + "lat": 40.725635, + "height": 2048, + "heading": 38, + "pitch": -30 + }, + { + "t": 1789766400000, + "lon": -74.005927, + "lat": 40.734522, + "height": 1642, + "heading": 48, + "pitch": -31 + }, + { + "t": 1789766490000, + "lon": -74.00545, + "lat": 40.742342, + "height": 1445, + "heading": 68, + "pitch": -32 + }, + { + "t": 1789766580000, + "lon": -74.00386, + "lat": 40.750391, + "height": 1312, + "heading": 98, + "pitch": -31 + }, + { + "t": 1789766670000, + "lon": -73.999209, + "lat": 40.756513, + "height": 1218, + "heading": 128, + "pitch": -30 + }, + { + "t": 1789766760000, + "lon": -73.991657, + "lat": 40.75976, + "height": 1129, + "heading": 158, + "pitch": -29 + }, + { + "t": 1789766860000, + "lon": -73.984235, + "lat": 40.758783, + "height": 962, + "heading": 186, + "pitch": -26 + }, + { + "t": 1789766970000, + "lon": -73.975805, + "lat": 40.758061, + "height": 1129, + "heading": 218, + "pitch": -29 + }, + { + "t": 1789767090000, + "lon": -73.967053, + "lat": 40.753051, + "height": 1351, + "heading": 252, + "pitch": -32 + }, + { + "t": 1789767210000, + "lon": -73.964233, + "lat": 40.74313, + "height": 1602, + "heading": 288, + "pitch": -34 + }, + { + "t": 1789767330000, + "lon": -73.97398, + "lat": 40.737038, + "height": 1342, + "heading": 322, + "pitch": -31 + }, + { + "t": 1789767460000, + "lon": -73.983515, + "lat": 40.736798, + "height": 1035, + "heading": 352, + "pitch": -27 + }, + { + "t": 1789767570000, + "lon": -73.992988, + "lat": 40.731238, + "height": 1522, + "heading": 18, + "pitch": -31 + }, + { + "t": 1789767690000, + "lon": -74.006569, + "lat": 40.72649, + "height": 2023, + "heading": 36, + "pitch": -31 + }, + { + "t": 1789767780000, + "lon": -74.018608, + "lat": 40.722418, + "height": 2459, + "heading": 44, + "pitch": -30 + } + ], + "beats": [ + { + "t": 1789766332000, + "title": "First sealed capture: two figures outside the 86th floor fence" + }, + { "t": 1789766410000, "title": "Police helicopter on scene" }, + { "t": 1789766550000, "title": "NEWS-7 arrives" }, + { "t": 1789766590000, "title": "Climbers start up the mast" }, + { "t": 1789766725000, "title": "SKY-4 joins: three helicopters orbiting" }, + { "t": 1789766860000, "title": "One climber at the top of the mast" }, + { "t": 1789767020000, "title": "Officers on the 102nd floor deck" }, + { "t": 1789767330000, "title": "Climbers start down" }, + { "t": 1789767460000, "title": "Both back over the rail" }, + { "t": 1789767540000, "title": "SKY-4 departs" } + ], + "tracks": [ + { + "id": "pd-14", + "kind": "helicopter", + "label": "PD-14 (illustrative)", + "callsign": "PD14", + "registration": "ILLUS-14", + "type": "Bell 429", + "operator": "City police aviation (fictional)", + "role": "police", + "color": "#5EC8FF", + "points": [ + { "t": 1789766280000, "lon": -74.009068, "lat": 40.701395, "altM": 15 }, + { "t": 1789766281000, "lon": -74.009064, "lat": 40.701406, "altM": 15 }, + { "t": 1789766282000, "lon": -74.008981, "lat": 40.701339, "altM": 15 }, + { "t": 1789766283000, "lon": -74.009048, "lat": 40.701348, "altM": 15 }, + { "t": 1789766284000, "lon": -74.00913, "lat": 40.701325, "altM": 15 }, + { "t": 1789766285000, "lon": -74.009091, "lat": 40.701295, "altM": 15 }, + { "t": 1789766286000, "lon": -74.008994, "lat": 40.701397, "altM": 15 }, + { "t": 1789766287000, "lon": -74.009055, "lat": 40.701333, "altM": 15 }, + { "t": 1789766288000, "lon": -74.009087, "lat": 40.701368, "altM": 15 }, + { "t": 1789766289000, "lon": -74.009018, "lat": 40.701373, "altM": 15 }, + { "t": 1789766290000, "lon": -74.009035, "lat": 40.701351, "altM": 15 }, + { "t": 1789766291000, "lon": -74.009072, "lat": 40.701348, "altM": 15 }, + { "t": 1789766292000, "lon": -74.008984, "lat": 40.701448, "altM": 15 }, + { "t": 1789766293000, "lon": -74.009122, "lat": 40.701436, "altM": 15 }, + { "t": 1789766294000, "lon": -74.00909, "lat": 40.701354, "altM": 15 }, + { "t": 1789766295000, "lon": -74.0091, "lat": 40.701367, "altM": 15 }, + { "t": 1789766296000, "lon": -74.009086, "lat": 40.701405, "altM": 15 }, + { "t": 1789766297000, "lon": -74.009044, "lat": 40.701321, "altM": 15 }, + { "t": 1789766298000, "lon": -74.009037, "lat": 40.70139, "altM": 15 }, + { "t": 1789766299000, "lon": -74.009028, "lat": 40.701337, "altM": 15 }, + { "t": 1789766300000, "lon": -74.008993, "lat": 40.701388, "altM": 23 }, + { "t": 1789766301000, "lon": -74.00898, "lat": 40.701368, "altM": 53 }, + { "t": 1789766302000, "lon": -74.008881, "lat": 40.701472, "altM": 76 }, + { "t": 1789766303000, "lon": -74.008792, "lat": 40.701665, "altM": 99 }, + { + "t": 1789766304000, + "lon": -74.008679, + "lat": 40.701879, + "altM": 122 + }, + { + "t": 1789766305000, + "lon": -74.008635, + "lat": 40.702037, + "altM": 137 + }, + { + "t": 1789766306000, + "lon": -74.008593, + "lat": 40.702278, + "altM": 152 + }, + { "t": 1789766307000, "lon": -74.008661, "lat": 40.70262, "altM": 168 }, + { + "t": 1789766308000, + "lon": -74.008657, + "lat": 40.702829, + "altM": 183 + }, + { "t": 1789766309000, "lon": -74.008639, "lat": 40.70318, "altM": 191 }, + { + "t": 1789766310000, + "lon": -74.008662, + "lat": 40.703561, + "altM": 206 + }, + { + "t": 1789766311000, + "lon": -74.008727, + "lat": 40.703881, + "altM": 213 + }, + { "t": 1789766312000, "lon": -74.008776, "lat": 40.7042, "altM": 221 }, + { + "t": 1789766313000, + "lon": -74.008951, + "lat": 40.704557, + "altM": 229 + }, + { + "t": 1789766314000, + "lon": -74.008841, + "lat": 40.704956, + "altM": 236 + }, + { + "t": 1789766315000, + "lon": -74.008805, + "lat": 40.705368, + "altM": 236 + }, + { "t": 1789766316000, "lon": -74.008844, "lat": 40.70566, "altM": 244 }, + { + "t": 1789766317000, + "lon": -74.008962, + "lat": 40.706005, + "altM": 251 + }, + { + "t": 1789766318000, + "lon": -74.009017, + "lat": 40.706397, + "altM": 251 + }, + { + "t": 1789766319000, + "lon": -74.009071, + "lat": 40.706892, + "altM": 259 + }, + { + "t": 1789766320000, + "lon": -74.009045, + "lat": 40.707261, + "altM": 259 + }, + { + "t": 1789766321000, + "lon": -74.009122, + "lat": 40.707701, + "altM": 267 + }, + { + "t": 1789766322000, + "lon": -74.009167, + "lat": 40.708038, + "altM": 267 + }, + { + "t": 1789766323000, + "lon": -74.009204, + "lat": 40.708371, + "altM": 267 + }, + { + "t": 1789766324000, + "lon": -74.009301, + "lat": 40.708837, + "altM": 274 + }, + { + "t": 1789766325000, + "lon": -74.009455, + "lat": 40.709256, + "altM": 274 + }, + { + "t": 1789766326000, + "lon": -74.009466, + "lat": 40.709622, + "altM": 274 + }, + { + "t": 1789766327000, + "lon": -74.009519, + "lat": 40.710022, + "altM": 274 + }, + { + "t": 1789766328000, + "lon": -74.009669, + "lat": 40.710444, + "altM": 274 + }, + { + "t": 1789766329000, + "lon": -74.009702, + "lat": 40.710796, + "altM": 282 + }, + { + "t": 1789766330000, + "lon": -74.009791, + "lat": 40.711191, + "altM": 282 + }, + { + "t": 1789766331000, + "lon": -74.009898, + "lat": 40.711626, + "altM": 282 + }, + { + "t": 1789766332000, + "lon": -74.010011, + "lat": 40.711995, + "altM": 282 + }, + { + "t": 1789766333000, + "lon": -74.009967, + "lat": 40.712387, + "altM": 282 + }, + { + "t": 1789766334000, + "lon": -74.010142, + "lat": 40.712784, + "altM": 282 + }, + { + "t": 1789766335000, + "lon": -74.010273, + "lat": 40.713194, + "altM": 282 + }, + { + "t": 1789766336000, + "lon": -74.010358, + "lat": 40.713562, + "altM": 290 + }, + { + "t": 1789766337000, + "lon": -74.010404, + "lat": 40.714048, + "altM": 297 + }, + { + "t": 1789766338000, + "lon": -74.010303, + "lat": 40.714466, + "altM": 305 + }, + { "t": 1789766339000, "lon": -74.010161, "lat": 40.71489, "altM": 312 }, + { + "t": 1789766340000, + "lon": -74.010005, + "lat": 40.715352, + "altM": 312 + }, + { + "t": 1789766341000, + "lon": -74.009878, + "lat": 40.715858, + "altM": 320 + }, + { + "t": 1789766342000, + "lon": -74.009695, + "lat": 40.716361, + "altM": 320 + }, + { + "t": 1789766343000, + "lon": -74.009468, + "lat": 40.716829, + "altM": 328 + }, + { + "t": 1789766344000, + "lon": -74.009342, + "lat": 40.717245, + "altM": 328 + }, + { + "t": 1789766345000, + "lon": -74.009191, + "lat": 40.717667, + "altM": 328 + }, + { + "t": 1789766346000, + "lon": -74.009077, + "lat": 40.718262, + "altM": 328 + }, + { + "t": 1789766347000, + "lon": -74.008868, + "lat": 40.718681, + "altM": 335 + }, + { + "t": 1789766348000, + "lon": -74.008764, + "lat": 40.719145, + "altM": 335 + }, + { "t": 1789766349000, "lon": -74.00853, "lat": 40.719628, "altM": 335 }, + { + "t": 1789766350000, + "lon": -74.008381, + "lat": 40.720079, + "altM": 335 + }, + { + "t": 1789766351000, + "lon": -74.008227, + "lat": 40.720581, + "altM": 343 + }, + { + "t": 1789766352000, + "lon": -74.007969, + "lat": 40.721034, + "altM": 343 + }, + { + "t": 1789766353000, + "lon": -74.007923, + "lat": 40.721491, + "altM": 343 + }, + { + "t": 1789766354000, + "lon": -74.007872, + "lat": 40.722022, + "altM": 343 + }, + { "t": 1789766355000, "lon": -74.00762, "lat": 40.722513, "altM": 343 }, + { + "t": 1789766356000, + "lon": -74.007472, + "lat": 40.722939, + "altM": 343 + }, + { + "t": 1789766357000, + "lon": -74.007336, + "lat": 40.723445, + "altM": 343 + }, + { + "t": 1789766358000, + "lon": -74.007194, + "lat": 40.723998, + "altM": 343 + }, + { + "t": 1789766359000, + "lon": -74.007066, + "lat": 40.724543, + "altM": 343 + }, + { + "t": 1789766360000, + "lon": -74.006979, + "lat": 40.724925, + "altM": 343 + }, + { "t": 1789766361000, "lon": -74.006834, "lat": 40.72546, "altM": 351 }, + { "t": 1789766362000, "lon": -74.006733, "lat": 40.72592, "altM": 351 }, + { + "t": 1789766363000, + "lon": -74.006482, + "lat": 40.726452, + "altM": 351 + }, + { + "t": 1789766364000, + "lon": -74.006457, + "lat": 40.726914, + "altM": 351 + }, + { "t": 1789766365000, "lon": -74.00628, "lat": 40.727391, "altM": 351 }, + { + "t": 1789766366000, + "lon": -74.006187, + "lat": 40.727802, + "altM": 351 + }, + { "t": 1789766367000, "lon": -74.006038, "lat": 40.72836, "altM": 351 }, + { + "t": 1789766368000, + "lon": -74.005932, + "lat": 40.728858, + "altM": 351 + }, + { + "t": 1789766369000, + "lon": -74.005861, + "lat": 40.729283, + "altM": 351 + }, + { + "t": 1789766370000, + "lon": -74.005777, + "lat": 40.729789, + "altM": 351 + }, + { + "t": 1789766371000, + "lon": -74.005716, + "lat": 40.730297, + "altM": 351 + }, + { "t": 1789766372000, "lon": -74.005557, "lat": 40.73079, "altM": 351 }, + { + "t": 1789766373000, + "lon": -74.005557, + "lat": 40.731286, + "altM": 351 + }, + { "t": 1789766374000, "lon": -74.005322, "lat": 40.73179, "altM": 351 }, + { + "t": 1789766375000, + "lon": -74.005464, + "lat": 40.732233, + "altM": 351 + }, + { + "t": 1789766376000, + "lon": -74.005299, + "lat": 40.732748, + "altM": 351 + }, + { + "t": 1789766377000, + "lon": -74.005293, + "lat": 40.733274, + "altM": 351 + }, + { + "t": 1789766378000, + "lon": -74.005203, + "lat": 40.733818, + "altM": 351 + }, + { + "t": 1789766379000, + "lon": -74.005189, + "lat": 40.734266, + "altM": 351 + }, + { + "t": 1789766380000, + "lon": -74.005151, + "lat": 40.734756, + "altM": 351 + }, + { "t": 1789766381000, "lon": -74.00498, "lat": 40.73522, "altM": 351 }, + { + "t": 1789766382000, + "lon": -74.004918, + "lat": 40.735658, + "altM": 351 + }, + { + "t": 1789766383000, + "lon": -74.004642, + "lat": 40.736115, + "altM": 351 + }, + { + "t": 1789766384000, + "lon": -74.004348, + "lat": 40.736506, + "altM": 351 + }, + { + "t": 1789766385000, + "lon": -74.004052, + "lat": 40.736973, + "altM": 351 + }, + { + "t": 1789766386000, + "lon": -74.003713, + "lat": 40.737282, + "altM": 351 + }, + { + "t": 1789766387000, + "lon": -74.003265, + "lat": 40.737698, + "altM": 351 + }, + { + "t": 1789766388000, + "lon": -74.002761, + "lat": 40.737968, + "altM": 351 + }, + { + "t": 1789766389000, + "lon": -74.002491, + "lat": 40.738234, + "altM": 351 + }, + { + "t": 1789766390000, + "lon": -74.001826, + "lat": 40.738527, + "altM": 351 + }, + { + "t": 1789766391000, + "lon": -74.001419, + "lat": 40.738826, + "altM": 351 + }, + { + "t": 1789766392000, + "lon": -74.000797, + "lat": 40.739128, + "altM": 351 + }, + { + "t": 1789766393000, + "lon": -74.000368, + "lat": 40.739352, + "altM": 351 + }, + { "t": 1789766394000, "lon": -73.99998, "lat": 40.739617, "altM": 351 }, + { + "t": 1789766395000, + "lon": -73.999442, + "lat": 40.739893, + "altM": 351 + }, + { + "t": 1789766396000, + "lon": -73.998926, + "lat": 40.740207, + "altM": 351 + }, + { + "t": 1789766397000, + "lon": -73.998456, + "lat": 40.740476, + "altM": 351 + }, + { + "t": 1789766398000, + "lon": -73.998022, + "lat": 40.740739, + "altM": 351 + }, + { + "t": 1789766399000, + "lon": -73.997475, + "lat": 40.740981, + "altM": 351 + }, + { + "t": 1789766400000, + "lon": -73.997138, + "lat": 40.741353, + "altM": 351 + }, + { "t": 1789766401000, "lon": -73.9966, "lat": 40.741573, "altM": 351 }, + { + "t": 1789766402000, + "lon": -73.996127, + "lat": 40.741784, + "altM": 351 + }, + { + "t": 1789766403000, + "lon": -73.995722, + "lat": 40.742135, + "altM": 351 + }, + { "t": 1789766404000, "lon": -73.99523, "lat": 40.742441, "altM": 351 }, + { "t": 1789766405000, "lon": -73.994836, "lat": 40.74272, "altM": 351 }, + { + "t": 1789766406000, + "lon": -73.994378, + "lat": 40.743041, + "altM": 351 + }, + { + "t": 1789766407000, + "lon": -73.993964, + "lat": 40.743241, + "altM": 351 + }, + { + "t": 1789766408000, + "lon": -73.993597, + "lat": 40.743594, + "altM": 351 + }, + { + "t": 1789766409000, + "lon": -73.993187, + "lat": 40.743793, + "altM": 351 + }, + { + "t": 1789766410000, + "lon": -73.992898, + "lat": 40.744063, + "altM": 351 + }, + { + "t": 1789766411000, + "lon": -73.992479, + "lat": 40.744316, + "altM": 351 + }, + { "t": 1789766412000, "lon": -73.992055, "lat": 40.74457, "altM": 351 }, + { + "t": 1789766413000, + "lon": -73.991608, + "lat": 40.744712, + "altM": 351 + }, + { + "t": 1789766414000, + "lon": -73.991291, + "lat": 40.744921, + "altM": 351 + }, + { + "t": 1789766415000, + "lon": -73.990788, + "lat": 40.745091, + "altM": 351 + }, + { "t": 1789766416000, "lon": -73.990325, "lat": 40.74511, "altM": 351 }, + { + "t": 1789766417000, + "lon": -73.989774, + "lat": 40.745238, + "altM": 351 + }, + { + "t": 1789766418000, + "lon": -73.989278, + "lat": 40.745273, + "altM": 351 + }, + { + "t": 1789766419000, + "lon": -73.988779, + "lat": 40.745295, + "altM": 351 + }, + { + "t": 1789766420000, + "lon": -73.988331, + "lat": 40.745211, + "altM": 351 + }, + { "t": 1789766421000, "lon": -73.987746, "lat": 40.74522, "altM": 351 }, + { + "t": 1789766422000, + "lon": -73.987312, + "lat": 40.745109, + "altM": 351 + }, + { + "t": 1789766423000, + "lon": -73.986967, + "lat": 40.744959, + "altM": 351 + }, + { + "t": 1789766424000, + "lon": -73.986401, + "lat": 40.744887, + "altM": 351 + }, + { + "t": 1789766425000, + "lon": -73.985983, + "lat": 40.744754, + "altM": 351 + }, + { + "t": 1789766426000, + "lon": -73.985571, + "lat": 40.744483, + "altM": 351 + }, + { "t": 1789766427000, "lon": -73.985163, "lat": 40.74428, "altM": 351 }, + { "t": 1789766428000, "lon": -73.984787, "lat": 40.74415, "altM": 351 }, + { + "t": 1789766429000, + "lon": -73.984285, + "lat": 40.743931, + "altM": 351 + }, + { + "t": 1789766430000, + "lon": -73.983803, + "lat": 40.743925, + "altM": 351 + }, + { + "t": 1789766431000, + "lon": -73.983378, + "lat": 40.743835, + "altM": 351 + }, + { + "t": 1789766432000, + "lon": -73.982925, + "lat": 40.743722, + "altM": 351 + }, + { + "t": 1789766433000, + "lon": -73.982474, + "lat": 40.743687, + "altM": 351 + }, + { + "t": 1789766434000, + "lon": -73.981897, + "lat": 40.743665, + "altM": 351 + }, + { + "t": 1789766435000, + "lon": -73.981576, + "lat": 40.743782, + "altM": 351 + }, + { + "t": 1789766436000, + "lon": -73.981018, + "lat": 40.743816, + "altM": 351 + }, + { + "t": 1789766437000, + "lon": -73.980679, + "lat": 40.743858, + "altM": 351 + }, + { + "t": 1789766438000, + "lon": -73.980178, + "lat": 40.743957, + "altM": 351 + }, + { + "t": 1789766439000, + "lon": -73.979806, + "lat": 40.744043, + "altM": 351 + }, + { + "t": 1789766440000, + "lon": -73.979394, + "lat": 40.744225, + "altM": 351 + }, + { + "t": 1789766441000, + "lon": -73.979053, + "lat": 40.744386, + "altM": 351 + }, + { + "t": 1789766442000, + "lon": -73.978622, + "lat": 40.744525, + "altM": 351 + }, + { + "t": 1789766443000, + "lon": -73.978306, + "lat": 40.744763, + "altM": 351 + }, + { + "t": 1789766444000, + "lon": -73.978146, + "lat": 40.744998, + "altM": 351 + }, + { "t": 1789766445000, "lon": -73.97788, "lat": 40.745288, "altM": 351 }, + { + "t": 1789766446000, + "lon": -73.977556, + "lat": 40.745526, + "altM": 351 + }, + { "t": 1789766447000, "lon": -73.9774, "lat": 40.745788, "altM": 351 }, + { + "t": 1789766448000, + "lon": -73.977234, + "lat": 40.746076, + "altM": 351 + }, + { "t": 1789766449000, "lon": -73.977215, "lat": 40.74628, "altM": 358 }, + { + "t": 1789766450000, + "lon": -73.977052, + "lat": 40.746661, + "altM": 351 + }, + { + "t": 1789766451000, + "lon": -73.976996, + "lat": 40.746881, + "altM": 358 + }, + { + "t": 1789766452000, + "lon": -73.977004, + "lat": 40.747184, + "altM": 358 + }, + { + "t": 1789766453000, + "lon": -73.977101, + "lat": 40.747417, + "altM": 358 + }, + { + "t": 1789766454000, + "lon": -73.977102, + "lat": 40.747627, + "altM": 358 + }, + { + "t": 1789766455000, + "lon": -73.977222, + "lat": 40.747909, + "altM": 358 + }, + { + "t": 1789766456000, + "lon": -73.977375, + "lat": 40.748193, + "altM": 358 + }, + { + "t": 1789766457000, + "lon": -73.977529, + "lat": 40.748319, + "altM": 358 + }, + { + "t": 1789766458000, + "lon": -73.977792, + "lat": 40.748515, + "altM": 358 + }, + { + "t": 1789766459000, + "lon": -73.977942, + "lat": 40.748715, + "altM": 358 + }, + { + "t": 1789766460000, + "lon": -73.978189, + "lat": 40.748866, + "altM": 358 + }, + { + "t": 1789766461000, + "lon": -73.978398, + "lat": 40.748942, + "altM": 358 + }, + { + "t": 1789766462000, + "lon": -73.978754, + "lat": 40.749079, + "altM": 358 + }, + { + "t": 1789766463000, + "lon": -73.978971, + "lat": 40.749232, + "altM": 358 + }, + { + "t": 1789766464000, + "lon": -73.979309, + "lat": 40.749361, + "altM": 358 + }, + { + "t": 1789766465000, + "lon": -73.979503, + "lat": 40.749578, + "altM": 358 + }, + { + "t": 1789766466000, + "lon": -73.979628, + "lat": 40.749657, + "altM": 358 + }, + { + "t": 1789766467000, + "lon": -73.979952, + "lat": 40.749868, + "altM": 358 + }, + { + "t": 1789766468000, + "lon": -73.980089, + "lat": 40.750009, + "altM": 358 + }, + { + "t": 1789766469000, + "lon": -73.980349, + "lat": 40.750168, + "altM": 358 + }, + { + "t": 1789766470000, + "lon": -73.980594, + "lat": 40.750416, + "altM": 358 + }, + { + "t": 1789766471000, + "lon": -73.980744, + "lat": 40.750489, + "altM": 358 + }, + { "t": 1789766472000, "lon": -73.981002, "lat": 40.75076, "altM": 358 }, + { + "t": 1789766473000, + "lon": -73.981206, + "lat": 40.750919, + "altM": 358 + }, + { "t": 1789766474000, "lon": -73.981466, "lat": 40.75097, "altM": 358 }, + { + "t": 1789766475000, + "lon": -73.981742, + "lat": 40.751186, + "altM": 358 + }, + { + "t": 1789766476000, + "lon": -73.981866, + "lat": 40.751225, + "altM": 358 + }, + { + "t": 1789766477000, + "lon": -73.982256, + "lat": 40.751464, + "altM": 358 + }, + { + "t": 1789766478000, + "lon": -73.982401, + "lat": 40.751581, + "altM": 358 + }, + { + "t": 1789766479000, + "lon": -73.982695, + "lat": 40.751624, + "altM": 358 + }, + { + "t": 1789766480000, + "lon": -73.982975, + "lat": 40.751775, + "altM": 358 + }, + { + "t": 1789766481000, + "lon": -73.983314, + "lat": 40.751894, + "altM": 358 + }, + { "t": 1789766482000, "lon": -73.98354, "lat": 40.751945, "altM": 358 }, + { + "t": 1789766483000, + "lon": -73.983874, + "lat": 40.751983, + "altM": 358 + }, + { + "t": 1789766484000, + "lon": -73.984098, + "lat": 40.751968, + "altM": 358 + }, + { + "t": 1789766485000, + "lon": -73.984452, + "lat": 40.752117, + "altM": 358 + }, + { + "t": 1789766486000, + "lon": -73.984792, + "lat": 40.752201, + "altM": 358 + }, + { + "t": 1789766487000, + "lon": -73.984975, + "lat": 40.752204, + "altM": 358 + }, + { "t": 1789766488000, "lon": -73.985383, "lat": 40.75208, "altM": 358 }, + { + "t": 1789766489000, + "lon": -73.985691, + "lat": 40.752097, + "altM": 358 + }, + { + "t": 1789766490000, + "lon": -73.985959, + "lat": 40.752145, + "altM": 358 + }, + { + "t": 1789766491000, + "lon": -73.986256, + "lat": 40.752088, + "altM": 358 + }, + { + "t": 1789766492000, + "lon": -73.986555, + "lat": 40.752004, + "altM": 358 + }, + { + "t": 1789766493000, + "lon": -73.986961, + "lat": 40.751939, + "altM": 358 + }, + { + "t": 1789766494000, + "lon": -73.987224, + "lat": 40.751876, + "altM": 358 + }, + { + "t": 1789766495000, + "lon": -73.987567, + "lat": 40.751761, + "altM": 358 + }, + { + "t": 1789766496000, + "lon": -73.987862, + "lat": 40.751673, + "altM": 358 + }, + { + "t": 1789766497000, + "lon": -73.988087, + "lat": 40.751575, + "altM": 358 + }, + { + "t": 1789766498000, + "lon": -73.988405, + "lat": 40.751373, + "altM": 358 + }, + { + "t": 1789766499000, + "lon": -73.988661, + "lat": 40.751209, + "altM": 358 + }, + { + "t": 1789766500000, + "lon": -73.988893, + "lat": 40.751034, + "altM": 358 + }, + { + "t": 1789766501000, + "lon": -73.989208, + "lat": 40.750881, + "altM": 358 + }, + { + "t": 1789766502000, + "lon": -73.989423, + "lat": 40.750722, + "altM": 358 + }, + { + "t": 1789766503000, + "lon": -73.989671, + "lat": 40.750544, + "altM": 358 + }, + { "t": 1789766504000, "lon": -73.989781, "lat": 40.75033, "altM": 358 }, + { + "t": 1789766505000, + "lon": -73.990031, + "lat": 40.750041, + "altM": 358 + }, + { "t": 1789766506000, "lon": -73.99024, "lat": 40.749868, "altM": 358 }, + { + "t": 1789766507000, + "lon": -73.990296, + "lat": 40.749548, + "altM": 358 + }, + { + "t": 1789766508000, + "lon": -73.990548, + "lat": 40.749265, + "altM": 358 + }, + { + "t": 1789766509000, + "lon": -73.990658, + "lat": 40.748997, + "altM": 358 + }, + { + "t": 1789766510000, + "lon": -73.990636, + "lat": 40.748702, + "altM": 358 + }, + { + "t": 1789766511000, + "lon": -73.990725, + "lat": 40.748413, + "altM": 358 + }, + { + "t": 1789766512000, + "lon": -73.990765, + "lat": 40.748061, + "altM": 358 + }, + { + "t": 1789766513000, + "lon": -73.990747, + "lat": 40.747801, + "altM": 358 + }, + { + "t": 1789766514000, + "lon": -73.990783, + "lat": 40.747411, + "altM": 358 + }, + { + "t": 1789766515000, + "lon": -73.990557, + "lat": 40.747099, + "altM": 358 + }, + { + "t": 1789766516000, + "lon": -73.990601, + "lat": 40.746814, + "altM": 358 + }, + { + "t": 1789766517000, + "lon": -73.990312, + "lat": 40.746513, + "altM": 358 + }, + { + "t": 1789766518000, + "lon": -73.990184, + "lat": 40.746193, + "altM": 358 + }, + { "t": 1789766519000, "lon": -73.99004, "lat": 40.745924, "altM": 358 }, + { + "t": 1789766520000, + "lon": -73.989762, + "lat": 40.745591, + "altM": 358 + }, + { "t": 1789766521000, "lon": -73.98949, "lat": 40.745295, "altM": 358 }, + { + "t": 1789766522000, + "lon": -73.989179, + "lat": 40.745065, + "altM": 358 + }, + { + "t": 1789766523000, + "lon": -73.988762, + "lat": 40.744808, + "altM": 358 + }, + { "t": 1789766524000, "lon": -73.988395, "lat": 40.74464, "altM": 358 }, + { + "t": 1789766525000, + "lon": -73.988063, + "lat": 40.744445, + "altM": 358 + }, + { + "t": 1789766526000, + "lon": -73.987624, + "lat": 40.744203, + "altM": 351 + }, + { + "t": 1789766527000, + "lon": -73.987173, + "lat": 40.744043, + "altM": 351 + }, + { + "t": 1789766528000, + "lon": -73.986725, + "lat": 40.743901, + "altM": 351 + }, + { + "t": 1789766529000, + "lon": -73.986344, + "lat": 40.743851, + "altM": 351 + }, + { + "t": 1789766530000, + "lon": -73.985882, + "lat": 40.743745, + "altM": 351 + }, + { + "t": 1789766531000, + "lon": -73.985341, + "lat": 40.743757, + "altM": 351 + }, + { + "t": 1789766532000, + "lon": -73.984858, + "lat": 40.743784, + "altM": 351 + }, + { + "t": 1789766533000, + "lon": -73.984418, + "lat": 40.743671, + "altM": 351 + }, + { + "t": 1789766534000, + "lon": -73.983941, + "lat": 40.743773, + "altM": 351 + }, + { + "t": 1789766535000, + "lon": -73.983495, + "lat": 40.743894, + "altM": 351 + }, + { + "t": 1789766536000, + "lon": -73.983062, + "lat": 40.744014, + "altM": 351 + }, + { "t": 1789766537000, "lon": -73.98264, "lat": 40.744113, "altM": 351 }, + { + "t": 1789766538000, + "lon": -73.982222, + "lat": 40.744207, + "altM": 351 + }, + { + "t": 1789766539000, + "lon": -73.981806, + "lat": 40.744436, + "altM": 351 + }, + { + "t": 1789766540000, + "lon": -73.981468, + "lat": 40.744615, + "altM": 351 + }, + { + "t": 1789766541000, + "lon": -73.981193, + "lat": 40.744769, + "altM": 351 + }, + { + "t": 1789766542000, + "lon": -73.980947, + "lat": 40.744989, + "altM": 351 + }, + { + "t": 1789766543000, + "lon": -73.980603, + "lat": 40.745264, + "altM": 351 + }, + { + "t": 1789766544000, + "lon": -73.980449, + "lat": 40.745516, + "altM": 351 + }, + { + "t": 1789766545000, + "lon": -73.980217, + "lat": 40.745702, + "altM": 351 + }, + { + "t": 1789766546000, + "lon": -73.980101, + "lat": 40.746002, + "altM": 351 + }, + { + "t": 1789766547000, + "lon": -73.979963, + "lat": 40.746258, + "altM": 351 + }, + { + "t": 1789766548000, + "lon": -73.979883, + "lat": 40.746569, + "altM": 351 + }, + { + "t": 1789766549000, + "lon": -73.979825, + "lat": 40.746915, + "altM": 351 + }, + { + "t": 1789766550000, + "lon": -73.979821, + "lat": 40.747196, + "altM": 351 + }, + { + "t": 1789766551000, + "lon": -73.979821, + "lat": 40.747404, + "altM": 351 + }, + { + "t": 1789766552000, + "lon": -73.979843, + "lat": 40.747669, + "altM": 351 + }, + { + "t": 1789766553000, + "lon": -73.979913, + "lat": 40.747932, + "altM": 351 + }, + { + "t": 1789766554000, + "lon": -73.979985, + "lat": 40.748172, + "altM": 351 + }, + { "t": 1789766555000, "lon": -73.97999, "lat": 40.748489, "altM": 351 }, + { + "t": 1789766556000, + "lon": -73.980211, + "lat": 40.748741, + "altM": 351 + }, + { + "t": 1789766557000, + "lon": -73.980289, + "lat": 40.748933, + "altM": 351 + }, + { "t": 1789766558000, "lon": -73.980338, "lat": 40.74918, "altM": 351 }, + { + "t": 1789766559000, + "lon": -73.980402, + "lat": 40.749364, + "altM": 351 + }, + { "t": 1789766560000, "lon": -73.980584, "lat": 40.74959, "altM": 351 }, + { + "t": 1789766561000, + "lon": -73.980838, + "lat": 40.749815, + "altM": 351 + }, + { + "t": 1789766562000, + "lon": -73.980942, + "lat": 40.750007, + "altM": 351 + }, + { + "t": 1789766563000, + "lon": -73.981217, + "lat": 40.750258, + "altM": 343 + }, + { + "t": 1789766564000, + "lon": -73.981298, + "lat": 40.750368, + "altM": 343 + }, + { + "t": 1789766565000, + "lon": -73.981535, + "lat": 40.750569, + "altM": 343 + }, + { + "t": 1789766566000, + "lon": -73.981798, + "lat": 40.750755, + "altM": 343 + }, + { + "t": 1789766567000, + "lon": -73.982024, + "lat": 40.750924, + "altM": 343 + }, + { + "t": 1789766568000, + "lon": -73.982265, + "lat": 40.751037, + "altM": 343 + }, + { + "t": 1789766569000, + "lon": -73.982493, + "lat": 40.751199, + "altM": 343 + }, + { "t": 1789766570000, "lon": -73.98279, "lat": 40.751298, "altM": 343 }, + { + "t": 1789766571000, + "lon": -73.982991, + "lat": 40.751404, + "altM": 343 + }, + { + "t": 1789766572000, + "lon": -73.983311, + "lat": 40.751507, + "altM": 343 + }, + { + "t": 1789766573000, + "lon": -73.983515, + "lat": 40.751645, + "altM": 343 + }, + { "t": 1789766574000, "lon": -73.983928, "lat": 40.75169, "altM": 343 }, + { + "t": 1789766575000, + "lon": -73.983991, + "lat": 40.751698, + "altM": 343 + }, + { "t": 1789766576000, "lon": -73.984489, "lat": 40.75183, "altM": 343 }, + { "t": 1789766577000, "lon": -73.98481, "lat": 40.751844, "altM": 343 }, + { + "t": 1789766578000, + "lon": -73.985109, + "lat": 40.751909, + "altM": 343 + }, + { + "t": 1789766579000, + "lon": -73.985373, + "lat": 40.751872, + "altM": 343 + }, + { + "t": 1789766580000, + "lon": -73.985665, + "lat": 40.751915, + "altM": 343 + }, + { + "t": 1789766581000, + "lon": -73.986044, + "lat": 40.751836, + "altM": 343 + }, + { + "t": 1789766582000, + "lon": -73.986302, + "lat": 40.751809, + "altM": 343 + }, + { "t": 1789766583000, "lon": -73.986698, "lat": 40.75187, "altM": 343 }, + { + "t": 1789766584000, + "lon": -73.986945, + "lat": 40.751727, + "altM": 343 + }, + { "t": 1789766585000, "lon": -73.987241, "lat": 40.75167, "altM": 343 }, + { + "t": 1789766586000, + "lon": -73.987498, + "lat": 40.751629, + "altM": 343 + }, + { + "t": 1789766587000, + "lon": -73.987794, + "lat": 40.751439, + "altM": 343 + }, + { + "t": 1789766588000, + "lon": -73.988135, + "lat": 40.751428, + "altM": 343 + }, + { + "t": 1789766589000, + "lon": -73.988416, + "lat": 40.751218, + "altM": 343 + }, + { "t": 1789766590000, "lon": -73.988706, "lat": 40.75105, "altM": 343 }, + { + "t": 1789766591000, + "lon": -73.988944, + "lat": 40.750929, + "altM": 343 + }, + { + "t": 1789766592000, + "lon": -73.989147, + "lat": 40.750672, + "altM": 343 + }, + { + "t": 1789766593000, + "lon": -73.989347, + "lat": 40.750512, + "altM": 343 + }, + { + "t": 1789766594000, + "lon": -73.989652, + "lat": 40.750403, + "altM": 343 + }, + { + "t": 1789766595000, + "lon": -73.989778, + "lat": 40.750064, + "altM": 343 + }, + { + "t": 1789766596000, + "lon": -73.990076, + "lat": 40.749821, + "altM": 343 + }, + { + "t": 1789766597000, + "lon": -73.990186, + "lat": 40.749595, + "altM": 343 + }, + { + "t": 1789766598000, + "lon": -73.990427, + "lat": 40.749377, + "altM": 343 + }, + { + "t": 1789766599000, + "lon": -73.990426, + "lat": 40.749067, + "altM": 343 + }, + { + "t": 1789766600000, + "lon": -73.990532, + "lat": 40.748778, + "altM": 343 + }, + { + "t": 1789766601000, + "lon": -73.990633, + "lat": 40.748508, + "altM": 343 + }, + { + "t": 1789766602000, + "lon": -73.990679, + "lat": 40.748154, + "altM": 343 + }, + { "t": 1789766603000, "lon": -73.990633, "lat": 40.7479, "altM": 343 }, + { + "t": 1789766604000, + "lon": -73.990623, + "lat": 40.747618, + "altM": 343 + }, + { + "t": 1789766605000, + "lon": -73.990605, + "lat": 40.747308, + "altM": 343 + }, + { + "t": 1789766606000, + "lon": -73.990647, + "lat": 40.746898, + "altM": 343 + }, + { "t": 1789766607000, "lon": -73.99038, "lat": 40.746613, "altM": 343 }, + { + "t": 1789766608000, + "lon": -73.990168, + "lat": 40.746301, + "altM": 343 + }, + { "t": 1789766609000, "lon": -73.990005, "lat": 40.74601, "altM": 343 }, + { + "t": 1789766610000, + "lon": -73.989821, + "lat": 40.745704, + "altM": 343 + }, + { "t": 1789766611000, "lon": -73.989555, "lat": 40.74541, "altM": 343 }, + { + "t": 1789766612000, + "lon": -73.989293, + "lat": 40.745155, + "altM": 343 + }, + { + "t": 1789766613000, + "lon": -73.989013, + "lat": 40.744909, + "altM": 343 + }, + { + "t": 1789766614000, + "lon": -73.988635, + "lat": 40.744622, + "altM": 343 + }, + { + "t": 1789766615000, + "lon": -73.988206, + "lat": 40.744472, + "altM": 343 + }, + { + "t": 1789766616000, + "lon": -73.987851, + "lat": 40.744252, + "altM": 343 + }, + { + "t": 1789766617000, + "lon": -73.987414, + "lat": 40.744035, + "altM": 343 + }, + { + "t": 1789766618000, + "lon": -73.986952, + "lat": 40.743889, + "altM": 343 + }, + { + "t": 1789766619000, + "lon": -73.986558, + "lat": 40.743765, + "altM": 343 + }, + { + "t": 1789766620000, + "lon": -73.986031, + "lat": 40.743772, + "altM": 343 + }, + { + "t": 1789766621000, + "lon": -73.985464, + "lat": 40.743672, + "altM": 343 + }, + { + "t": 1789766622000, + "lon": -73.985077, + "lat": 40.743702, + "altM": 343 + }, + { "t": 1789766623000, "lon": -73.984657, "lat": 40.74367, "altM": 343 }, + { + "t": 1789766624000, + "lon": -73.984129, + "lat": 40.743676, + "altM": 343 + }, + { "t": 1789766625000, "lon": -73.98375, "lat": 40.743748, "altM": 343 }, + { + "t": 1789766626000, + "lon": -73.983196, + "lat": 40.743854, + "altM": 343 + }, + { + "t": 1789766627000, + "lon": -73.982759, + "lat": 40.743896, + "altM": 343 + }, + { + "t": 1789766628000, + "lon": -73.982426, + "lat": 40.744015, + "altM": 343 + }, + { + "t": 1789766629000, + "lon": -73.981955, + "lat": 40.744174, + "altM": 343 + }, + { + "t": 1789766630000, + "lon": -73.981736, + "lat": 40.744385, + "altM": 343 + }, + { + "t": 1789766631000, + "lon": -73.981246, + "lat": 40.744562, + "altM": 343 + }, + { + "t": 1789766632000, + "lon": -73.980993, + "lat": 40.744788, + "altM": 343 + }, + { + "t": 1789766633000, + "lon": -73.980702, + "lat": 40.744959, + "altM": 343 + }, + { + "t": 1789766634000, + "lon": -73.980476, + "lat": 40.745301, + "altM": 343 + }, + { + "t": 1789766635000, + "lon": -73.980234, + "lat": 40.745585, + "altM": 343 + }, + { + "t": 1789766636000, + "lon": -73.980063, + "lat": 40.745774, + "altM": 343 + }, + { + "t": 1789766637000, + "lon": -73.979848, + "lat": 40.746008, + "altM": 343 + }, + { + "t": 1789766638000, + "lon": -73.979852, + "lat": 40.746315, + "altM": 343 + }, + { "t": 1789766639000, "lon": -73.97984, "lat": 40.746677, "altM": 343 }, + { + "t": 1789766640000, + "lon": -73.979663, + "lat": 40.746873, + "altM": 343 + }, + { + "t": 1789766641000, + "lon": -73.979723, + "lat": 40.747165, + "altM": 343 + }, + { + "t": 1789766642000, + "lon": -73.979587, + "lat": 40.747446, + "altM": 343 + }, + { + "t": 1789766643000, + "lon": -73.979655, + "lat": 40.747645, + "altM": 343 + }, + { + "t": 1789766644000, + "lon": -73.979664, + "lat": 40.747938, + "altM": 343 + }, + { + "t": 1789766645000, + "lon": -73.979738, + "lat": 40.748181, + "altM": 343 + }, + { "t": 1789766646000, "lon": -73.979795, "lat": 40.74848, "altM": 351 }, + { + "t": 1789766647000, + "lon": -73.979854, + "lat": 40.748744, + "altM": 351 + }, + { + "t": 1789766648000, + "lon": -73.979877, + "lat": 40.748941, + "altM": 351 + }, + { + "t": 1789766649000, + "lon": -73.980051, + "lat": 40.749225, + "altM": 351 + }, + { + "t": 1789766650000, + "lon": -73.980053, + "lat": 40.749441, + "altM": 351 + }, + { + "t": 1789766651000, + "lon": -73.980241, + "lat": 40.749668, + "altM": 351 + }, + { + "t": 1789766652000, + "lon": -73.980394, + "lat": 40.749861, + "altM": 351 + }, + { "t": 1789766653000, "lon": -73.980482, "lat": 40.75015, "altM": 351 }, + { + "t": 1789766654000, + "lon": -73.980677, + "lat": 40.750336, + "altM": 351 + }, + { + "t": 1789766655000, + "lon": -73.980947, + "lat": 40.750613, + "altM": 351 + }, + { + "t": 1789766656000, + "lon": -73.981104, + "lat": 40.750656, + "altM": 351 + }, + { "t": 1789766657000, "lon": -73.981279, "lat": 40.75088, "altM": 351 }, + { + "t": 1789766658000, + "lon": -73.981508, + "lat": 40.751067, + "altM": 351 + }, + { + "t": 1789766659000, + "lon": -73.981753, + "lat": 40.751209, + "altM": 351 + }, + { "t": 1789766660000, "lon": -73.98191, "lat": 40.751346, "altM": 351 }, + { + "t": 1789766661000, + "lon": -73.982255, + "lat": 40.751543, + "altM": 351 + }, + { + "t": 1789766662000, + "lon": -73.982492, + "lat": 40.751634, + "altM": 351 + }, + { + "t": 1789766663000, + "lon": -73.982705, + "lat": 40.751794, + "altM": 351 + }, + { + "t": 1789766664000, + "lon": -73.982962, + "lat": 40.751883, + "altM": 351 + }, + { + "t": 1789766665000, + "lon": -73.983296, + "lat": 40.751956, + "altM": 351 + }, + { + "t": 1789766666000, + "lon": -73.983533, + "lat": 40.752092, + "altM": 351 + }, + { + "t": 1789766667000, + "lon": -73.983865, + "lat": 40.752096, + "altM": 351 + }, + { "t": 1789766668000, "lon": -73.9841, "lat": 40.752199, "altM": 351 }, + { + "t": 1789766669000, + "lon": -73.984413, + "lat": 40.752184, + "altM": 351 + }, + { "t": 1789766670000, "lon": -73.984773, "lat": 40.75223, "altM": 351 }, + { "t": 1789766671000, "lon": -73.985014, "lat": 40.75228, "altM": 351 }, + { "t": 1789766672000, "lon": -73.985307, "lat": 40.75228, "altM": 351 }, + { + "t": 1789766673000, + "lon": -73.985634, + "lat": 40.752272, + "altM": 351 + }, + { + "t": 1789766674000, + "lon": -73.986059, + "lat": 40.752334, + "altM": 351 + }, + { + "t": 1789766675000, + "lon": -73.986304, + "lat": 40.752293, + "altM": 351 + }, + { + "t": 1789766676000, + "lon": -73.986576, + "lat": 40.752317, + "altM": 351 + }, + { + "t": 1789766677000, + "lon": -73.986929, + "lat": 40.752151, + "altM": 351 + }, + { "t": 1789766678000, "lon": -73.98724, "lat": 40.752115, "altM": 351 }, + { + "t": 1789766679000, + "lon": -73.987481, + "lat": 40.752018, + "altM": 351 + }, + { + "t": 1789766680000, + "lon": -73.987864, + "lat": 40.751909, + "altM": 351 + }, + { "t": 1789766681000, "lon": -73.988064, "lat": 40.75192, "altM": 351 }, + { + "t": 1789766682000, + "lon": -73.988397, + "lat": 40.751668, + "altM": 358 + }, + { + "t": 1789766683000, + "lon": -73.988678, + "lat": 40.751542, + "altM": 358 + }, + { + "t": 1789766684000, + "lon": -73.988887, + "lat": 40.751428, + "altM": 358 + }, + { "t": 1789766685000, "lon": -73.989171, "lat": 40.75118, "altM": 358 }, + { + "t": 1789766686000, + "lon": -73.989498, + "lat": 40.751191, + "altM": 358 + }, + { + "t": 1789766687000, + "lon": -73.989766, + "lat": 40.750874, + "altM": 358 + }, + { "t": 1789766688000, "lon": -73.990017, "lat": 40.75069, "altM": 358 }, + { + "t": 1789766689000, + "lon": -73.990207, + "lat": 40.750451, + "altM": 358 + }, + { + "t": 1789766690000, + "lon": -73.990377, + "lat": 40.750265, + "altM": 358 + }, + { + "t": 1789766691000, + "lon": -73.990507, + "lat": 40.750067, + "altM": 358 + }, + { + "t": 1789766692000, + "lon": -73.990752, + "lat": 40.749728, + "altM": 358 + }, + { + "t": 1789766693000, + "lon": -73.990799, + "lat": 40.749463, + "altM": 358 + }, + { + "t": 1789766694000, + "lon": -73.990939, + "lat": 40.749208, + "altM": 358 + }, + { + "t": 1789766695000, + "lon": -73.991028, + "lat": 40.748951, + "altM": 358 + }, + { + "t": 1789766696000, + "lon": -73.991182, + "lat": 40.748679, + "altM": 358 + }, + { "t": 1789766697000, "lon": -73.991132, "lat": 40.74825, "altM": 358 }, + { + "t": 1789766698000, + "lon": -73.991307, + "lat": 40.748013, + "altM": 358 + }, + { "t": 1789766699000, "lon": -73.991254, "lat": 40.74768, "altM": 358 }, + { + "t": 1789766700000, + "lon": -73.991238, + "lat": 40.747377, + "altM": 358 + }, + { "t": 1789766701000, "lon": -73.99112, "lat": 40.747017, "altM": 358 }, + { + "t": 1789766702000, + "lon": -73.991012, + "lat": 40.746791, + "altM": 358 + }, + { + "t": 1789766703000, + "lon": -73.990948, + "lat": 40.746426, + "altM": 358 + }, + { + "t": 1789766704000, + "lon": -73.990688, + "lat": 40.746086, + "altM": 358 + }, + { + "t": 1789766705000, + "lon": -73.990541, + "lat": 40.745818, + "altM": 358 + }, + { "t": 1789766706000, "lon": -73.99025, "lat": 40.745513, "altM": 358 }, + { + "t": 1789766707000, + "lon": -73.989977, + "lat": 40.745233, + "altM": 358 + }, + { "t": 1789766708000, "lon": -73.98974, "lat": 40.744918, "altM": 358 }, + { + "t": 1789766709000, + "lon": -73.989415, + "lat": 40.744731, + "altM": 358 + }, + { + "t": 1789766710000, + "lon": -73.989045, + "lat": 40.744407, + "altM": 358 + }, + { + "t": 1789766711000, + "lon": -73.988659, + "lat": 40.744211, + "altM": 358 + }, + { + "t": 1789766712000, + "lon": -73.988428, + "lat": 40.744054, + "altM": 358 + }, + { + "t": 1789766713000, + "lon": -73.987935, + "lat": 40.743793, + "altM": 358 + }, + { + "t": 1789766714000, + "lon": -73.987429, + "lat": 40.743684, + "altM": 358 + }, + { + "t": 1789766715000, + "lon": -73.986955, + "lat": 40.743561, + "altM": 358 + }, + { + "t": 1789766716000, + "lon": -73.986498, + "lat": 40.743535, + "altM": 358 + }, + { "t": 1789766717000, "lon": -73.98611, "lat": 40.743433, "altM": 358 }, + { + "t": 1789766718000, + "lon": -73.985572, + "lat": 40.743392, + "altM": 358 + }, + { + "t": 1789766719000, + "lon": -73.985084, + "lat": 40.743343, + "altM": 358 + }, + { + "t": 1789766720000, + "lon": -73.984722, + "lat": 40.743363, + "altM": 358 + }, + { + "t": 1789766721000, + "lon": -73.984255, + "lat": 40.743431, + "altM": 358 + }, + { + "t": 1789766722000, + "lon": -73.983735, + "lat": 40.743504, + "altM": 358 + }, + { + "t": 1789766723000, + "lon": -73.983234, + "lat": 40.743583, + "altM": 358 + }, + { + "t": 1789766724000, + "lon": -73.982999, + "lat": 40.743807, + "altM": 358 + }, + { + "t": 1789766725000, + "lon": -73.982445, + "lat": 40.743905, + "altM": 358 + }, + { + "t": 1789766726000, + "lon": -73.982205, + "lat": 40.744051, + "altM": 358 + }, + { "t": 1789766727000, "lon": -73.981788, "lat": 40.74428, "altM": 358 }, + { + "t": 1789766728000, + "lon": -73.981443, + "lat": 40.744379, + "altM": 358 + }, + { "t": 1789766729000, "lon": -73.981152, "lat": 40.74465, "altM": 358 }, + { "t": 1789766730000, "lon": -73.980904, "lat": 40.74485, "altM": 358 }, + { + "t": 1789766731000, + "lon": -73.980682, + "lat": 40.745228, + "altM": 358 + }, + { "t": 1789766732000, "lon": -73.98035, "lat": 40.745389, "altM": 358 }, + { + "t": 1789766733000, + "lon": -73.980189, + "lat": 40.745641, + "altM": 358 + }, + { + "t": 1789766734000, + "lon": -73.980084, + "lat": 40.745939, + "altM": 358 + }, + { "t": 1789766735000, "lon": -73.97985, "lat": 40.746214, "altM": 358 }, + { + "t": 1789766736000, + "lon": -73.979724, + "lat": 40.746494, + "altM": 358 + }, + { + "t": 1789766737000, + "lon": -73.979691, + "lat": 40.746831, + "altM": 358 + }, + { + "t": 1789766738000, + "lon": -73.979545, + "lat": 40.747034, + "altM": 358 + }, + { + "t": 1789766739000, + "lon": -73.979439, + "lat": 40.747286, + "altM": 358 + }, + { + "t": 1789766740000, + "lon": -73.979504, + "lat": 40.747585, + "altM": 358 + }, + { + "t": 1789766741000, + "lon": -73.979424, + "lat": 40.747846, + "altM": 358 + }, + { + "t": 1789766742000, + "lon": -73.979583, + "lat": 40.748117, + "altM": 358 + }, + { "t": 1789766743000, "lon": -73.979527, "lat": 40.74838, "altM": 358 }, + { + "t": 1789766744000, + "lon": -73.979692, + "lat": 40.748628, + "altM": 358 + }, + { + "t": 1789766745000, + "lon": -73.979653, + "lat": 40.748933, + "altM": 358 + }, + { "t": 1789766746000, "lon": -73.979872, "lat": 40.7491, "altM": 358 }, + { + "t": 1789766747000, + "lon": -73.979882, + "lat": 40.749402, + "altM": 358 + }, + { + "t": 1789766748000, + "lon": -73.980024, + "lat": 40.749611, + "altM": 358 + }, + { + "t": 1789766749000, + "lon": -73.980179, + "lat": 40.749809, + "altM": 358 + }, + { "t": 1789766750000, "lon": -73.98033, "lat": 40.750058, "altM": 358 }, + { "t": 1789766751000, "lon": -73.98055, "lat": 40.750209, "altM": 358 }, + { + "t": 1789766752000, + "lon": -73.980725, + "lat": 40.750505, + "altM": 358 + }, + { + "t": 1789766753000, + "lon": -73.980905, + "lat": 40.750607, + "altM": 358 + }, + { + "t": 1789766754000, + "lon": -73.981054, + "lat": 40.750776, + "altM": 358 + }, + { + "t": 1789766755000, + "lon": -73.981347, + "lat": 40.750925, + "altM": 358 + }, + { + "t": 1789766756000, + "lon": -73.981516, + "lat": 40.751129, + "altM": 358 + }, + { "t": 1789766757000, "lon": -73.981805, "lat": 40.75128, "altM": 358 }, + { + "t": 1789766758000, + "lon": -73.981946, + "lat": 40.751377, + "altM": 358 + }, + { + "t": 1789766759000, + "lon": -73.982316, + "lat": 40.751513, + "altM": 358 + }, + { + "t": 1789766760000, + "lon": -73.982523, + "lat": 40.751652, + "altM": 358 + }, + { + "t": 1789766761000, + "lon": -73.982788, + "lat": 40.751756, + "altM": 358 + }, + { + "t": 1789766762000, + "lon": -73.983061, + "lat": 40.751833, + "altM": 358 + }, + { + "t": 1789766763000, + "lon": -73.983313, + "lat": 40.751945, + "altM": 351 + }, + { "t": 1789766764000, "lon": -73.98373, "lat": 40.751964, "altM": 351 }, + { "t": 1789766765000, "lon": -73.98404, "lat": 40.752073, "altM": 351 }, + { + "t": 1789766766000, + "lon": -73.984213, + "lat": 40.752213, + "altM": 351 + }, + { "t": 1789766767000, "lon": -73.98462, "lat": 40.752174, "altM": 351 }, + { + "t": 1789766768000, + "lon": -73.984839, + "lat": 40.752169, + "altM": 351 + }, + { + "t": 1789766769000, + "lon": -73.985197, + "lat": 40.752144, + "altM": 351 + }, + { + "t": 1789766770000, + "lon": -73.985504, + "lat": 40.752255, + "altM": 351 + }, + { "t": 1789766771000, "lon": -73.98585, "lat": 40.752223, "altM": 351 }, + { + "t": 1789766772000, + "lon": -73.986079, + "lat": 40.752156, + "altM": 351 + }, + { "t": 1789766773000, "lon": -73.98644, "lat": 40.75212, "altM": 351 }, + { + "t": 1789766774000, + "lon": -73.986715, + "lat": 40.752108, + "altM": 351 + }, + { + "t": 1789766775000, + "lon": -73.987072, + "lat": 40.751975, + "altM": 351 + }, + { "t": 1789766776000, "lon": -73.98736, "lat": 40.751887, "altM": 351 }, + { + "t": 1789766777000, + "lon": -73.987659, + "lat": 40.751877, + "altM": 351 + }, + { + "t": 1789766778000, + "lon": -73.987879, + "lat": 40.751653, + "altM": 351 + }, + { + "t": 1789766779000, + "lon": -73.988203, + "lat": 40.751631, + "altM": 351 + }, + { + "t": 1789766780000, + "lon": -73.988395, + "lat": 40.751432, + "altM": 351 + }, + { + "t": 1789766781000, + "lon": -73.988792, + "lat": 40.751282, + "altM": 351 + }, + { + "t": 1789766782000, + "lon": -73.989093, + "lat": 40.751182, + "altM": 351 + }, + { + "t": 1789766783000, + "lon": -73.989284, + "lat": 40.750947, + "altM": 351 + }, + { + "t": 1789766784000, + "lon": -73.989516, + "lat": 40.750715, + "altM": 351 + }, + { + "t": 1789766785000, + "lon": -73.989722, + "lat": 40.750579, + "altM": 351 + }, + { + "t": 1789766786000, + "lon": -73.989971, + "lat": 40.750374, + "altM": 351 + }, + { + "t": 1789766787000, + "lon": -73.990155, + "lat": 40.750123, + "altM": 351 + }, + { + "t": 1789766788000, + "lon": -73.990351, + "lat": 40.749859, + "altM": 351 + }, + { "t": 1789766789000, "lon": -73.99052, "lat": 40.749555, "altM": 351 }, + { + "t": 1789766790000, + "lon": -73.990634, + "lat": 40.749257, + "altM": 351 + }, + { + "t": 1789766791000, + "lon": -73.990686, + "lat": 40.749017, + "altM": 351 + }, + { + "t": 1789766792000, + "lon": -73.990764, + "lat": 40.748691, + "altM": 351 + }, + { "t": 1789766793000, "lon": -73.990865, "lat": 40.74839, "altM": 351 }, + { + "t": 1789766794000, + "lon": -73.990812, + "lat": 40.748134, + "altM": 351 + }, + { "t": 1789766795000, "lon": -73.99083, "lat": 40.747845, "altM": 351 }, + { + "t": 1789766796000, + "lon": -73.990757, + "lat": 40.747417, + "altM": 351 + }, + { + "t": 1789766797000, + "lon": -73.990781, + "lat": 40.747143, + "altM": 351 + }, + { + "t": 1789766798000, + "lon": -73.990617, + "lat": 40.746801, + "altM": 351 + }, + { "t": 1789766799000, "lon": -73.990616, "lat": 40.74653, "altM": 343 }, + { + "t": 1789766800000, + "lon": -73.990428, + "lat": 40.746282, + "altM": 343 + }, + { + "t": 1789766801000, + "lon": -73.990088, + "lat": 40.745855, + "altM": 343 + }, + { + "t": 1789766802000, + "lon": -73.989869, + "lat": 40.745594, + "altM": 343 + }, + { + "t": 1789766803000, + "lon": -73.989549, + "lat": 40.745263, + "altM": 343 + }, + { + "t": 1789766804000, + "lon": -73.989229, + "lat": 40.745012, + "altM": 343 + }, + { + "t": 1789766805000, + "lon": -73.988872, + "lat": 40.744814, + "altM": 343 + }, + { + "t": 1789766806000, + "lon": -73.988558, + "lat": 40.744543, + "altM": 343 + }, + { + "t": 1789766807000, + "lon": -73.988218, + "lat": 40.744451, + "altM": 343 + }, + { + "t": 1789766808000, + "lon": -73.987788, + "lat": 40.744241, + "altM": 343 + }, + { + "t": 1789766809000, + "lon": -73.987391, + "lat": 40.743985, + "altM": 343 + }, + { + "t": 1789766810000, + "lon": -73.986815, + "lat": 40.743889, + "altM": 343 + }, + { + "t": 1789766811000, + "lon": -73.986431, + "lat": 40.743821, + "altM": 343 + }, + { + "t": 1789766812000, + "lon": -73.985999, + "lat": 40.743777, + "altM": 343 + }, + { "t": 1789766813000, "lon": -73.985554, "lat": 40.74372, "altM": 343 }, + { + "t": 1789766814000, + "lon": -73.985013, + "lat": 40.743684, + "altM": 343 + }, + { + "t": 1789766815000, + "lon": -73.984583, + "lat": 40.743745, + "altM": 343 + }, + { + "t": 1789766816000, + "lon": -73.984133, + "lat": 40.743756, + "altM": 343 + }, + { "t": 1789766817000, "lon": -73.98368, "lat": 40.743779, "altM": 343 }, + { + "t": 1789766818000, + "lon": -73.983249, + "lat": 40.743929, + "altM": 343 + }, + { + "t": 1789766819000, + "lon": -73.982768, + "lat": 40.744014, + "altM": 343 + }, + { + "t": 1789766820000, + "lon": -73.982336, + "lat": 40.744202, + "altM": 343 + }, + { + "t": 1789766821000, + "lon": -73.982006, + "lat": 40.744335, + "altM": 343 + }, + { "t": 1789766822000, "lon": -73.981579, "lat": 40.74451, "altM": 343 }, + { "t": 1789766823000, "lon": -73.98126, "lat": 40.744693, "altM": 343 }, + { + "t": 1789766824000, + "lon": -73.981029, + "lat": 40.744875, + "altM": 343 + }, + { + "t": 1789766825000, + "lon": -73.980812, + "lat": 40.745216, + "altM": 343 + }, + { + "t": 1789766826000, + "lon": -73.980461, + "lat": 40.745416, + "altM": 343 + }, + { + "t": 1789766827000, + "lon": -73.980336, + "lat": 40.745694, + "altM": 343 + }, + { + "t": 1789766828000, + "lon": -73.980092, + "lat": 40.745955, + "altM": 343 + }, + { + "t": 1789766829000, + "lon": -73.979921, + "lat": 40.746245, + "altM": 343 + }, + { + "t": 1789766830000, + "lon": -73.979962, + "lat": 40.746446, + "altM": 343 + }, + { + "t": 1789766831000, + "lon": -73.979841, + "lat": 40.746801, + "altM": 343 + }, + { "t": 1789766832000, "lon": -73.979911, "lat": 40.74706, "altM": 343 }, + { "t": 1789766833000, "lon": -73.97989, "lat": 40.747319, "altM": 343 }, + { + "t": 1789766834000, + "lon": -73.979816, + "lat": 40.747592, + "altM": 343 + }, + { + "t": 1789766835000, + "lon": -73.979931, + "lat": 40.747842, + "altM": 343 + }, + { + "t": 1789766836000, + "lon": -73.979933, + "lat": 40.748116, + "altM": 343 + }, + { "t": 1789766837000, "lon": -73.98014, "lat": 40.748355, "altM": 343 }, + { + "t": 1789766838000, + "lon": -73.980124, + "lat": 40.748596, + "altM": 343 + }, + { + "t": 1789766839000, + "lon": -73.980323, + "lat": 40.748743, + "altM": 343 + }, + { + "t": 1789766840000, + "lon": -73.980299, + "lat": 40.749022, + "altM": 343 + }, + { + "t": 1789766841000, + "lon": -73.980441, + "lat": 40.749353, + "altM": 343 + }, + { "t": 1789766842000, "lon": -73.980605, "lat": 40.7495, "altM": 343 }, + { + "t": 1789766843000, + "lon": -73.980803, + "lat": 40.749767, + "altM": 343 + }, + { + "t": 1789766844000, + "lon": -73.980899, + "lat": 40.749904, + "altM": 343 + }, + { "t": 1789766845000, "lon": -73.98112, "lat": 40.750226, "altM": 343 }, + { + "t": 1789766846000, + "lon": -73.981289, + "lat": 40.750449, + "altM": 343 + }, + { + "t": 1789766847000, + "lon": -73.981468, + "lat": 40.750568, + "altM": 343 + }, + { + "t": 1789766848000, + "lon": -73.981733, + "lat": 40.750728, + "altM": 343 + }, + { + "t": 1789766849000, + "lon": -73.981903, + "lat": 40.750911, + "altM": 343 + }, + { + "t": 1789766850000, + "lon": -73.982313, + "lat": 40.751061, + "altM": 343 + }, + { + "t": 1789766851000, + "lon": -73.982423, + "lat": 40.751159, + "altM": 343 + }, + { + "t": 1789766852000, + "lon": -73.982636, + "lat": 40.751304, + "altM": 343 + }, + { + "t": 1789766853000, + "lon": -73.982973, + "lat": 40.751404, + "altM": 343 + }, + { + "t": 1789766854000, + "lon": -73.983207, + "lat": 40.751562, + "altM": 343 + }, + { + "t": 1789766855000, + "lon": -73.983478, + "lat": 40.751636, + "altM": 343 + }, + { + "t": 1789766856000, + "lon": -73.983778, + "lat": 40.751719, + "altM": 343 + }, + { + "t": 1789766857000, + "lon": -73.984169, + "lat": 40.751794, + "altM": 343 + }, + { + "t": 1789766858000, + "lon": -73.984419, + "lat": 40.751787, + "altM": 343 + }, + { + "t": 1789766859000, + "lon": -73.984615, + "lat": 40.751827, + "altM": 343 + }, + { + "t": 1789766860000, + "lon": -73.984947, + "lat": 40.751869, + "altM": 343 + }, + { "t": 1789766861000, "lon": -73.98532, "lat": 40.751838, "altM": 343 }, + { + "t": 1789766862000, + "lon": -73.985562, + "lat": 40.751841, + "altM": 343 + }, + { + "t": 1789766863000, + "lon": -73.985878, + "lat": 40.751825, + "altM": 343 + }, + { + "t": 1789766864000, + "lon": -73.986183, + "lat": 40.751844, + "altM": 343 + }, + { + "t": 1789766865000, + "lon": -73.986542, + "lat": 40.751808, + "altM": 343 + }, + { + "t": 1789766866000, + "lon": -73.986827, + "lat": 40.751684, + "altM": 343 + }, + { "t": 1789766867000, "lon": -73.987169, "lat": 40.75169, "altM": 343 }, + { + "t": 1789766868000, + "lon": -73.987515, + "lat": 40.751599, + "altM": 343 + }, + { + "t": 1789766869000, + "lon": -73.987736, + "lat": 40.751453, + "altM": 343 + }, + { + "t": 1789766870000, + "lon": -73.988088, + "lat": 40.751342, + "altM": 343 + }, + { + "t": 1789766871000, + "lon": -73.988281, + "lat": 40.751197, + "altM": 343 + }, + { + "t": 1789766872000, + "lon": -73.988622, + "lat": 40.751134, + "altM": 343 + }, + { + "t": 1789766873000, + "lon": -73.988913, + "lat": 40.750907, + "altM": 343 + }, + { + "t": 1789766874000, + "lon": -73.989125, + "lat": 40.750716, + "altM": 343 + }, + { + "t": 1789766875000, + "lon": -73.989322, + "lat": 40.750493, + "altM": 343 + }, + { + "t": 1789766876000, + "lon": -73.989612, + "lat": 40.750327, + "altM": 343 + }, + { + "t": 1789766877000, + "lon": -73.989767, + "lat": 40.750015, + "altM": 343 + }, + { + "t": 1789766878000, + "lon": -73.989918, + "lat": 40.749949, + "altM": 343 + }, + { + "t": 1789766879000, + "lon": -73.990148, + "lat": 40.749603, + "altM": 351 + }, + { "t": 1789766880000, "lon": -73.99031, "lat": 40.74929, "altM": 351 }, + { + "t": 1789766881000, + "lon": -73.990465, + "lat": 40.749062, + "altM": 351 + }, + { "t": 1789766882000, "lon": -73.99053, "lat": 40.748809, "altM": 351 }, + { + "t": 1789766883000, + "lon": -73.990643, + "lat": 40.748534, + "altM": 351 + }, + { + "t": 1789766884000, + "lon": -73.990653, + "lat": 40.748186, + "altM": 351 + }, + { + "t": 1789766885000, + "lon": -73.990621, + "lat": 40.747923, + "altM": 351 + }, + { "t": 1789766886000, "lon": -73.99062, "lat": 40.747551, "altM": 351 }, + { + "t": 1789766887000, + "lon": -73.990566, + "lat": 40.747194, + "altM": 351 + }, + { + "t": 1789766888000, + "lon": -73.990474, + "lat": 40.746891, + "altM": 351 + }, + { + "t": 1789766889000, + "lon": -73.990333, + "lat": 40.746638, + "altM": 351 + }, + { + "t": 1789766890000, + "lon": -73.990231, + "lat": 40.746293, + "altM": 351 + }, + { + "t": 1789766891000, + "lon": -73.990008, + "lat": 40.746027, + "altM": 351 + }, + { + "t": 1789766892000, + "lon": -73.989787, + "lat": 40.745632, + "altM": 351 + }, + { "t": 1789766893000, "lon": -73.98941, "lat": 40.745381, "altM": 351 }, + { + "t": 1789766894000, + "lon": -73.989207, + "lat": 40.745195, + "altM": 351 + }, + { + "t": 1789766895000, + "lon": -73.988883, + "lat": 40.744876, + "altM": 351 + }, + { + "t": 1789766896000, + "lon": -73.988508, + "lat": 40.744624, + "altM": 351 + }, + { + "t": 1789766897000, + "lon": -73.988147, + "lat": 40.744395, + "altM": 351 + }, + { + "t": 1789766898000, + "lon": -73.987651, + "lat": 40.744278, + "altM": 351 + }, + { + "t": 1789766899000, + "lon": -73.987315, + "lat": 40.744027, + "altM": 351 + }, + { + "t": 1789766900000, + "lon": -73.986818, + "lat": 40.743919, + "altM": 351 + }, + { + "t": 1789766901000, + "lon": -73.986398, + "lat": 40.743878, + "altM": 351 + }, + { + "t": 1789766902000, + "lon": -73.985864, + "lat": 40.743801, + "altM": 351 + }, + { + "t": 1789766903000, + "lon": -73.985472, + "lat": 40.743622, + "altM": 351 + }, + { "t": 1789766904000, "lon": -73.984935, "lat": 40.74367, "altM": 351 }, + { + "t": 1789766905000, + "lon": -73.984517, + "lat": 40.743635, + "altM": 351 + }, + { + "t": 1789766906000, + "lon": -73.984035, + "lat": 40.743683, + "altM": 351 + }, + { + "t": 1789766907000, + "lon": -73.983587, + "lat": 40.743812, + "altM": 351 + }, + { + "t": 1789766908000, + "lon": -73.983228, + "lat": 40.743826, + "altM": 351 + }, + { "t": 1789766909000, "lon": -73.982718, "lat": 40.74389, "altM": 351 }, + { + "t": 1789766910000, + "lon": -73.982325, + "lat": 40.744074, + "altM": 351 + }, + { + "t": 1789766911000, + "lon": -73.981861, + "lat": 40.744283, + "altM": 351 + }, + { + "t": 1789766912000, + "lon": -73.981553, + "lat": 40.744388, + "altM": 351 + }, + { + "t": 1789766913000, + "lon": -73.981165, + "lat": 40.744653, + "altM": 351 + }, + { + "t": 1789766914000, + "lon": -73.980903, + "lat": 40.744819, + "altM": 351 + }, + { + "t": 1789766915000, + "lon": -73.980654, + "lat": 40.745083, + "altM": 358 + }, + { "t": 1789766916000, "lon": -73.980324, "lat": 40.74533, "altM": 358 }, + { "t": 1789766917000, "lon": -73.98017, "lat": 40.745668, "altM": 358 }, + { + "t": 1789766918000, + "lon": -73.980005, + "lat": 40.745843, + "altM": 358 + }, + { + "t": 1789766919000, + "lon": -73.979901, + "lat": 40.746075, + "altM": 358 + }, + { + "t": 1789766920000, + "lon": -73.979867, + "lat": 40.746413, + "altM": 358 + }, + { + "t": 1789766921000, + "lon": -73.979679, + "lat": 40.746689, + "altM": 358 + }, + { + "t": 1789766922000, + "lon": -73.979723, + "lat": 40.746957, + "altM": 358 + }, + { + "t": 1789766923000, + "lon": -73.979634, + "lat": 40.747228, + "altM": 358 + }, + { + "t": 1789766924000, + "lon": -73.979723, + "lat": 40.747508, + "altM": 358 + }, + { + "t": 1789766925000, + "lon": -73.979703, + "lat": 40.747732, + "altM": 358 + }, + { + "t": 1789766926000, + "lon": -73.979792, + "lat": 40.748019, + "altM": 358 + }, + { + "t": 1789766927000, + "lon": -73.979836, + "lat": 40.748299, + "altM": 358 + }, + { + "t": 1789766928000, + "lon": -73.979804, + "lat": 40.748486, + "altM": 358 + }, + { "t": 1789766929000, "lon": -73.97997, "lat": 40.748806, "altM": 358 }, + { + "t": 1789766930000, + "lon": -73.979924, + "lat": 40.748972, + "altM": 358 + }, + { + "t": 1789766931000, + "lon": -73.980149, + "lat": 40.749262, + "altM": 358 + }, + { + "t": 1789766932000, + "lon": -73.980135, + "lat": 40.749556, + "altM": 358 + }, + { + "t": 1789766933000, + "lon": -73.980327, + "lat": 40.749724, + "altM": 358 + }, + { + "t": 1789766934000, + "lon": -73.980489, + "lat": 40.749944, + "altM": 358 + }, + { + "t": 1789766935000, + "lon": -73.980661, + "lat": 40.750198, + "altM": 358 + }, + { + "t": 1789766936000, + "lon": -73.980805, + "lat": 40.750415, + "altM": 358 + }, + { + "t": 1789766937000, + "lon": -73.980967, + "lat": 40.750556, + "altM": 358 + }, + { + "t": 1789766938000, + "lon": -73.981235, + "lat": 40.750706, + "altM": 358 + }, + { + "t": 1789766939000, + "lon": -73.981422, + "lat": 40.750816, + "altM": 358 + }, + { + "t": 1789766940000, + "lon": -73.981658, + "lat": 40.751068, + "altM": 358 + }, + { + "t": 1789766941000, + "lon": -73.981811, + "lat": 40.751262, + "altM": 358 + }, + { + "t": 1789766942000, + "lon": -73.982133, + "lat": 40.751389, + "altM": 358 + }, + { "t": 1789766943000, "lon": -73.98233, "lat": 40.751462, "altM": 358 }, + { + "t": 1789766944000, + "lon": -73.982687, + "lat": 40.751648, + "altM": 358 + }, + { + "t": 1789766945000, + "lon": -73.982924, + "lat": 40.751716, + "altM": 358 + }, + { + "t": 1789766946000, + "lon": -73.983147, + "lat": 40.751823, + "altM": 358 + }, + { + "t": 1789766947000, + "lon": -73.983537, + "lat": 40.751958, + "altM": 358 + }, + { + "t": 1789766948000, + "lon": -73.983733, + "lat": 40.751952, + "altM": 358 + }, + { "t": 1789766949000, "lon": -73.984112, "lat": 40.75205, "altM": 358 }, + { + "t": 1789766950000, + "lon": -73.984316, + "lat": 40.752145, + "altM": 358 + }, + { + "t": 1789766951000, + "lon": -73.984632, + "lat": 40.752211, + "altM": 358 + }, + { + "t": 1789766952000, + "lon": -73.985064, + "lat": 40.752212, + "altM": 358 + }, + { + "t": 1789766953000, + "lon": -73.985238, + "lat": 40.752268, + "altM": 358 + }, + { + "t": 1789766954000, + "lon": -73.985594, + "lat": 40.752203, + "altM": 358 + }, + { "t": 1789766955000, "lon": -73.985898, "lat": 40.75228, "altM": 358 }, + { + "t": 1789766956000, + "lon": -73.986229, + "lat": 40.752173, + "altM": 358 + }, + { + "t": 1789766957000, + "lon": -73.986519, + "lat": 40.752145, + "altM": 358 + }, + { + "t": 1789766958000, + "lon": -73.986811, + "lat": 40.752129, + "altM": 358 + }, + { + "t": 1789766959000, + "lon": -73.987094, + "lat": 40.752071, + "altM": 358 + }, + { + "t": 1789766960000, + "lon": -73.987457, + "lat": 40.751963, + "altM": 358 + }, + { + "t": 1789766961000, + "lon": -73.987681, + "lat": 40.751942, + "altM": 358 + }, + { + "t": 1789766962000, + "lon": -73.988083, + "lat": 40.751886, + "altM": 358 + }, + { + "t": 1789766963000, + "lon": -73.988329, + "lat": 40.751749, + "altM": 358 + }, + { + "t": 1789766964000, + "lon": -73.988654, + "lat": 40.751508, + "altM": 358 + }, + { + "t": 1789766965000, + "lon": -73.988918, + "lat": 40.751445, + "altM": 358 + }, + { + "t": 1789766966000, + "lon": -73.989181, + "lat": 40.751255, + "altM": 358 + }, + { + "t": 1789766967000, + "lon": -73.989368, + "lat": 40.751097, + "altM": 358 + }, + { + "t": 1789766968000, + "lon": -73.989696, + "lat": 40.750902, + "altM": 358 + }, + { + "t": 1789766969000, + "lon": -73.989899, + "lat": 40.750751, + "altM": 358 + }, + { + "t": 1789766970000, + "lon": -73.990137, + "lat": 40.750479, + "altM": 358 + }, + { + "t": 1789766971000, + "lon": -73.990297, + "lat": 40.750307, + "altM": 358 + }, + { + "t": 1789766972000, + "lon": -73.990577, + "lat": 40.749995, + "altM": 358 + }, + { + "t": 1789766973000, + "lon": -73.990733, + "lat": 40.749739, + "altM": 358 + }, + { + "t": 1789766974000, + "lon": -73.990764, + "lat": 40.749528, + "altM": 358 + }, + { "t": 1789766975000, "lon": -73.99098, "lat": 40.749278, "altM": 358 }, + { + "t": 1789766976000, + "lon": -73.990985, + "lat": 40.748914, + "altM": 358 + }, + { + "t": 1789766977000, + "lon": -73.991095, + "lat": 40.748697, + "altM": 358 + }, + { + "t": 1789766978000, + "lon": -73.991129, + "lat": 40.748396, + "altM": 358 + }, + { + "t": 1789766979000, + "lon": -73.991267, + "lat": 40.748073, + "altM": 358 + }, + { "t": 1789766980000, "lon": -73.99117, "lat": 40.747711, "altM": 358 }, + { + "t": 1789766981000, + "lon": -73.991165, + "lat": 40.747481, + "altM": 358 + }, + { + "t": 1789766982000, + "lon": -73.991091, + "lat": 40.747106, + "altM": 358 + }, + { + "t": 1789766983000, + "lon": -73.990977, + "lat": 40.746773, + "altM": 358 + }, + { "t": 1789766984000, "lon": -73.99092, "lat": 40.746485, "altM": 358 }, + { "t": 1789766985000, "lon": -73.990716, "lat": 40.74616, "altM": 358 }, + { + "t": 1789766986000, + "lon": -73.990453, + "lat": 40.745852, + "altM": 358 + }, + { + "t": 1789766987000, + "lon": -73.990289, + "lat": 40.745569, + "altM": 358 + }, + { + "t": 1789766988000, + "lon": -73.989977, + "lat": 40.745246, + "altM": 358 + }, + { + "t": 1789766989000, + "lon": -73.989758, + "lat": 40.744959, + "altM": 358 + }, + { + "t": 1789766990000, + "lon": -73.989382, + "lat": 40.744762, + "altM": 358 + }, + { + "t": 1789766991000, + "lon": -73.989104, + "lat": 40.744502, + "altM": 358 + }, + { + "t": 1789766992000, + "lon": -73.988749, + "lat": 40.744212, + "altM": 358 + }, + { + "t": 1789766993000, + "lon": -73.988285, + "lat": 40.744032, + "altM": 358 + }, + { + "t": 1789766994000, + "lon": -73.987916, + "lat": 40.743807, + "altM": 351 + }, + { + "t": 1789766995000, + "lon": -73.987458, + "lat": 40.743735, + "altM": 351 + }, + { + "t": 1789766996000, + "lon": -73.986999, + "lat": 40.743568, + "altM": 351 + }, + { + "t": 1789766997000, + "lon": -73.986611, + "lat": 40.743494, + "altM": 351 + }, + { + "t": 1789766998000, + "lon": -73.986106, + "lat": 40.743454, + "altM": 351 + }, + { + "t": 1789766999000, + "lon": -73.985535, + "lat": 40.743367, + "altM": 351 + }, + { + "t": 1789767000000, + "lon": -73.985265, + "lat": 40.743377, + "altM": 351 + }, + { + "t": 1789767001000, + "lon": -73.984713, + "lat": 40.743393, + "altM": 351 + }, + { + "t": 1789767002000, + "lon": -73.984345, + "lat": 40.743414, + "altM": 351 + }, + { + "t": 1789767003000, + "lon": -73.983757, + "lat": 40.743488, + "altM": 351 + }, + { + "t": 1789767004000, + "lon": -73.983336, + "lat": 40.743588, + "altM": 351 + }, + { + "t": 1789767005000, + "lon": -73.982975, + "lat": 40.743691, + "altM": 351 + }, + { + "t": 1789767006000, + "lon": -73.982486, + "lat": 40.743894, + "altM": 351 + }, + { + "t": 1789767007000, + "lon": -73.982131, + "lat": 40.744061, + "altM": 351 + }, + { + "t": 1789767008000, + "lon": -73.981814, + "lat": 40.744195, + "altM": 351 + }, + { + "t": 1789767009000, + "lon": -73.981443, + "lat": 40.744377, + "altM": 351 + }, + { + "t": 1789767010000, + "lon": -73.981221, + "lat": 40.744623, + "altM": 351 + }, + { + "t": 1789767011000, + "lon": -73.980873, + "lat": 40.744797, + "altM": 351 + }, + { + "t": 1789767012000, + "lon": -73.980539, + "lat": 40.745091, + "altM": 351 + }, + { "t": 1789767013000, "lon": -73.980324, "lat": 40.74542, "altM": 351 }, + { + "t": 1789767014000, + "lon": -73.980114, + "lat": 40.745537, + "altM": 351 + }, + { + "t": 1789767015000, + "lon": -73.979971, + "lat": 40.745895, + "altM": 351 + }, + { + "t": 1789767016000, + "lon": -73.979857, + "lat": 40.746187, + "altM": 351 + }, + { + "t": 1789767017000, + "lon": -73.979736, + "lat": 40.746475, + "altM": 351 + }, + { + "t": 1789767018000, + "lon": -73.979608, + "lat": 40.746744, + "altM": 351 + }, + { + "t": 1789767019000, + "lon": -73.979587, + "lat": 40.747019, + "altM": 351 + }, + { + "t": 1789767020000, + "lon": -73.979509, + "lat": 40.747218, + "altM": 351 + }, + { + "t": 1789767021000, + "lon": -73.979468, + "lat": 40.747508, + "altM": 351 + }, + { "t": 1789767022000, "lon": -73.97941, "lat": 40.747802, "altM": 351 }, + { + "t": 1789767023000, + "lon": -73.979471, + "lat": 40.748072, + "altM": 351 + }, + { + "t": 1789767024000, + "lon": -73.979536, + "lat": 40.748382, + "altM": 351 + }, + { + "t": 1789767025000, + "lon": -73.979549, + "lat": 40.748652, + "altM": 351 + }, + { "t": 1789767026000, "lon": -73.97956, "lat": 40.748885, "altM": 351 }, + { + "t": 1789767027000, + "lon": -73.979693, + "lat": 40.749143, + "altM": 351 + }, + { "t": 1789767028000, "lon": -73.97988, "lat": 40.749303, "altM": 351 }, + { + "t": 1789767029000, + "lon": -73.979952, + "lat": 40.749563, + "altM": 351 + }, + { + "t": 1789767030000, + "lon": -73.980087, + "lat": 40.749775, + "altM": 343 + }, + { "t": 1789767031000, "lon": -73.980227, "lat": 40.74996, "altM": 343 }, + { + "t": 1789767032000, + "lon": -73.980387, + "lat": 40.750146, + "altM": 343 + }, + { "t": 1789767033000, "lon": -73.98058, "lat": 40.750413, "altM": 343 }, + { + "t": 1789767034000, + "lon": -73.980775, + "lat": 40.750656, + "altM": 343 + }, + { + "t": 1789767035000, + "lon": -73.980945, + "lat": 40.750803, + "altM": 343 + }, + { "t": 1789767036000, "lon": -73.981243, "lat": 40.75089, "altM": 343 }, + { + "t": 1789767037000, + "lon": -73.981361, + "lat": 40.751103, + "altM": 343 + }, + { "t": 1789767038000, "lon": -73.981665, "lat": 40.75129, "altM": 343 }, + { + "t": 1789767039000, + "lon": -73.981918, + "lat": 40.751372, + "altM": 343 + }, + { "t": 1789767040000, "lon": -73.982116, "lat": 40.75152, "altM": 343 }, + { + "t": 1789767041000, + "lon": -73.982437, + "lat": 40.751729, + "altM": 343 + }, + { + "t": 1789767042000, + "lon": -73.982621, + "lat": 40.751843, + "altM": 343 + }, + { + "t": 1789767043000, + "lon": -73.983039, + "lat": 40.751919, + "altM": 343 + }, + { "t": 1789767044000, "lon": -73.98326, "lat": 40.752034, "altM": 343 }, + { + "t": 1789767045000, + "lon": -73.983535, + "lat": 40.752059, + "altM": 343 + }, + { "t": 1789767046000, "lon": -73.98382, "lat": 40.752146, "altM": 343 }, + { + "t": 1789767047000, + "lon": -73.984084, + "lat": 40.752086, + "altM": 343 + }, + { + "t": 1789767048000, + "lon": -73.984465, + "lat": 40.752198, + "altM": 343 + }, + { "t": 1789767049000, "lon": -73.984848, "lat": 40.75222, "altM": 343 }, + { "t": 1789767050000, "lon": -73.98505, "lat": 40.752189, "altM": 343 }, + { + "t": 1789767051000, + "lon": -73.985358, + "lat": 40.752249, + "altM": 343 + }, + { + "t": 1789767052000, + "lon": -73.985632, + "lat": 40.752294, + "altM": 343 + }, + { + "t": 1789767053000, + "lon": -73.985968, + "lat": 40.752234, + "altM": 343 + }, + { + "t": 1789767054000, + "lon": -73.986229, + "lat": 40.752201, + "altM": 343 + }, + { + "t": 1789767055000, + "lon": -73.986625, + "lat": 40.752183, + "altM": 343 + }, + { + "t": 1789767056000, + "lon": -73.986879, + "lat": 40.752113, + "altM": 343 + }, + { + "t": 1789767057000, + "lon": -73.987228, + "lat": 40.752063, + "altM": 343 + }, + { + "t": 1789767058000, + "lon": -73.987526, + "lat": 40.751966, + "altM": 343 + }, + { + "t": 1789767059000, + "lon": -73.987806, + "lat": 40.751896, + "altM": 343 + }, + { + "t": 1789767060000, + "lon": -73.988069, + "lat": 40.751783, + "altM": 343 + }, + { + "t": 1789767061000, + "lon": -73.988386, + "lat": 40.751601, + "altM": 343 + }, + { + "t": 1789767062000, + "lon": -73.988574, + "lat": 40.751462, + "altM": 343 + }, + { + "t": 1789767063000, + "lon": -73.988925, + "lat": 40.751239, + "altM": 343 + }, + { + "t": 1789767064000, + "lon": -73.989137, + "lat": 40.751144, + "altM": 343 + }, + { + "t": 1789767065000, + "lon": -73.989425, + "lat": 40.750958, + "altM": 343 + }, + { + "t": 1789767066000, + "lon": -73.989606, + "lat": 40.750761, + "altM": 343 + }, + { + "t": 1789767067000, + "lon": -73.989836, + "lat": 40.750567, + "altM": 343 + }, + { + "t": 1789767068000, + "lon": -73.990084, + "lat": 40.750232, + "altM": 343 + }, + { + "t": 1789767069000, + "lon": -73.990292, + "lat": 40.750053, + "altM": 343 + }, + { + "t": 1789767070000, + "lon": -73.990433, + "lat": 40.749863, + "altM": 343 + }, + { "t": 1789767071000, "lon": -73.990604, "lat": 40.74953, "altM": 343 }, + { "t": 1789767072000, "lon": -73.990703, "lat": 40.74931, "altM": 343 }, + { + "t": 1789767073000, + "lon": -73.990801, + "lat": 40.748945, + "altM": 343 + }, + { + "t": 1789767074000, + "lon": -73.990827, + "lat": 40.748715, + "altM": 343 + }, + { "t": 1789767075000, "lon": -73.991001, "lat": 40.74837, "altM": 343 }, + { + "t": 1789767076000, + "lon": -73.990818, + "lat": 40.748104, + "altM": 343 + }, + { + "t": 1789767077000, + "lon": -73.991004, + "lat": 40.747775, + "altM": 343 + }, + { + "t": 1789767078000, + "lon": -73.990902, + "lat": 40.747419, + "altM": 343 + }, + { + "t": 1789767079000, + "lon": -73.990807, + "lat": 40.747087, + "altM": 343 + }, + { "t": 1789767080000, "lon": -73.99071, "lat": 40.746783, "altM": 343 }, + { + "t": 1789767081000, + "lon": -73.990504, + "lat": 40.746529, + "altM": 343 + }, + { + "t": 1789767082000, + "lon": -73.990278, + "lat": 40.746205, + "altM": 343 + }, + { + "t": 1789767083000, + "lon": -73.990136, + "lat": 40.745884, + "altM": 343 + }, + { + "t": 1789767084000, + "lon": -73.989897, + "lat": 40.745566, + "altM": 343 + }, + { + "t": 1789767085000, + "lon": -73.989621, + "lat": 40.745305, + "altM": 343 + }, + { + "t": 1789767086000, + "lon": -73.989335, + "lat": 40.744989, + "altM": 343 + }, + { + "t": 1789767087000, + "lon": -73.988903, + "lat": 40.744823, + "altM": 343 + }, + { + "t": 1789767088000, + "lon": -73.988616, + "lat": 40.744609, + "altM": 343 + }, + { + "t": 1789767089000, + "lon": -73.988301, + "lat": 40.744343, + "altM": 343 + }, + { + "t": 1789767090000, + "lon": -73.987886, + "lat": 40.744222, + "altM": 343 + }, + { + "t": 1789767091000, + "lon": -73.987456, + "lat": 40.744034, + "altM": 343 + }, + { + "t": 1789767092000, + "lon": -73.986973, + "lat": 40.743876, + "altM": 343 + }, + { "t": 1789767093000, "lon": -73.98651, "lat": 40.743721, "altM": 343 }, + { + "t": 1789767094000, + "lon": -73.986071, + "lat": 40.743713, + "altM": 343 + }, + { + "t": 1789767095000, + "lon": -73.985615, + "lat": 40.743642, + "altM": 343 + }, + { + "t": 1789767096000, + "lon": -73.985133, + "lat": 40.743638, + "altM": 343 + }, + { + "t": 1789767097000, + "lon": -73.984624, + "lat": 40.743639, + "altM": 343 + }, + { "t": 1789767098000, "lon": -73.984085, "lat": 40.74373, "altM": 343 }, + { + "t": 1789767099000, + "lon": -73.983742, + "lat": 40.743777, + "altM": 343 + }, + { + "t": 1789767100000, + "lon": -73.983272, + "lat": 40.743872, + "altM": 343 + }, + { "t": 1789767101000, "lon": -73.98281, "lat": 40.743962, "altM": 343 }, + { + "t": 1789767102000, + "lon": -73.982404, + "lat": 40.744082, + "altM": 343 + }, + { + "t": 1789767103000, + "lon": -73.982097, + "lat": 40.744381, + "altM": 343 + }, + { + "t": 1789767104000, + "lon": -73.981721, + "lat": 40.744418, + "altM": 343 + }, + { "t": 1789767105000, "lon": -73.9814, "lat": 40.744661, "altM": 343 }, + { + "t": 1789767106000, + "lon": -73.981074, + "lat": 40.744938, + "altM": 343 + }, + { + "t": 1789767107000, + "lon": -73.980879, + "lat": 40.745178, + "altM": 343 + }, + { + "t": 1789767108000, + "lon": -73.980568, + "lat": 40.745419, + "altM": 343 + }, + { "t": 1789767109000, "lon": -73.9804, "lat": 40.745625, "altM": 343 }, + { + "t": 1789767110000, + "lon": -73.980267, + "lat": 40.745911, + "altM": 343 + }, + { "t": 1789767111000, "lon": -73.980046, "lat": 40.7462, "altM": 351 }, + { + "t": 1789767112000, + "lon": -73.980025, + "lat": 40.746432, + "altM": 351 + }, + { + "t": 1789767113000, + "lon": -73.979953, + "lat": 40.746779, + "altM": 351 + }, + { "t": 1789767114000, "lon": -73.98003, "lat": 40.746987, "altM": 351 }, + { + "t": 1789767115000, + "lon": -73.979921, + "lat": 40.747224, + "altM": 351 + }, + { "t": 1789767116000, "lon": -73.979843, "lat": 40.74759, "altM": 351 }, + { "t": 1789767117000, "lon": -73.980001, "lat": 40.74779, "altM": 351 }, + { + "t": 1789767118000, + "lon": -73.980038, + "lat": 40.748035, + "altM": 351 + }, + { + "t": 1789767119000, + "lon": -73.979961, + "lat": 40.748368, + "altM": 351 + }, + { + "t": 1789767120000, + "lon": -73.980095, + "lat": 40.748592, + "altM": 351 + }, + { + "t": 1789767121000, + "lon": -73.980264, + "lat": 40.748837, + "altM": 343 + }, + { + "t": 1789767122000, + "lon": -73.980126, + "lat": 40.749063, + "altM": 343 + }, + { + "t": 1789767123000, + "lon": -73.980245, + "lat": 40.749408, + "altM": 343 + }, + { + "t": 1789767124000, + "lon": -73.980192, + "lat": 40.749556, + "altM": 335 + }, + { + "t": 1789767125000, + "lon": -73.980243, + "lat": 40.749771, + "altM": 335 + }, + { + "t": 1789767126000, + "lon": -73.980467, + "lat": 40.750023, + "altM": 335 + }, + { + "t": 1789767127000, + "lon": -73.980563, + "lat": 40.750272, + "altM": 335 + }, + { "t": 1789767128000, "lon": -73.980731, "lat": 40.75047, "altM": 335 }, + { "t": 1789767129000, "lon": -73.980847, "lat": 40.75065, "altM": 335 }, + { + "t": 1789767130000, + "lon": -73.981007, + "lat": 40.750817, + "altM": 328 + }, + { + "t": 1789767131000, + "lon": -73.981294, + "lat": 40.750993, + "altM": 328 + }, + { "t": 1789767132000, "lon": -73.9814, "lat": 40.751122, "altM": 328 }, + { + "t": 1789767133000, + "lon": -73.981633, + "lat": 40.751278, + "altM": 328 + }, + { + "t": 1789767134000, + "lon": -73.981833, + "lat": 40.751359, + "altM": 328 + }, + { + "t": 1789767135000, + "lon": -73.982101, + "lat": 40.751507, + "altM": 328 + }, + { + "t": 1789767136000, + "lon": -73.982269, + "lat": 40.751653, + "altM": 328 + }, + { + "t": 1789767137000, + "lon": -73.982565, + "lat": 40.751627, + "altM": 328 + }, + { "t": 1789767138000, "lon": -73.98275, "lat": 40.751825, "altM": 328 }, + { + "t": 1789767139000, + "lon": -73.983049, + "lat": 40.751897, + "altM": 328 + }, + { "t": 1789767140000, "lon": -73.983289, "lat": 40.75192, "altM": 328 }, + { + "t": 1789767141000, + "lon": -73.983429, + "lat": 40.751993, + "altM": 328 + }, + { + "t": 1789767142000, + "lon": -73.983747, + "lat": 40.752101, + "altM": 328 + }, + { + "t": 1789767143000, + "lon": -73.984114, + "lat": 40.752104, + "altM": 328 + }, + { + "t": 1789767144000, + "lon": -73.984361, + "lat": 40.752178, + "altM": 328 + }, + { + "t": 1789767145000, + "lon": -73.984606, + "lat": 40.752112, + "altM": 328 + }, + { + "t": 1789767146000, + "lon": -73.984935, + "lat": 40.752185, + "altM": 328 + }, + { "t": 1789767147000, "lon": -73.985092, "lat": 40.75219, "altM": 328 }, + { + "t": 1789767148000, + "lon": -73.985401, + "lat": 40.752095, + "altM": 328 + }, + { + "t": 1789767149000, + "lon": -73.985772, + "lat": 40.752109, + "altM": 328 + }, + { + "t": 1789767150000, + "lon": -73.985906, + "lat": 40.752063, + "altM": 328 + }, + { "t": 1789767151000, "lon": -73.98623, "lat": 40.752044, "altM": 328 }, + { + "t": 1789767152000, + "lon": -73.986527, + "lat": 40.751904, + "altM": 328 + }, + { "t": 1789767153000, "lon": -73.98676, "lat": 40.751881, "altM": 328 }, + { + "t": 1789767154000, + "lon": -73.986974, + "lat": 40.751756, + "altM": 328 + }, + { + "t": 1789767155000, + "lon": -73.987305, + "lat": 40.751746, + "altM": 328 + }, + { + "t": 1789767156000, + "lon": -73.987525, + "lat": 40.751529, + "altM": 328 + }, + { + "t": 1789767157000, + "lon": -73.987819, + "lat": 40.751531, + "altM": 328 + }, + { "t": 1789767158000, "lon": -73.98806, "lat": 40.751338, "altM": 328 }, + { + "t": 1789767159000, + "lon": -73.988378, + "lat": 40.751237, + "altM": 328 + }, + { + "t": 1789767160000, + "lon": -73.988586, + "lat": 40.751036, + "altM": 328 + }, + { + "t": 1789767161000, + "lon": -73.988686, + "lat": 40.750851, + "altM": 328 + }, + { + "t": 1789767162000, + "lon": -73.988874, + "lat": 40.750669, + "altM": 328 + }, + { + "t": 1789767163000, + "lon": -73.989032, + "lat": 40.750422, + "altM": 328 + }, + { + "t": 1789767164000, + "lon": -73.989269, + "lat": 40.750194, + "altM": 328 + }, + { "t": 1789767165000, "lon": -73.98938, "lat": 40.750061, "altM": 328 }, + { + "t": 1789767166000, + "lon": -73.989513, + "lat": 40.749793, + "altM": 328 + }, + { + "t": 1789767167000, + "lon": -73.989576, + "lat": 40.749558, + "altM": 328 + }, + { + "t": 1789767168000, + "lon": -73.989733, + "lat": 40.749238, + "altM": 328 + }, + { + "t": 1789767169000, + "lon": -73.989797, + "lat": 40.749004, + "altM": 328 + }, + { + "t": 1789767170000, + "lon": -73.989876, + "lat": 40.748748, + "altM": 328 + }, + { "t": 1789767171000, "lon": -73.989836, "lat": 40.74848, "altM": 328 }, + { + "t": 1789767172000, + "lon": -73.989895, + "lat": 40.748125, + "altM": 328 + }, + { + "t": 1789767173000, + "lon": -73.989745, + "lat": 40.747912, + "altM": 328 + }, + { + "t": 1789767174000, + "lon": -73.989815, + "lat": 40.747563, + "altM": 328 + }, + { + "t": 1789767175000, + "lon": -73.989526, + "lat": 40.747251, + "altM": 328 + }, + { "t": 1789767176000, "lon": -73.98954, "lat": 40.746988, "altM": 328 }, + { + "t": 1789767177000, + "lon": -73.989409, + "lat": 40.746711, + "altM": 328 + }, + { + "t": 1789767178000, + "lon": -73.989172, + "lat": 40.746438, + "altM": 328 + }, + { + "t": 1789767179000, + "lon": -73.989015, + "lat": 40.746133, + "altM": 328 + }, + { + "t": 1789767180000, + "lon": -73.988724, + "lat": 40.745903, + "altM": 328 + }, + { + "t": 1789767181000, + "lon": -73.988418, + "lat": 40.745618, + "altM": 328 + }, + { + "t": 1789767182000, + "lon": -73.988069, + "lat": 40.745444, + "altM": 328 + }, + { + "t": 1789767183000, + "lon": -73.987818, + "lat": 40.745175, + "altM": 328 + }, + { + "t": 1789767184000, + "lon": -73.987395, + "lat": 40.745009, + "altM": 328 + }, + { + "t": 1789767185000, + "lon": -73.987052, + "lat": 40.744876, + "altM": 328 + }, + { + "t": 1789767186000, + "lon": -73.986694, + "lat": 40.744667, + "altM": 328 + }, + { + "t": 1789767187000, + "lon": -73.986105, + "lat": 40.744536, + "altM": 328 + }, + { + "t": 1789767188000, + "lon": -73.985866, + "lat": 40.744515, + "altM": 328 + }, + { "t": 1789767189000, "lon": -73.985527, "lat": 40.74435, "altM": 328 }, + { + "t": 1789767190000, + "lon": -73.984953, + "lat": 40.744372, + "altM": 328 + }, + { + "t": 1789767191000, + "lon": -73.984573, + "lat": 40.744323, + "altM": 328 + }, + { + "t": 1789767192000, + "lon": -73.984131, + "lat": 40.744322, + "altM": 328 + }, + { + "t": 1789767193000, + "lon": -73.983656, + "lat": 40.744304, + "altM": 328 + }, + { + "t": 1789767194000, + "lon": -73.983285, + "lat": 40.744379, + "altM": 328 + }, + { "t": 1789767195000, "lon": -73.982848, "lat": 40.74442, "altM": 328 }, + { + "t": 1789767196000, + "lon": -73.982491, + "lat": 40.744583, + "altM": 328 + }, + { + "t": 1789767197000, + "lon": -73.982012, + "lat": 40.744697, + "altM": 328 + }, + { + "t": 1789767198000, + "lon": -73.981721, + "lat": 40.744784, + "altM": 328 + }, + { + "t": 1789767199000, + "lon": -73.981356, + "lat": 40.744964, + "altM": 328 + }, + { + "t": 1789767200000, + "lon": -73.981121, + "lat": 40.745168, + "altM": 328 + }, + { + "t": 1789767201000, + "lon": -73.980792, + "lat": 40.745411, + "altM": 328 + }, + { "t": 1789767202000, "lon": -73.980558, "lat": 40.74563, "altM": 328 }, + { + "t": 1789767203000, + "lon": -73.980299, + "lat": 40.745751, + "altM": 328 + }, + { "t": 1789767204000, "lon": -73.980157, "lat": 40.74599, "altM": 328 }, + { + "t": 1789767205000, + "lon": -73.979963, + "lat": 40.746341, + "altM": 328 + }, + { + "t": 1789767206000, + "lon": -73.979811, + "lat": 40.746524, + "altM": 328 + }, + { + "t": 1789767207000, + "lon": -73.979683, + "lat": 40.746794, + "altM": 328 + }, + { "t": 1789767208000, "lon": -73.979645, "lat": 40.74694, "altM": 328 }, + { + "t": 1789767209000, + "lon": -73.979664, + "lat": 40.747272, + "altM": 328 + }, + { "t": 1789767210000, "lon": -73.97971, "lat": 40.747465, "altM": 328 }, + { + "t": 1789767211000, + "lon": -73.979577, + "lat": 40.747668, + "altM": 328 + }, + { + "t": 1789767212000, + "lon": -73.979592, + "lat": 40.748032, + "altM": 328 + }, + { + "t": 1789767213000, + "lon": -73.979648, + "lat": 40.748243, + "altM": 328 + }, + { + "t": 1789767214000, + "lon": -73.979638, + "lat": 40.748465, + "altM": 328 + }, + { + "t": 1789767215000, + "lon": -73.979727, + "lat": 40.748711, + "altM": 328 + }, + { + "t": 1789767216000, + "lon": -73.979756, + "lat": 40.748921, + "altM": 328 + }, + { + "t": 1789767217000, + "lon": -73.979871, + "lat": 40.749101, + "altM": 328 + }, + { + "t": 1789767218000, + "lon": -73.979999, + "lat": 40.749419, + "altM": 328 + }, + { + "t": 1789767219000, + "lon": -73.980125, + "lat": 40.749579, + "altM": 328 + }, + { + "t": 1789767220000, + "lon": -73.980222, + "lat": 40.749736, + "altM": 328 + }, + { + "t": 1789767221000, + "lon": -73.980274, + "lat": 40.749995, + "altM": 328 + }, + { + "t": 1789767222000, + "lon": -73.980462, + "lat": 40.750114, + "altM": 328 + }, + { + "t": 1789767223000, + "lon": -73.980582, + "lat": 40.750346, + "altM": 328 + }, + { + "t": 1789767224000, + "lon": -73.980819, + "lat": 40.750495, + "altM": 320 + }, + { + "t": 1789767225000, + "lon": -73.980916, + "lat": 40.750634, + "altM": 320 + }, + { + "t": 1789767226000, + "lon": -73.981127, + "lat": 40.750806, + "altM": 320 + }, + { + "t": 1789767227000, + "lon": -73.981375, + "lat": 40.750903, + "altM": 320 + }, + { + "t": 1789767228000, + "lon": -73.981547, + "lat": 40.751096, + "altM": 320 + }, + { + "t": 1789767229000, + "lon": -73.981765, + "lat": 40.751195, + "altM": 320 + }, + { + "t": 1789767230000, + "lon": -73.981945, + "lat": 40.751295, + "altM": 320 + }, + { + "t": 1789767231000, + "lon": -73.982268, + "lat": 40.751369, + "altM": 320 + }, + { + "t": 1789767232000, + "lon": -73.982378, + "lat": 40.751554, + "altM": 320 + }, + { "t": 1789767233000, "lon": -73.98267, "lat": 40.75163, "altM": 320 }, + { "t": 1789767234000, "lon": -73.982936, "lat": 40.75179, "altM": 320 }, + { + "t": 1789767235000, + "lon": -73.983093, + "lat": 40.751779, + "altM": 320 + }, + { "t": 1789767236000, "lon": -73.983479, "lat": 40.75176, "altM": 320 }, + { + "t": 1789767237000, + "lon": -73.983734, + "lat": 40.751837, + "altM": 320 + }, + { + "t": 1789767238000, + "lon": -73.983987, + "lat": 40.751964, + "altM": 320 + }, + { + "t": 1789767239000, + "lon": -73.984291, + "lat": 40.751959, + "altM": 320 + }, + { + "t": 1789767240000, + "lon": -73.984491, + "lat": 40.751927, + "altM": 320 + }, + { + "t": 1789767241000, + "lon": -73.984764, + "lat": 40.751957, + "altM": 320 + }, + { + "t": 1789767242000, + "lon": -73.985054, + "lat": 40.751929, + "altM": 320 + }, + { + "t": 1789767243000, + "lon": -73.985286, + "lat": 40.751965, + "altM": 320 + }, + { + "t": 1789767244000, + "lon": -73.985525, + "lat": 40.751899, + "altM": 320 + }, + { + "t": 1789767245000, + "lon": -73.985849, + "lat": 40.751947, + "altM": 320 + }, + { + "t": 1789767246000, + "lon": -73.986167, + "lat": 40.751871, + "altM": 320 + }, + { + "t": 1789767247000, + "lon": -73.986413, + "lat": 40.751773, + "altM": 320 + }, + { + "t": 1789767248000, + "lon": -73.986575, + "lat": 40.751686, + "altM": 320 + }, + { + "t": 1789767249000, + "lon": -73.986925, + "lat": 40.751557, + "altM": 320 + }, + { + "t": 1789767250000, + "lon": -73.987104, + "lat": 40.751493, + "altM": 320 + }, + { + "t": 1789767251000, + "lon": -73.987334, + "lat": 40.751405, + "altM": 320 + }, + { + "t": 1789767252000, + "lon": -73.987749, + "lat": 40.751184, + "altM": 320 + }, + { + "t": 1789767253000, + "lon": -73.987873, + "lat": 40.751021, + "altM": 320 + }, + { + "t": 1789767254000, + "lon": -73.988187, + "lat": 40.750942, + "altM": 320 + }, + { + "t": 1789767255000, + "lon": -73.988337, + "lat": 40.750795, + "altM": 320 + }, + { + "t": 1789767256000, + "lon": -73.988519, + "lat": 40.750553, + "altM": 320 + }, + { + "t": 1789767257000, + "lon": -73.988745, + "lat": 40.750339, + "altM": 320 + }, + { + "t": 1789767258000, + "lon": -73.988976, + "lat": 40.750174, + "altM": 320 + }, + { "t": 1789767259000, "lon": -73.98904, "lat": 40.749833, "altM": 320 }, + { + "t": 1789767260000, + "lon": -73.989147, + "lat": 40.749664, + "altM": 320 + }, + { "t": 1789767261000, "lon": -73.98934, "lat": 40.749437, "altM": 312 }, + { + "t": 1789767262000, + "lon": -73.989345, + "lat": 40.749145, + "altM": 312 + }, + { + "t": 1789767263000, + "lon": -73.989482, + "lat": 40.748864, + "altM": 312 + }, + { + "t": 1789767264000, + "lon": -73.989463, + "lat": 40.748596, + "altM": 312 + }, + { + "t": 1789767265000, + "lon": -73.989415, + "lat": 40.748327, + "altM": 312 + }, + { + "t": 1789767266000, + "lon": -73.989453, + "lat": 40.748024, + "altM": 312 + }, + { + "t": 1789767267000, + "lon": -73.989371, + "lat": 40.747711, + "altM": 312 + }, + { + "t": 1789767268000, + "lon": -73.989347, + "lat": 40.747427, + "altM": 312 + }, + { "t": 1789767269000, "lon": -73.98916, "lat": 40.747154, "altM": 312 }, + { + "t": 1789767270000, + "lon": -73.989138, + "lat": 40.746832, + "altM": 312 + }, + { "t": 1789767271000, "lon": -73.988801, "lat": 40.74665, "altM": 312 }, + { + "t": 1789767272000, + "lon": -73.988618, + "lat": 40.746318, + "altM": 312 + }, + { + "t": 1789767273000, + "lon": -73.988362, + "lat": 40.746119, + "altM": 312 + }, + { + "t": 1789767274000, + "lon": -73.988046, + "lat": 40.745854, + "altM": 312 + }, + { + "t": 1789767275000, + "lon": -73.987702, + "lat": 40.745554, + "altM": 312 + }, + { "t": 1789767276000, "lon": -73.98741, "lat": 40.745349, "altM": 312 }, + { "t": 1789767277000, "lon": -73.987121, "lat": 40.74525, "altM": 312 }, + { + "t": 1789767278000, + "lon": -73.986744, + "lat": 40.745038, + "altM": 312 + }, + { + "t": 1789767279000, + "lon": -73.986264, + "lat": 40.744799, + "altM": 312 + }, + { + "t": 1789767280000, + "lon": -73.985894, + "lat": 40.744771, + "altM": 312 + }, + { + "t": 1789767281000, + "lon": -73.985457, + "lat": 40.744663, + "altM": 312 + }, + { + "t": 1789767282000, + "lon": -73.985039, + "lat": 40.744552, + "altM": 312 + }, + { + "t": 1789767283000, + "lon": -73.984592, + "lat": 40.744571, + "altM": 312 + }, + { + "t": 1789767284000, + "lon": -73.984145, + "lat": 40.744478, + "altM": 312 + }, + { + "t": 1789767285000, + "lon": -73.983692, + "lat": 40.744508, + "altM": 312 + }, + { + "t": 1789767286000, + "lon": -73.983353, + "lat": 40.744439, + "altM": 312 + }, + { + "t": 1789767287000, + "lon": -73.982929, + "lat": 40.744513, + "altM": 312 + }, + { + "t": 1789767288000, + "lon": -73.982482, + "lat": 40.744657, + "altM": 312 + }, + { + "t": 1789767289000, + "lon": -73.982051, + "lat": 40.744748, + "altM": 312 + }, + { "t": 1789767290000, "lon": -73.98167, "lat": 40.744902, "altM": 312 }, + { "t": 1789767291000, "lon": -73.98131, "lat": 40.745059, "altM": 312 }, + { "t": 1789767292000, "lon": -73.98095, "lat": 40.745234, "altM": 312 }, + { + "t": 1789767293000, + "lon": -73.980663, + "lat": 40.745406, + "altM": 312 + }, + { + "t": 1789767294000, + "lon": -73.980525, + "lat": 40.745626, + "altM": 312 + }, + { "t": 1789767295000, "lon": -73.980146, "lat": 40.7458, "altM": 312 }, + { + "t": 1789767296000, + "lon": -73.979995, + "lat": 40.746012, + "altM": 312 + }, + { + "t": 1789767297000, + "lon": -73.979711, + "lat": 40.746186, + "altM": 312 + }, + { + "t": 1789767298000, + "lon": -73.979573, + "lat": 40.746487, + "altM": 312 + }, + { + "t": 1789767299000, + "lon": -73.979441, + "lat": 40.746675, + "altM": 312 + }, + { + "t": 1789767300000, + "lon": -73.979361, + "lat": 40.746958, + "altM": 312 + }, + { + "t": 1789767301000, + "lon": -73.979348, + "lat": 40.747184, + "altM": 312 + }, + { + "t": 1789767302000, + "lon": -73.979326, + "lat": 40.747503, + "altM": 312 + }, + { + "t": 1789767303000, + "lon": -73.979308, + "lat": 40.747747, + "altM": 312 + }, + { + "t": 1789767304000, + "lon": -73.979213, + "lat": 40.747887, + "altM": 312 + }, + { "t": 1789767305000, "lon": -73.979319, "lat": 40.74816, "altM": 312 }, + { + "t": 1789767306000, + "lon": -73.979562, + "lat": 40.748398, + "altM": 312 + }, + { + "t": 1789767307000, + "lon": -73.979708, + "lat": 40.748608, + "altM": 312 + }, + { + "t": 1789767308000, + "lon": -73.979812, + "lat": 40.748749, + "altM": 312 + }, + { "t": 1789767309000, "lon": -73.979788, "lat": 40.74889, "altM": 312 }, + { + "t": 1789767310000, + "lon": -73.980031, + "lat": 40.749135, + "altM": 312 + }, + { + "t": 1789767311000, + "lon": -73.980117, + "lat": 40.749356, + "altM": 312 + }, + { + "t": 1789767312000, + "lon": -73.980255, + "lat": 40.749495, + "altM": 312 + }, + { + "t": 1789767313000, + "lon": -73.980525, + "lat": 40.749684, + "altM": 312 + }, + { + "t": 1789767314000, + "lon": -73.980627, + "lat": 40.749838, + "altM": 312 + }, + { + "t": 1789767315000, + "lon": -73.980821, + "lat": 40.750054, + "altM": 312 + }, + { + "t": 1789767316000, + "lon": -73.980952, + "lat": 40.750294, + "altM": 312 + }, + { + "t": 1789767317000, + "lon": -73.981127, + "lat": 40.750369, + "altM": 312 + }, + { + "t": 1789767318000, + "lon": -73.981341, + "lat": 40.750582, + "altM": 312 + }, + { + "t": 1789767319000, + "lon": -73.981507, + "lat": 40.750682, + "altM": 312 + }, + { "t": 1789767320000, "lon": -73.98167, "lat": 40.750851, "altM": 312 }, + { + "t": 1789767321000, + "lon": -73.981918, + "lat": 40.750955, + "altM": 312 + }, + { + "t": 1789767322000, + "lon": -73.982177, + "lat": 40.750997, + "altM": 312 + }, + { + "t": 1789767323000, + "lon": -73.982359, + "lat": 40.751261, + "altM": 312 + }, + { + "t": 1789767324000, + "lon": -73.982651, + "lat": 40.751278, + "altM": 312 + }, + { "t": 1789767325000, "lon": -73.98301, "lat": 40.751378, "altM": 312 }, + { + "t": 1789767326000, + "lon": -73.983081, + "lat": 40.751465, + "altM": 312 + }, + { + "t": 1789767327000, + "lon": -73.983299, + "lat": 40.751543, + "altM": 312 + }, + { + "t": 1789767328000, + "lon": -73.983564, + "lat": 40.751608, + "altM": 312 + }, + { + "t": 1789767329000, + "lon": -73.983892, + "lat": 40.751697, + "altM": 312 + }, + { + "t": 1789767330000, + "lon": -73.984028, + "lat": 40.751701, + "altM": 312 + }, + { + "t": 1789767331000, + "lon": -73.984304, + "lat": 40.751695, + "altM": 312 + }, + { + "t": 1789767332000, + "lon": -73.984599, + "lat": 40.751736, + "altM": 312 + }, + { + "t": 1789767333000, + "lon": -73.984879, + "lat": 40.751748, + "altM": 312 + }, + { + "t": 1789767334000, + "lon": -73.985238, + "lat": 40.751731, + "altM": 312 + }, + { + "t": 1789767335000, + "lon": -73.985465, + "lat": 40.751677, + "altM": 312 + }, + { + "t": 1789767336000, + "lon": -73.985692, + "lat": 40.751695, + "altM": 312 + }, + { + "t": 1789767337000, + "lon": -73.986106, + "lat": 40.751658, + "altM": 312 + }, + { "t": 1789767338000, "lon": -73.986299, "lat": 40.75164, "altM": 312 }, + { + "t": 1789767339000, + "lon": -73.986511, + "lat": 40.751524, + "altM": 312 + }, + { + "t": 1789767340000, + "lon": -73.986782, + "lat": 40.751438, + "altM": 312 + }, + { + "t": 1789767341000, + "lon": -73.987047, + "lat": 40.751329, + "altM": 312 + }, + { + "t": 1789767342000, + "lon": -73.987362, + "lat": 40.751201, + "altM": 312 + }, + { "t": 1789767343000, "lon": -73.987624, "lat": 40.75122, "altM": 312 }, + { + "t": 1789767344000, + "lon": -73.987857, + "lat": 40.751034, + "altM": 320 + }, + { + "t": 1789767345000, + "lon": -73.988093, + "lat": 40.750811, + "altM": 320 + }, + { + "t": 1789767346000, + "lon": -73.988277, + "lat": 40.750632, + "altM": 320 + }, + { + "t": 1789767347000, + "lon": -73.988458, + "lat": 40.750466, + "altM": 320 + }, + { + "t": 1789767348000, + "lon": -73.988714, + "lat": 40.750259, + "altM": 320 + }, + { + "t": 1789767349000, + "lon": -73.988888, + "lat": 40.750088, + "altM": 320 + }, + { "t": 1789767350000, "lon": -73.988901, "lat": 40.74984, "altM": 320 }, + { + "t": 1789767351000, + "lon": -73.989148, + "lat": 40.749624, + "altM": 320 + }, + { + "t": 1789767352000, + "lon": -73.989202, + "lat": 40.749374, + "altM": 320 + }, + { + "t": 1789767353000, + "lon": -73.989369, + "lat": 40.749092, + "altM": 320 + }, + { + "t": 1789767354000, + "lon": -73.989409, + "lat": 40.748851, + "altM": 320 + }, + { + "t": 1789767355000, + "lon": -73.989422, + "lat": 40.748591, + "altM": 320 + }, + { + "t": 1789767356000, + "lon": -73.989438, + "lat": 40.748218, + "altM": 320 + }, + { + "t": 1789767357000, + "lon": -73.989444, + "lat": 40.747957, + "altM": 320 + }, + { "t": 1789767358000, "lon": -73.989285, "lat": 40.74762, "altM": 320 }, + { "t": 1789767359000, "lon": -73.989263, "lat": 40.74734, "altM": 320 }, + { + "t": 1789767360000, + "lon": -73.989086, + "lat": 40.747124, + "altM": 320 + }, + { + "t": 1789767361000, + "lon": -73.988912, + "lat": 40.746769, + "altM": 320 + }, + { + "t": 1789767362000, + "lon": -73.988802, + "lat": 40.746488, + "altM": 320 + }, + { + "t": 1789767363000, + "lon": -73.988492, + "lat": 40.746275, + "altM": 320 + }, + { + "t": 1789767364000, + "lon": -73.988315, + "lat": 40.745959, + "altM": 320 + }, + { + "t": 1789767365000, + "lon": -73.987987, + "lat": 40.745731, + "altM": 320 + }, + { "t": 1789767366000, "lon": -73.987735, "lat": 40.74552, "altM": 320 }, + { + "t": 1789767367000, + "lon": -73.987386, + "lat": 40.745306, + "altM": 320 + }, + { + "t": 1789767368000, + "lon": -73.986917, + "lat": 40.745106, + "altM": 320 + }, + { + "t": 1789767369000, + "lon": -73.986569, + "lat": 40.744983, + "altM": 320 + }, + { "t": 1789767370000, "lon": -73.986189, "lat": 40.74486, "altM": 320 }, + { + "t": 1789767371000, + "lon": -73.985811, + "lat": 40.744654, + "altM": 320 + }, + { "t": 1789767372000, "lon": -73.985412, "lat": 40.74454, "altM": 320 }, + { + "t": 1789767373000, + "lon": -73.984992, + "lat": 40.744541, + "altM": 320 + }, + { + "t": 1789767374000, + "lon": -73.984489, + "lat": 40.744455, + "altM": 320 + }, + { + "t": 1789767375000, + "lon": -73.984085, + "lat": 40.744411, + "altM": 320 + }, + { + "t": 1789767376000, + "lon": -73.983689, + "lat": 40.744426, + "altM": 320 + }, + { "t": 1789767377000, "lon": -73.98323, "lat": 40.744446, "altM": 320 }, + { + "t": 1789767378000, + "lon": -73.982792, + "lat": 40.744454, + "altM": 320 + }, + { + "t": 1789767379000, + "lon": -73.982422, + "lat": 40.744588, + "altM": 328 + }, + { + "t": 1789767380000, + "lon": -73.982066, + "lat": 40.744675, + "altM": 328 + }, + { + "t": 1789767381000, + "lon": -73.981686, + "lat": 40.744888, + "altM": 328 + }, + { + "t": 1789767382000, + "lon": -73.981266, + "lat": 40.744999, + "altM": 328 + }, + { "t": 1789767383000, "lon": -73.98091, "lat": 40.745084, "altM": 328 }, + { + "t": 1789767384000, + "lon": -73.980708, + "lat": 40.745301, + "altM": 328 + }, + { + "t": 1789767385000, + "lon": -73.980282, + "lat": 40.745555, + "altM": 328 + }, + { + "t": 1789767386000, + "lon": -73.980086, + "lat": 40.745729, + "altM": 328 + }, + { "t": 1789767387000, "lon": -73.97983, "lat": 40.745917, "altM": 328 }, + { + "t": 1789767388000, + "lon": -73.979716, + "lat": 40.746114, + "altM": 328 + }, + { + "t": 1789767389000, + "lon": -73.979475, + "lat": 40.746407, + "altM": 328 + }, + { + "t": 1789767390000, + "lon": -73.979444, + "lat": 40.746613, + "altM": 328 + }, + { + "t": 1789767391000, + "lon": -73.979251, + "lat": 40.746895, + "altM": 328 + }, + { + "t": 1789767392000, + "lon": -73.979268, + "lat": 40.747167, + "altM": 328 + }, + { + "t": 1789767393000, + "lon": -73.979235, + "lat": 40.747388, + "altM": 328 + }, + { "t": 1789767394000, "lon": -73.97924, "lat": 40.747684, "altM": 328 }, + { "t": 1789767395000, "lon": -73.97925, "lat": 40.747806, "altM": 328 }, + { + "t": 1789767396000, + "lon": -73.979278, + "lat": 40.748056, + "altM": 328 + }, + { + "t": 1789767397000, + "lon": -73.979402, + "lat": 40.748234, + "altM": 328 + }, + { + "t": 1789767398000, + "lon": -73.979582, + "lat": 40.748445, + "altM": 328 + }, + { + "t": 1789767399000, + "lon": -73.979691, + "lat": 40.748711, + "altM": 328 + }, + { + "t": 1789767400000, + "lon": -73.979678, + "lat": 40.748955, + "altM": 328 + }, + { + "t": 1789767401000, + "lon": -73.979802, + "lat": 40.749132, + "altM": 328 + }, + { + "t": 1789767402000, + "lon": -73.980027, + "lat": 40.749343, + "altM": 328 + }, + { + "t": 1789767403000, + "lon": -73.979998, + "lat": 40.749526, + "altM": 328 + }, + { + "t": 1789767404000, + "lon": -73.980231, + "lat": 40.749774, + "altM": 328 + }, + { + "t": 1789767405000, + "lon": -73.980224, + "lat": 40.749944, + "altM": 328 + }, + { "t": 1789767406000, "lon": -73.980431, "lat": 40.75013, "altM": 328 }, + { + "t": 1789767407000, + "lon": -73.980545, + "lat": 40.750249, + "altM": 328 + }, + { + "t": 1789767408000, + "lon": -73.980781, + "lat": 40.750513, + "altM": 328 + }, + { + "t": 1789767409000, + "lon": -73.980942, + "lat": 40.750646, + "altM": 328 + }, + { "t": 1789767410000, "lon": -73.981133, "lat": 40.75082, "altM": 328 }, + { + "t": 1789767411000, + "lon": -73.981354, + "lat": 40.750921, + "altM": 328 + }, + { + "t": 1789767412000, + "lon": -73.981598, + "lat": 40.751077, + "altM": 328 + }, + { + "t": 1789767413000, + "lon": -73.981743, + "lat": 40.751244, + "altM": 328 + }, + { + "t": 1789767414000, + "lon": -73.981903, + "lat": 40.751413, + "altM": 328 + }, + { + "t": 1789767415000, + "lon": -73.982142, + "lat": 40.751529, + "altM": 328 + }, + { + "t": 1789767416000, + "lon": -73.982404, + "lat": 40.751571, + "altM": 328 + }, + { "t": 1789767417000, "lon": -73.982519, "lat": 40.75166, "altM": 328 }, + { + "t": 1789767418000, + "lon": -73.982866, + "lat": 40.751754, + "altM": 328 + }, + { + "t": 1789767419000, + "lon": -73.983042, + "lat": 40.751815, + "altM": 328 + }, + { + "t": 1789767420000, + "lon": -73.983438, + "lat": 40.751927, + "altM": 328 + }, + { + "t": 1789767421000, + "lon": -73.983569, + "lat": 40.752037, + "altM": 328 + }, + { + "t": 1789767422000, + "lon": -73.983764, + "lat": 40.752016, + "altM": 328 + }, + { + "t": 1789767423000, + "lon": -73.984198, + "lat": 40.752041, + "altM": 328 + }, + { + "t": 1789767424000, + "lon": -73.984399, + "lat": 40.752107, + "altM": 328 + }, + { "t": 1789767425000, "lon": -73.984651, "lat": 40.75213, "altM": 328 }, + { + "t": 1789767426000, + "lon": -73.985026, + "lat": 40.752149, + "altM": 328 + }, + { + "t": 1789767427000, + "lon": -73.985252, + "lat": 40.752147, + "altM": 328 + }, + { "t": 1789767428000, "lon": -73.98554, "lat": 40.752079, "altM": 328 }, + { + "t": 1789767429000, + "lon": -73.985723, + "lat": 40.752041, + "altM": 328 + }, + { + "t": 1789767430000, + "lon": -73.986042, + "lat": 40.751997, + "altM": 328 + }, + { + "t": 1789767431000, + "lon": -73.986381, + "lat": 40.751997, + "altM": 328 + }, + { + "t": 1789767432000, + "lon": -73.986565, + "lat": 40.751917, + "altM": 328 + }, + { + "t": 1789767433000, + "lon": -73.986857, + "lat": 40.751822, + "altM": 328 + }, + { + "t": 1789767434000, + "lon": -73.987104, + "lat": 40.751686, + "altM": 328 + }, + { "t": 1789767435000, "lon": -73.9874, "lat": 40.751651, "altM": 328 }, + { + "t": 1789767436000, + "lon": -73.987565, + "lat": 40.751493, + "altM": 328 + }, + { + "t": 1789767437000, + "lon": -73.987974, + "lat": 40.751381, + "altM": 328 + }, + { "t": 1789767438000, "lon": -73.9881, "lat": 40.751267, "altM": 328 }, + { + "t": 1789767439000, + "lon": -73.988315, + "lat": 40.751049, + "altM": 328 + }, + { + "t": 1789767440000, + "lon": -73.988593, + "lat": 40.750945, + "altM": 328 + }, + { + "t": 1789767441000, + "lon": -73.988718, + "lat": 40.750707, + "altM": 328 + }, + { + "t": 1789767442000, + "lon": -73.988971, + "lat": 40.750573, + "altM": 328 + }, + { + "t": 1789767443000, + "lon": -73.989136, + "lat": 40.750323, + "altM": 328 + }, + { + "t": 1789767444000, + "lon": -73.989326, + "lat": 40.750146, + "altM": 328 + }, + { "t": 1789767445000, "lon": -73.98945, "lat": 40.749841, "altM": 328 }, + { + "t": 1789767446000, + "lon": -73.989622, + "lat": 40.749716, + "altM": 328 + }, + { + "t": 1789767447000, + "lon": -73.989717, + "lat": 40.749441, + "altM": 328 + }, + { + "t": 1789767448000, + "lon": -73.989741, + "lat": 40.749116, + "altM": 328 + }, + { + "t": 1789767449000, + "lon": -73.989738, + "lat": 40.748831, + "altM": 328 + }, + { + "t": 1789767450000, + "lon": -73.989917, + "lat": 40.748575, + "altM": 328 + }, + { + "t": 1789767451000, + "lon": -73.989872, + "lat": 40.748336, + "altM": 328 + }, + { + "t": 1789767452000, + "lon": -73.989806, + "lat": 40.747922, + "altM": 328 + }, + { + "t": 1789767453000, + "lon": -73.989749, + "lat": 40.747787, + "altM": 328 + }, + { + "t": 1789767454000, + "lon": -73.989765, + "lat": 40.747469, + "altM": 328 + }, + { + "t": 1789767455000, + "lon": -73.989572, + "lat": 40.747166, + "altM": 328 + }, + { "t": 1789767456000, "lon": -73.989447, "lat": 40.74686, "altM": 328 }, + { + "t": 1789767457000, + "lon": -73.989343, + "lat": 40.746586, + "altM": 328 + }, + { + "t": 1789767458000, + "lon": -73.989081, + "lat": 40.746306, + "altM": 320 + }, + { + "t": 1789767459000, + "lon": -73.988824, + "lat": 40.746003, + "altM": 328 + }, + { "t": 1789767460000, "lon": -73.9886, "lat": 40.74582, "altM": 320 }, + { + "t": 1789767461000, + "lon": -73.988284, + "lat": 40.745563, + "altM": 320 + }, + { + "t": 1789767462000, + "lon": -73.988058, + "lat": 40.745306, + "altM": 320 + }, + { + "t": 1789767463000, + "lon": -73.987746, + "lat": 40.745186, + "altM": 320 + }, + { "t": 1789767464000, "lon": -73.987341, "lat": 40.74495, "altM": 320 }, + { + "t": 1789767465000, + "lon": -73.986867, + "lat": 40.744765, + "altM": 320 + }, + { + "t": 1789767466000, + "lon": -73.986554, + "lat": 40.744638, + "altM": 320 + }, + { "t": 1789767467000, "lon": -73.98603, "lat": 40.744544, "altM": 320 }, + { + "t": 1789767468000, + "lon": -73.985715, + "lat": 40.744403, + "altM": 320 + }, + { + "t": 1789767469000, + "lon": -73.985305, + "lat": 40.744398, + "altM": 320 + }, + { "t": 1789767470000, "lon": -73.98482, "lat": 40.744293, "altM": 320 }, + { + "t": 1789767471000, + "lon": -73.984363, + "lat": 40.744266, + "altM": 320 + }, + { + "t": 1789767472000, + "lon": -73.983953, + "lat": 40.744245, + "altM": 320 + }, + { + "t": 1789767473000, + "lon": -73.983619, + "lat": 40.744334, + "altM": 320 + }, + { + "t": 1789767474000, + "lon": -73.983009, + "lat": 40.744418, + "altM": 320 + }, + { + "t": 1789767475000, + "lon": -73.982649, + "lat": 40.744485, + "altM": 320 + }, + { "t": 1789767476000, "lon": -73.98225, "lat": 40.744592, "altM": 320 }, + { + "t": 1789767477000, + "lon": -73.981957, + "lat": 40.744712, + "altM": 320 + }, + { "t": 1789767478000, "lon": -73.981634, "lat": 40.74485, "altM": 320 }, + { + "t": 1789767479000, + "lon": -73.981272, + "lat": 40.745015, + "altM": 320 + }, + { + "t": 1789767480000, + "lon": -73.980958, + "lat": 40.745205, + "altM": 320 + }, + { + "t": 1789767481000, + "lon": -73.980712, + "lat": 40.745369, + "altM": 320 + }, + { + "t": 1789767482000, + "lon": -73.980464, + "lat": 40.745662, + "altM": 320 + }, + { "t": 1789767483000, "lon": -73.980195, "lat": 40.74587, "altM": 320 }, + { "t": 1789767484000, "lon": -73.980037, "lat": 40.74612, "altM": 320 }, + { + "t": 1789767485000, + "lon": -73.979943, + "lat": 40.746302, + "altM": 320 + }, + { + "t": 1789767486000, + "lon": -73.979753, + "lat": 40.746584, + "altM": 320 + }, + { + "t": 1789767487000, + "lon": -73.979655, + "lat": 40.746832, + "altM": 320 + }, + { + "t": 1789767488000, + "lon": -73.979527, + "lat": 40.747121, + "altM": 320 + }, + { + "t": 1789767489000, + "lon": -73.979572, + "lat": 40.747297, + "altM": 320 + }, + { + "t": 1789767490000, + "lon": -73.979599, + "lat": 40.747581, + "altM": 320 + }, + { + "t": 1789767491000, + "lon": -73.979566, + "lat": 40.747801, + "altM": 320 + }, + { + "t": 1789767492000, + "lon": -73.979488, + "lat": 40.748082, + "altM": 320 + }, + { + "t": 1789767493000, + "lon": -73.979708, + "lat": 40.748315, + "altM": 312 + }, + { + "t": 1789767494000, + "lon": -73.979671, + "lat": 40.748469, + "altM": 312 + }, + { + "t": 1789767495000, + "lon": -73.979579, + "lat": 40.748744, + "altM": 312 + }, + { "t": 1789767496000, "lon": -73.97965, "lat": 40.74896, "altM": 312 }, + { + "t": 1789767497000, + "lon": -73.979904, + "lat": 40.749159, + "altM": 312 + }, + { "t": 1789767498000, "lon": -73.97994, "lat": 40.749404, "altM": 312 }, + { "t": 1789767499000, "lon": -73.98008, "lat": 40.749701, "altM": 312 }, + { + "t": 1789767500000, + "lon": -73.980119, + "lat": 40.749861, + "altM": 312 + }, + { + "t": 1789767501000, + "lon": -73.980273, + "lat": 40.750036, + "altM": 312 + }, + { + "t": 1789767502000, + "lon": -73.980478, + "lat": 40.750219, + "altM": 312 + }, + { + "t": 1789767503000, + "lon": -73.980557, + "lat": 40.750364, + "altM": 312 + }, + { + "t": 1789767504000, + "lon": -73.980683, + "lat": 40.750538, + "altM": 312 + }, + { + "t": 1789767505000, + "lon": -73.980965, + "lat": 40.750677, + "altM": 312 + }, + { + "t": 1789767506000, + "lon": -73.981147, + "lat": 40.750847, + "altM": 312 + }, + { + "t": 1789767507000, + "lon": -73.981254, + "lat": 40.751023, + "altM": 312 + }, + { + "t": 1789767508000, + "lon": -73.981459, + "lat": 40.751125, + "altM": 312 + }, + { + "t": 1789767509000, + "lon": -73.981684, + "lat": 40.751348, + "altM": 312 + }, + { + "t": 1789767510000, + "lon": -73.981945, + "lat": 40.751344, + "altM": 312 + }, + { + "t": 1789767511000, + "lon": -73.982188, + "lat": 40.751508, + "altM": 312 + }, + { + "t": 1789767512000, + "lon": -73.982381, + "lat": 40.751582, + "altM": 312 + }, + { "t": 1789767513000, "lon": -73.98275, "lat": 40.751638, "altM": 312 }, + { + "t": 1789767514000, + "lon": -73.982921, + "lat": 40.751749, + "altM": 312 + }, + { + "t": 1789767515000, + "lon": -73.983207, + "lat": 40.751826, + "altM": 312 + }, + { + "t": 1789767516000, + "lon": -73.983426, + "lat": 40.751854, + "altM": 312 + }, + { + "t": 1789767517000, + "lon": -73.983663, + "lat": 40.751972, + "altM": 312 + }, + { + "t": 1789767518000, + "lon": -73.983963, + "lat": 40.751968, + "altM": 312 + }, + { + "t": 1789767519000, + "lon": -73.984265, + "lat": 40.752023, + "altM": 312 + }, + { + "t": 1789767520000, + "lon": -73.984513, + "lat": 40.752038, + "altM": 312 + }, + { + "t": 1789767521000, + "lon": -73.984763, + "lat": 40.752028, + "altM": 312 + }, + { + "t": 1789767522000, + "lon": -73.985058, + "lat": 40.752055, + "altM": 312 + }, + { + "t": 1789767523000, + "lon": -73.985268, + "lat": 40.752027, + "altM": 312 + }, + { + "t": 1789767524000, + "lon": -73.985606, + "lat": 40.751961, + "altM": 312 + }, + { + "t": 1789767525000, + "lon": -73.985806, + "lat": 40.751955, + "altM": 312 + }, + { + "t": 1789767526000, + "lon": -73.986153, + "lat": 40.751823, + "altM": 312 + }, + { "t": 1789767527000, "lon": -73.986307, "lat": 40.75181, "altM": 312 }, + { + "t": 1789767528000, + "lon": -73.986677, + "lat": 40.751726, + "altM": 312 + }, + { + "t": 1789767529000, + "lon": -73.986933, + "lat": 40.751666, + "altM": 312 + }, + { + "t": 1789767530000, + "lon": -73.987165, + "lat": 40.751496, + "altM": 312 + }, + { + "t": 1789767531000, + "lon": -73.987473, + "lat": 40.751458, + "altM": 312 + }, + { + "t": 1789767532000, + "lon": -73.987702, + "lat": 40.751306, + "altM": 312 + }, + { + "t": 1789767533000, + "lon": -73.987892, + "lat": 40.751149, + "altM": 312 + }, + { "t": 1789767534000, "lon": -73.98809, "lat": 40.751029, "altM": 312 }, + { + "t": 1789767535000, + "lon": -73.988325, + "lat": 40.750865, + "altM": 312 + }, + { "t": 1789767536000, "lon": -73.98864, "lat": 40.750647, "altM": 312 }, + { + "t": 1789767537000, + "lon": -73.988777, + "lat": 40.750448, + "altM": 312 + }, + { + "t": 1789767538000, + "lon": -73.988963, + "lat": 40.750331, + "altM": 312 + }, + { "t": 1789767539000, "lon": -73.98903, "lat": 40.750005, "altM": 312 }, + { + "t": 1789767540000, + "lon": -73.989285, + "lat": 40.749759, + "altM": 312 + }, + { + "t": 1789767541000, + "lon": -73.989221, + "lat": 40.749546, + "altM": 312 + }, + { + "t": 1789767542000, + "lon": -73.989394, + "lat": 40.749287, + "altM": 312 + }, + { + "t": 1789767543000, + "lon": -73.989465, + "lat": 40.749016, + "altM": 312 + }, + { + "t": 1789767544000, + "lon": -73.989518, + "lat": 40.748772, + "altM": 312 + }, + { + "t": 1789767545000, + "lon": -73.989516, + "lat": 40.748493, + "altM": 312 + }, + { + "t": 1789767546000, + "lon": -73.989655, + "lat": 40.748163, + "altM": 312 + }, + { + "t": 1789767547000, + "lon": -73.989488, + "lat": 40.747888, + "altM": 312 + }, + { + "t": 1789767548000, + "lon": -73.989434, + "lat": 40.747657, + "altM": 312 + }, + { + "t": 1789767549000, + "lon": -73.989307, + "lat": 40.747291, + "altM": 312 + }, + { "t": 1789767550000, "lon": -73.989135, "lat": 40.74697, "altM": 312 }, + { "t": 1789767551000, "lon": -73.98897, "lat": 40.746706, "altM": 312 }, + { + "t": 1789767552000, + "lon": -73.988768, + "lat": 40.746513, + "altM": 312 + }, + { + "t": 1789767553000, + "lon": -73.988616, + "lat": 40.746156, + "altM": 312 + }, + { + "t": 1789767554000, + "lon": -73.988279, + "lat": 40.745906, + "altM": 312 + }, + { "t": 1789767555000, "lon": -73.988027, "lat": 40.7457, "altM": 312 }, + { + "t": 1789767556000, + "lon": -73.987679, + "lat": 40.745498, + "altM": 312 + }, + { + "t": 1789767557000, + "lon": -73.987299, + "lat": 40.745313, + "altM": 312 + }, + { + "t": 1789767558000, + "lon": -73.986993, + "lat": 40.745141, + "altM": 312 + }, + { + "t": 1789767559000, + "lon": -73.986591, + "lat": 40.744935, + "altM": 312 + }, + { + "t": 1789767560000, + "lon": -73.986271, + "lat": 40.744856, + "altM": 312 + }, + { + "t": 1789767561000, + "lon": -73.985761, + "lat": 40.744687, + "altM": 312 + }, + { "t": 1789767562000, "lon": -73.98538, "lat": 40.744575, "altM": 312 }, + { "t": 1789767563000, "lon": -73.98495, "lat": 40.744631, "altM": 312 }, + { + "t": 1789767564000, + "lon": -73.984618, + "lat": 40.744438, + "altM": 312 + }, + { + "t": 1789767565000, + "lon": -73.984135, + "lat": 40.744539, + "altM": 312 + }, + { + "t": 1789767566000, + "lon": -73.983716, + "lat": 40.744498, + "altM": 312 + }, + { "t": 1789767567000, "lon": -73.9832, "lat": 40.74455, "altM": 312 }, + { + "t": 1789767568000, + "lon": -73.982808, + "lat": 40.744602, + "altM": 312 + }, + { + "t": 1789767569000, + "lon": -73.982397, + "lat": 40.744679, + "altM": 312 + }, + { + "t": 1789767570000, + "lon": -73.981995, + "lat": 40.744838, + "altM": 312 + }, + { + "t": 1789767571000, + "lon": -73.981608, + "lat": 40.744861, + "altM": 312 + }, + { + "t": 1789767572000, + "lon": -73.981284, + "lat": 40.745086, + "altM": 312 + }, + { + "t": 1789767573000, + "lon": -73.980998, + "lat": 40.745244, + "altM": 312 + }, + { + "t": 1789767574000, + "lon": -73.980609, + "lat": 40.745399, + "altM": 312 + }, + { + "t": 1789767575000, + "lon": -73.980359, + "lat": 40.745661, + "altM": 312 + }, + { "t": 1789767576000, "lon": -73.980127, "lat": 40.74584, "altM": 312 }, + { + "t": 1789767577000, + "lon": -73.979958, + "lat": 40.746071, + "altM": 312 + }, + { "t": 1789767578000, "lon": -73.9797, "lat": 40.746316, "altM": 320 }, + { + "t": 1789767579000, + "lon": -73.979605, + "lat": 40.746564, + "altM": 320 + }, + { + "t": 1789767580000, + "lon": -73.979433, + "lat": 40.746869, + "altM": 320 + }, + { + "t": 1789767581000, + "lon": -73.979425, + "lat": 40.747086, + "altM": 320 + }, + { + "t": 1789767582000, + "lon": -73.979385, + "lat": 40.747336, + "altM": 320 + }, + { + "t": 1789767583000, + "lon": -73.979407, + "lat": 40.747507, + "altM": 320 + }, + { + "t": 1789767584000, + "lon": -73.979348, + "lat": 40.747822, + "altM": 320 + }, + { "t": 1789767585000, "lon": -73.979404, "lat": 40.74798, "altM": 320 }, + { "t": 1789767586000, "lon": -73.979518, "lat": 40.74821, "altM": 320 }, + { + "t": 1789767587000, + "lon": -73.979586, + "lat": 40.748402, + "altM": 320 + }, + { + "t": 1789767588000, + "lon": -73.979723, + "lat": 40.748638, + "altM": 320 + }, + { + "t": 1789767589000, + "lon": -73.979888, + "lat": 40.748833, + "altM": 320 + }, + { + "t": 1789767590000, + "lon": -73.980053, + "lat": 40.749052, + "altM": 320 + }, + { "t": 1789767591000, "lon": -73.98017, "lat": 40.749222, "altM": 320 }, + { + "t": 1789767592000, + "lon": -73.980295, + "lat": 40.749371, + "altM": 320 + }, + { + "t": 1789767593000, + "lon": -73.980407, + "lat": 40.749589, + "altM": 320 + }, + { + "t": 1789767594000, + "lon": -73.980576, + "lat": 40.749808, + "altM": 320 + }, + { + "t": 1789767595000, + "lon": -73.980765, + "lat": 40.749957, + "altM": 320 + }, + { + "t": 1789767596000, + "lon": -73.980838, + "lat": 40.750156, + "altM": 320 + }, + { + "t": 1789767597000, + "lon": -73.981081, + "lat": 40.750319, + "altM": 320 + }, + { "t": 1789767598000, "lon": -73.98117, "lat": 40.750455, "altM": 320 }, + { + "t": 1789767599000, + "lon": -73.981447, + "lat": 40.750624, + "altM": 320 + }, + { + "t": 1789767600000, + "lon": -73.981642, + "lat": 40.750745, + "altM": 320 + }, + { + "t": 1789767601000, + "lon": -73.981798, + "lat": 40.750906, + "altM": 320 + }, + { + "t": 1789767602000, + "lon": -73.982077, + "lat": 40.751078, + "altM": 320 + }, + { + "t": 1789767603000, + "lon": -73.982288, + "lat": 40.751116, + "altM": 320 + }, + { + "t": 1789767604000, + "lon": -73.982486, + "lat": 40.751294, + "altM": 320 + }, + { + "t": 1789767605000, + "lon": -73.982748, + "lat": 40.751377, + "altM": 320 + }, + { "t": 1789767606000, "lon": -73.98304, "lat": 40.751434, "altM": 320 }, + { + "t": 1789767607000, + "lon": -73.983223, + "lat": 40.751577, + "altM": 320 + }, + { "t": 1789767608000, "lon": -73.983491, "lat": 40.75157, "altM": 320 }, + { + "t": 1789767609000, + "lon": -73.983749, + "lat": 40.751634, + "altM": 320 + }, + { "t": 1789767610000, "lon": -73.983941, "lat": 40.75163, "altM": 320 }, + { + "t": 1789767611000, + "lon": -73.984271, + "lat": 40.751759, + "altM": 320 + }, + { + "t": 1789767612000, + "lon": -73.984486, + "lat": 40.751774, + "altM": 320 + }, + { + "t": 1789767613000, + "lon": -73.984702, + "lat": 40.751712, + "altM": 320 + }, + { + "t": 1789767614000, + "lon": -73.985108, + "lat": 40.751663, + "altM": 328 + }, + { + "t": 1789767615000, + "lon": -73.985397, + "lat": 40.751731, + "altM": 328 + }, + { + "t": 1789767616000, + "lon": -73.985587, + "lat": 40.751712, + "altM": 328 + }, + { "t": 1789767617000, "lon": -73.98602, "lat": 40.751631, "altM": 328 }, + { "t": 1789767618000, "lon": -73.986137, "lat": 40.75159, "altM": 328 }, + { + "t": 1789767619000, + "lon": -73.986458, + "lat": 40.751567, + "altM": 328 + }, + { + "t": 1789767620000, + "lon": -73.986659, + "lat": 40.751467, + "altM": 328 + }, + { + "t": 1789767621000, + "lon": -73.987021, + "lat": 40.751379, + "altM": 328 + }, + { + "t": 1789767622000, + "lon": -73.987278, + "lat": 40.751293, + "altM": 328 + }, + { + "t": 1789767623000, + "lon": -73.987529, + "lat": 40.751201, + "altM": 328 + }, + { + "t": 1789767624000, + "lon": -73.987702, + "lat": 40.751019, + "altM": 328 + }, + { + "t": 1789767625000, + "lon": -73.987923, + "lat": 40.750846, + "altM": 328 + }, + { + "t": 1789767626000, + "lon": -73.988119, + "lat": 40.750664, + "altM": 328 + }, + { "t": 1789767627000, "lon": -73.98829, "lat": 40.75053, "altM": 328 }, + { + "t": 1789767628000, + "lon": -73.988569, + "lat": 40.750303, + "altM": 328 + }, + { + "t": 1789767629000, + "lon": -73.988681, + "lat": 40.750068, + "altM": 328 + }, + { + "t": 1789767630000, + "lon": -73.988866, + "lat": 40.749817, + "altM": 328 + }, + { + "t": 1789767631000, + "lon": -73.989021, + "lat": 40.749658, + "altM": 328 + }, + { + "t": 1789767632000, + "lon": -73.989118, + "lat": 40.749466, + "altM": 328 + }, + { + "t": 1789767633000, + "lon": -73.989216, + "lat": 40.749164, + "altM": 328 + }, + { + "t": 1789767634000, + "lon": -73.989325, + "lat": 40.748801, + "altM": 328 + }, + { + "t": 1789767635000, + "lon": -73.989355, + "lat": 40.748581, + "altM": 328 + }, + { + "t": 1789767636000, + "lon": -73.989342, + "lat": 40.748325, + "altM": 328 + }, + { + "t": 1789767637000, + "lon": -73.989322, + "lat": 40.748027, + "altM": 328 + }, + { + "t": 1789767638000, + "lon": -73.989277, + "lat": 40.747753, + "altM": 328 + }, + { + "t": 1789767639000, + "lon": -73.989115, + "lat": 40.747414, + "altM": 328 + }, + { + "t": 1789767640000, + "lon": -73.989081, + "lat": 40.747163, + "altM": 328 + }, + { + "t": 1789767641000, + "lon": -73.988943, + "lat": 40.746892, + "altM": 328 + }, + { + "t": 1789767642000, + "lon": -73.988776, + "lat": 40.746574, + "altM": 328 + }, + { + "t": 1789767643000, + "lon": -73.988531, + "lat": 40.746326, + "altM": 328 + }, + { + "t": 1789767644000, + "lon": -73.988268, + "lat": 40.746104, + "altM": 328 + }, + { "t": 1789767645000, "lon": -73.98791, "lat": 40.745779, "altM": 328 }, + { + "t": 1789767646000, + "lon": -73.987632, + "lat": 40.745561, + "altM": 328 + }, + { + "t": 1789767647000, + "lon": -73.987383, + "lat": 40.745329, + "altM": 328 + }, + { "t": 1789767648000, "lon": -73.987009, "lat": 40.74518, "altM": 328 }, + { + "t": 1789767649000, + "lon": -73.986612, + "lat": 40.745016, + "altM": 328 + }, + { + "t": 1789767650000, + "lon": -73.986247, + "lat": 40.744849, + "altM": 328 + }, + { + "t": 1789767651000, + "lon": -73.985819, + "lat": 40.744727, + "altM": 328 + }, + { + "t": 1789767652000, + "lon": -73.985367, + "lat": 40.744654, + "altM": 328 + }, + { + "t": 1789767653000, + "lon": -73.984993, + "lat": 40.744454, + "altM": 328 + }, + { + "t": 1789767654000, + "lon": -73.984449, + "lat": 40.744453, + "altM": 328 + }, + { + "t": 1789767655000, + "lon": -73.984132, + "lat": 40.744425, + "altM": 328 + }, + { + "t": 1789767656000, + "lon": -73.983704, + "lat": 40.744439, + "altM": 328 + }, + { + "t": 1789767657000, + "lon": -73.983239, + "lat": 40.744388, + "altM": 328 + }, + { "t": 1789767658000, "lon": -73.982788, "lat": 40.74458, "altM": 328 }, + { + "t": 1789767659000, + "lon": -73.982374, + "lat": 40.744659, + "altM": 328 + }, + { + "t": 1789767660000, + "lon": -73.982037, + "lat": 40.744774, + "altM": 328 + }, + { + "t": 1789767661000, + "lon": -73.981666, + "lat": 40.744787, + "altM": 328 + }, + { + "t": 1789767662000, + "lon": -73.981327, + "lat": 40.744923, + "altM": 328 + }, + { "t": 1789767663000, "lon": -73.981048, "lat": 40.74517, "altM": 328 }, + { + "t": 1789767664000, + "lon": -73.980675, + "lat": 40.745292, + "altM": 328 + }, + { + "t": 1789767665000, + "lon": -73.980338, + "lat": 40.745466, + "altM": 328 + }, + { + "t": 1789767666000, + "lon": -73.980103, + "lat": 40.745744, + "altM": 328 + }, + { + "t": 1789767667000, + "lon": -73.979909, + "lat": 40.745969, + "altM": 328 + }, + { + "t": 1789767668000, + "lon": -73.979659, + "lat": 40.746196, + "altM": 328 + }, + { "t": 1789767669000, "lon": -73.97942, "lat": 40.746389, "altM": 328 }, + { "t": 1789767670000, "lon": -73.97943, "lat": 40.746643, "altM": 328 }, + { + "t": 1789767671000, + "lon": -73.979234, + "lat": 40.746924, + "altM": 328 + }, + { + "t": 1789767672000, + "lon": -73.979234, + "lat": 40.747161, + "altM": 328 + }, + { + "t": 1789767673000, + "lon": -73.979187, + "lat": 40.747392, + "altM": 328 + }, + { + "t": 1789767674000, + "lon": -73.979169, + "lat": 40.747641, + "altM": 328 + }, + { + "t": 1789767675000, + "lon": -73.979221, + "lat": 40.747809, + "altM": 328 + }, + { + "t": 1789767676000, + "lon": -73.979238, + "lat": 40.748097, + "altM": 328 + }, + { + "t": 1789767677000, + "lon": -73.979319, + "lat": 40.748327, + "altM": 328 + }, + { + "t": 1789767678000, + "lon": -73.979446, + "lat": 40.748488, + "altM": 328 + }, + { + "t": 1789767679000, + "lon": -73.979485, + "lat": 40.748705, + "altM": 328 + }, + { + "t": 1789767680000, + "lon": -73.979711, + "lat": 40.748947, + "altM": 328 + }, + { + "t": 1789767681000, + "lon": -73.979812, + "lat": 40.749163, + "altM": 328 + }, + { + "t": 1789767682000, + "lon": -73.979945, + "lat": 40.749302, + "altM": 328 + }, + { + "t": 1789767683000, + "lon": -73.979971, + "lat": 40.749498, + "altM": 328 + }, + { + "t": 1789767684000, + "lon": -73.980152, + "lat": 40.749707, + "altM": 328 + }, + { "t": 1789767685000, "lon": -73.98033, "lat": 40.749887, "altM": 328 }, + { + "t": 1789767686000, + "lon": -73.980486, + "lat": 40.750076, + "altM": 328 + }, + { + "t": 1789767687000, + "lon": -73.980595, + "lat": 40.750262, + "altM": 328 + }, + { + "t": 1789767688000, + "lon": -73.980816, + "lat": 40.750388, + "altM": 328 + }, + { + "t": 1789767689000, + "lon": -73.980917, + "lat": 40.750643, + "altM": 328 + }, + { + "t": 1789767690000, + "lon": -73.981148, + "lat": 40.750744, + "altM": 328 + }, + { "t": 1789767691000, "lon": -73.98138, "lat": 40.75096, "altM": 320 }, + { + "t": 1789767692000, + "lon": -73.981539, + "lat": 40.751088, + "altM": 320 + }, + { + "t": 1789767693000, + "lon": -73.981819, + "lat": 40.751157, + "altM": 320 + }, + { "t": 1789767694000, "lon": -73.981969, "lat": 40.75125, "altM": 320 }, + { + "t": 1789767695000, + "lon": -73.982187, + "lat": 40.751388, + "altM": 320 + }, + { + "t": 1789767696000, + "lon": -73.982388, + "lat": 40.751477, + "altM": 320 + }, + { + "t": 1789767697000, + "lon": -73.982611, + "lat": 40.751679, + "altM": 320 + }, + { "t": 1789767698000, "lon": -73.98296, "lat": 40.751736, "altM": 320 }, + { + "t": 1789767699000, + "lon": -73.983188, + "lat": 40.751778, + "altM": 320 + }, + { + "t": 1789767700000, + "lon": -73.983426, + "lat": 40.751836, + "altM": 320 + }, + { "t": 1789767701000, "lon": -73.9836, "lat": 40.751934, "altM": 320 }, + { "t": 1789767702000, "lon": -73.98406, "lat": 40.751976, "altM": 320 }, + { + "t": 1789767703000, + "lon": -73.984175, + "lat": 40.751969, + "altM": 320 + }, + { + "t": 1789767704000, + "lon": -73.984461, + "lat": 40.751973, + "altM": 320 + }, + { + "t": 1789767705000, + "lon": -73.984713, + "lat": 40.752096, + "altM": 320 + }, + { "t": 1789767706000, "lon": -73.98494, "lat": 40.75204, "altM": 320 }, + { + "t": 1789767707000, + "lon": -73.985307, + "lat": 40.752013, + "altM": 320 + }, + { + "t": 1789767708000, + "lon": -73.985532, + "lat": 40.752031, + "altM": 320 + }, + { + "t": 1789767709000, + "lon": -73.985793, + "lat": 40.752052, + "altM": 320 + }, + { + "t": 1789767710000, + "lon": -73.986097, + "lat": 40.751957, + "altM": 320 + }, + { "t": 1789767711000, "lon": -73.986399, "lat": 40.75187, "altM": 320 }, + { + "t": 1789767712000, + "lon": -73.986624, + "lat": 40.751875, + "altM": 320 + }, + { + "t": 1789767713000, + "lon": -73.986824, + "lat": 40.751709, + "altM": 320 + }, + { + "t": 1789767714000, + "lon": -73.987161, + "lat": 40.751683, + "altM": 320 + }, + { + "t": 1789767715000, + "lon": -73.987462, + "lat": 40.751584, + "altM": 320 + }, + { + "t": 1789767716000, + "lon": -73.987669, + "lat": 40.751487, + "altM": 320 + }, + { + "t": 1789767717000, + "lon": -73.987879, + "lat": 40.751278, + "altM": 320 + }, + { + "t": 1789767718000, + "lon": -73.988171, + "lat": 40.751131, + "altM": 320 + }, + { + "t": 1789767719000, + "lon": -73.988208, + "lat": 40.751053, + "altM": 320 + }, + { + "t": 1789767720000, + "lon": -73.988554, + "lat": 40.750852, + "altM": 320 + }, + { "t": 1789767721000, "lon": -73.98884, "lat": 40.750649, "altM": 320 }, + { + "t": 1789767722000, + "lon": -73.988954, + "lat": 40.750518, + "altM": 320 + }, + { + "t": 1789767723000, + "lon": -73.989167, + "lat": 40.750296, + "altM": 320 + }, + { + "t": 1789767724000, + "lon": -73.989384, + "lat": 40.749994, + "altM": 312 + }, + { + "t": 1789767725000, + "lon": -73.989473, + "lat": 40.749824, + "altM": 312 + }, + { + "t": 1789767726000, + "lon": -73.989518, + "lat": 40.749523, + "altM": 312 + }, + { "t": 1789767727000, "lon": -73.98971, "lat": 40.749302, "altM": 312 }, + { "t": 1789767728000, "lon": -73.98972, "lat": 40.749014, "altM": 312 }, + { "t": 1789767729000, "lon": -73.989796, "lat": 40.74882, "altM": 312 }, + { + "t": 1789767730000, + "lon": -73.989889, + "lat": 40.748486, + "altM": 312 + }, + { + "t": 1789767731000, + "lon": -73.989844, + "lat": 40.748204, + "altM": 312 + }, + { + "t": 1789767732000, + "lon": -73.989869, + "lat": 40.747887, + "altM": 312 + }, + { + "t": 1789767733000, + "lon": -73.989816, + "lat": 40.747538, + "altM": 312 + }, + { + "t": 1789767734000, + "lon": -73.989562, + "lat": 40.747312, + "altM": 312 + }, + { + "t": 1789767735000, + "lon": -73.989536, + "lat": 40.747088, + "altM": 312 + }, + { + "t": 1789767736000, + "lon": -73.989417, + "lat": 40.746758, + "altM": 312 + }, + { + "t": 1789767737000, + "lon": -73.989225, + "lat": 40.746447, + "altM": 312 + }, + { + "t": 1789767738000, + "lon": -73.988942, + "lat": 40.746205, + "altM": 312 + }, + { + "t": 1789767739000, + "lon": -73.988664, + "lat": 40.745947, + "altM": 312 + }, + { + "t": 1789767740000, + "lon": -73.988455, + "lat": 40.745666, + "altM": 312 + }, + { + "t": 1789767741000, + "lon": -73.988071, + "lat": 40.745501, + "altM": 312 + }, + { + "t": 1789767742000, + "lon": -73.987857, + "lat": 40.745115, + "altM": 312 + }, + { + "t": 1789767743000, + "lon": -73.987514, + "lat": 40.744991, + "altM": 312 + }, + { + "t": 1789767744000, + "lon": -73.987138, + "lat": 40.744812, + "altM": 312 + }, + { + "t": 1789767745000, + "lon": -73.986774, + "lat": 40.744682, + "altM": 312 + }, + { + "t": 1789767746000, + "lon": -73.986337, + "lat": 40.744547, + "altM": 312 + }, + { + "t": 1789767747000, + "lon": -73.985871, + "lat": 40.744478, + "altM": 312 + }, + { + "t": 1789767748000, + "lon": -73.985482, + "lat": 40.744428, + "altM": 312 + }, + { + "t": 1789767749000, + "lon": -73.985144, + "lat": 40.744276, + "altM": 312 + }, + { + "t": 1789767750000, + "lon": -73.984552, + "lat": 40.744322, + "altM": 312 + }, + { + "t": 1789767751000, + "lon": -73.984244, + "lat": 40.744278, + "altM": 312 + }, + { + "t": 1789767752000, + "lon": -73.983824, + "lat": 40.744309, + "altM": 312 + }, + { + "t": 1789767753000, + "lon": -73.983308, + "lat": 40.744369, + "altM": 312 + }, + { + "t": 1789767754000, + "lon": -73.982885, + "lat": 40.744337, + "altM": 312 + }, + { + "t": 1789767755000, + "lon": -73.982576, + "lat": 40.744559, + "altM": 312 + }, + { + "t": 1789767756000, + "lon": -73.982031, + "lat": 40.744631, + "altM": 312 + }, + { "t": 1789767757000, "lon": -73.98182, "lat": 40.744837, "altM": 312 }, + { + "t": 1789767758000, + "lon": -73.981496, + "lat": 40.744908, + "altM": 312 + }, + { + "t": 1789767759000, + "lon": -73.981094, + "lat": 40.745069, + "altM": 312 + }, + { + "t": 1789767760000, + "lon": -73.980867, + "lat": 40.745313, + "altM": 312 + }, + { + "t": 1789767761000, + "lon": -73.980566, + "lat": 40.745499, + "altM": 312 + }, + { + "t": 1789767762000, + "lon": -73.980341, + "lat": 40.745759, + "altM": 312 + }, + { "t": 1789767763000, "lon": -73.98014, "lat": 40.745935, "altM": 312 }, + { + "t": 1789767764000, + "lon": -73.979958, + "lat": 40.746256, + "altM": 312 + }, + { + "t": 1789767765000, + "lon": -73.979791, + "lat": 40.746496, + "altM": 312 + }, + { + "t": 1789767766000, + "lon": -73.979691, + "lat": 40.746773, + "altM": 312 + }, + { + "t": 1789767767000, + "lon": -73.979637, + "lat": 40.746948, + "altM": 312 + }, + { + "t": 1789767768000, + "lon": -73.979597, + "lat": 40.747249, + "altM": 312 + }, + { + "t": 1789767769000, + "lon": -73.979488, + "lat": 40.747478, + "altM": 312 + }, + { + "t": 1789767770000, + "lon": -73.979502, + "lat": 40.747662, + "altM": 312 + }, + { "t": 1789767771000, "lon": -73.97951, "lat": 40.747918, "altM": 312 }, + { + "t": 1789767772000, + "lon": -73.979533, + "lat": 40.748165, + "altM": 312 + }, + { + "t": 1789767773000, + "lon": -73.979559, + "lat": 40.748371, + "altM": 312 + }, + { "t": 1789767774000, "lon": -73.97964, "lat": 40.74859, "altM": 312 }, + { "t": 1789767775000, "lon": -73.97966, "lat": 40.748794, "altM": 312 }, + { + "t": 1789767776000, + "lon": -73.979764, + "lat": 40.749106, + "altM": 312 + }, + { + "t": 1789767777000, + "lon": -73.979787, + "lat": 40.749228, + "altM": 312 + }, + { "t": 1789767778000, "lon": -73.979894, "lat": 40.7495, "altM": 312 }, + { + "t": 1789767779000, + "lon": -73.979963, + "lat": 40.749708, + "altM": 312 + }, + { "t": 1789767780000, "lon": -73.980125, "lat": 40.749896, "altM": 312 } + ] + }, + { + "id": "news-7", + "kind": "helicopter", + "label": "NEWS-7 (illustrative)", + "callsign": "NEWS7", + "registration": "ILLUS-07", + "type": "Airbus H125", + "operator": "Channel 7 News (fictional)", + "role": "news", + "color": "#FFD166", + "points": [ + { + "t": 1789766365000, + "lon": -74.074157, + "lat": 40.772671, + "altM": 290 + }, + { + "t": 1789766366000, + "lon": -74.074004, + "lat": 40.772634, + "altM": 305 + }, + { + "t": 1789766367000, + "lon": -74.073838, + "lat": 40.772583, + "altM": 320 + }, + { + "t": 1789766368000, + "lon": -74.073465, + "lat": 40.772461, + "altM": 335 + }, + { + "t": 1789766369000, + "lon": -74.073073, + "lat": 40.772328, + "altM": 343 + }, + { + "t": 1789766370000, + "lon": -74.072518, + "lat": 40.772294, + "altM": 358 + }, + { + "t": 1789766371000, + "lon": -74.072095, + "lat": 40.772052, + "altM": 366 + }, + { + "t": 1789766372000, + "lon": -74.071486, + "lat": 40.771985, + "altM": 373 + }, + { + "t": 1789766373000, + "lon": -74.070927, + "lat": 40.771786, + "altM": 381 + }, + { + "t": 1789766374000, + "lon": -74.070327, + "lat": 40.771598, + "altM": 389 + }, + { + "t": 1789766375000, + "lon": -74.069768, + "lat": 40.771367, + "altM": 396 + }, + { + "t": 1789766376000, + "lon": -74.069116, + "lat": 40.771239, + "altM": 396 + }, + { + "t": 1789766377000, + "lon": -74.068248, + "lat": 40.771044, + "altM": 404 + }, + { + "t": 1789766378000, + "lon": -74.067654, + "lat": 40.770836, + "altM": 404 + }, + { + "t": 1789766379000, + "lon": -74.067035, + "lat": 40.770659, + "altM": 411 + }, + { + "t": 1789766380000, + "lon": -74.066239, + "lat": 40.770455, + "altM": 411 + }, + { + "t": 1789766381000, + "lon": -74.065554, + "lat": 40.770209, + "altM": 419 + }, + { + "t": 1789766382000, + "lon": -74.064747, + "lat": 40.770101, + "altM": 419 + }, + { + "t": 1789766383000, + "lon": -74.064077, + "lat": 40.769841, + "altM": 419 + }, + { "t": 1789766384000, "lon": -74.063337, "lat": 40.76959, "altM": 427 }, + { + "t": 1789766385000, + "lon": -74.062623, + "lat": 40.769383, + "altM": 427 + }, + { "t": 1789766386000, "lon": -74.06182, "lat": 40.769181, "altM": 427 }, + { + "t": 1789766387000, + "lon": -74.061146, + "lat": 40.769001, + "altM": 427 + }, + { "t": 1789766388000, "lon": -74.06036, "lat": 40.768747, "altM": 427 }, + { "t": 1789766389000, "lon": -74.05971, "lat": 40.768541, "altM": 434 }, + { + "t": 1789766390000, + "lon": -74.058857, + "lat": 40.768414, + "altM": 434 + }, + { + "t": 1789766391000, + "lon": -74.058149, + "lat": 40.768116, + "altM": 434 + }, + { + "t": 1789766392000, + "lon": -74.057294, + "lat": 40.768011, + "altM": 434 + }, + { + "t": 1789766393000, + "lon": -74.056588, + "lat": 40.767763, + "altM": 434 + }, + { + "t": 1789766394000, + "lon": -74.055798, + "lat": 40.767491, + "altM": 434 + }, + { + "t": 1789766395000, + "lon": -74.055126, + "lat": 40.767292, + "altM": 434 + }, + { "t": 1789766396000, "lon": -74.05421, "lat": 40.767099, "altM": 434 }, + { + "t": 1789766397000, + "lon": -74.053399, + "lat": 40.766859, + "altM": 434 + }, + { + "t": 1789766398000, + "lon": -74.052786, + "lat": 40.766659, + "altM": 434 + }, + { + "t": 1789766399000, + "lon": -74.051952, + "lat": 40.766391, + "altM": 442 + }, + { "t": 1789766400000, "lon": -74.051271, "lat": 40.7662, "altM": 442 }, + { "t": 1789766401000, "lon": -74.050443, "lat": 40.76593, "altM": 442 }, + { "t": 1789766402000, "lon": -74.04969, "lat": 40.765762, "altM": 442 }, + { + "t": 1789766403000, + "lon": -74.048854, + "lat": 40.765522, + "altM": 442 + }, + { + "t": 1789766404000, + "lon": -74.048263, + "lat": 40.765326, + "altM": 442 + }, + { + "t": 1789766405000, + "lon": -74.047366, + "lat": 40.765076, + "altM": 442 + }, + { + "t": 1789766406000, + "lon": -74.046692, + "lat": 40.764907, + "altM": 442 + }, + { + "t": 1789766407000, + "lon": -74.045919, + "lat": 40.764706, + "altM": 442 + }, + { + "t": 1789766408000, + "lon": -74.045046, + "lat": 40.764493, + "altM": 442 + }, + { + "t": 1789766409000, + "lon": -74.044324, + "lat": 40.764271, + "altM": 442 + }, + { + "t": 1789766410000, + "lon": -74.043657, + "lat": 40.764085, + "altM": 442 + }, + { + "t": 1789766411000, + "lon": -74.042806, + "lat": 40.763771, + "altM": 442 + }, + { + "t": 1789766412000, + "lon": -74.041965, + "lat": 40.763605, + "altM": 442 + }, + { + "t": 1789766413000, + "lon": -74.041249, + "lat": 40.763367, + "altM": 442 + }, + { + "t": 1789766414000, + "lon": -74.040474, + "lat": 40.763176, + "altM": 442 + }, + { + "t": 1789766415000, + "lon": -74.039632, + "lat": 40.762963, + "altM": 442 + }, + { + "t": 1789766416000, + "lon": -74.038918, + "lat": 40.762689, + "altM": 442 + }, + { + "t": 1789766417000, + "lon": -74.038245, + "lat": 40.762541, + "altM": 442 + }, + { "t": 1789766418000, "lon": -74.037397, "lat": 40.76232, "altM": 442 }, + { + "t": 1789766419000, + "lon": -74.036597, + "lat": 40.762146, + "altM": 442 + }, + { "t": 1789766420000, "lon": -74.03587, "lat": 40.76187, "altM": 442 }, + { + "t": 1789766421000, + "lon": -74.035165, + "lat": 40.761646, + "altM": 442 + }, + { "t": 1789766422000, "lon": -74.034416, "lat": 40.7614, "altM": 442 }, + { + "t": 1789766423000, + "lon": -74.033591, + "lat": 40.761273, + "altM": 442 + }, + { "t": 1789766424000, "lon": -74.03282, "lat": 40.761001, "altM": 442 }, + { + "t": 1789766425000, + "lon": -74.032061, + "lat": 40.760761, + "altM": 442 + }, + { + "t": 1789766426000, + "lon": -74.031215, + "lat": 40.760586, + "altM": 442 + }, + { + "t": 1789766427000, + "lon": -74.030581, + "lat": 40.760353, + "altM": 442 + }, + { + "t": 1789766428000, + "lon": -74.029807, + "lat": 40.760158, + "altM": 442 + }, + { + "t": 1789766429000, + "lon": -74.029085, + "lat": 40.759963, + "altM": 442 + }, + { "t": 1789766430000, "lon": -74.028163, "lat": 40.75973, "altM": 442 }, + { + "t": 1789766431000, + "lon": -74.027362, + "lat": 40.759528, + "altM": 442 + }, + { "t": 1789766432000, "lon": -74.02676, "lat": 40.75924, "altM": 442 }, + { + "t": 1789766433000, + "lon": -74.025935, + "lat": 40.759005, + "altM": 442 + }, + { + "t": 1789766434000, + "lon": -74.025215, + "lat": 40.758877, + "altM": 442 + }, + { + "t": 1789766435000, + "lon": -74.024399, + "lat": 40.758607, + "altM": 442 + }, + { + "t": 1789766436000, + "lon": -74.023637, + "lat": 40.758428, + "altM": 442 + }, + { + "t": 1789766437000, + "lon": -74.022938, + "lat": 40.758152, + "altM": 442 + }, + { + "t": 1789766438000, + "lon": -74.022257, + "lat": 40.757839, + "altM": 442 + }, + { + "t": 1789766439000, + "lon": -74.021522, + "lat": 40.757437, + "altM": 442 + }, + { + "t": 1789766440000, + "lon": -74.020956, + "lat": 40.757006, + "altM": 442 + }, + { + "t": 1789766441000, + "lon": -74.020283, + "lat": 40.756607, + "altM": 442 + }, + { + "t": 1789766442000, + "lon": -74.019824, + "lat": 40.756126, + "altM": 442 + }, + { + "t": 1789766443000, + "lon": -74.019386, + "lat": 40.755605, + "altM": 442 + }, + { "t": 1789766444000, "lon": -74.01897, "lat": 40.755108, "altM": 442 }, + { + "t": 1789766445000, + "lon": -74.018731, + "lat": 40.754569, + "altM": 442 + }, + { + "t": 1789766446000, + "lon": -74.018494, + "lat": 40.753956, + "altM": 442 + }, + { "t": 1789766447000, "lon": -74.018229, "lat": 40.7534, "altM": 442 }, + { + "t": 1789766448000, + "lon": -74.018071, + "lat": 40.752796, + "altM": 442 + }, + { + "t": 1789766449000, + "lon": -74.018072, + "lat": 40.752259, + "altM": 442 + }, + { + "t": 1789766450000, + "lon": -74.018069, + "lat": 40.751724, + "altM": 442 + }, + { + "t": 1789766451000, + "lon": -74.018051, + "lat": 40.751082, + "altM": 442 + }, + { + "t": 1789766452000, + "lon": -74.018415, + "lat": 40.750597, + "altM": 442 + }, + { + "t": 1789766453000, + "lon": -74.018508, + "lat": 40.750028, + "altM": 442 + }, + { + "t": 1789766454000, + "lon": -74.018755, + "lat": 40.749584, + "altM": 442 + }, + { + "t": 1789766455000, + "lon": -74.019139, + "lat": 40.749029, + "altM": 442 + }, + { + "t": 1789766456000, + "lon": -74.019564, + "lat": 40.748609, + "altM": 442 + }, + { + "t": 1789766457000, + "lon": -74.019984, + "lat": 40.748213, + "altM": 442 + }, + { + "t": 1789766458000, + "lon": -74.020548, + "lat": 40.747849, + "altM": 442 + }, + { + "t": 1789766459000, + "lon": -74.020993, + "lat": 40.747505, + "altM": 442 + }, + { "t": 1789766460000, "lon": -74.021628, "lat": 40.74726, "altM": 442 }, + { + "t": 1789766461000, + "lon": -74.022164, + "lat": 40.747067, + "altM": 442 + }, + { + "t": 1789766462000, + "lon": -74.022898, + "lat": 40.746907, + "altM": 442 + }, + { + "t": 1789766463000, + "lon": -74.023422, + "lat": 40.746724, + "altM": 442 + }, + { + "t": 1789766464000, + "lon": -74.024076, + "lat": 40.746677, + "altM": 442 + }, + { + "t": 1789766465000, + "lon": -74.024747, + "lat": 40.746592, + "altM": 442 + }, + { + "t": 1789766466000, + "lon": -74.025441, + "lat": 40.746615, + "altM": 442 + }, + { + "t": 1789766467000, + "lon": -74.026022, + "lat": 40.746724, + "altM": 442 + }, + { + "t": 1789766468000, + "lon": -74.026697, + "lat": 40.746773, + "altM": 442 + }, + { + "t": 1789766469000, + "lon": -74.027198, + "lat": 40.747071, + "altM": 442 + }, + { "t": 1789766470000, "lon": -74.02778, "lat": 40.747333, "altM": 442 }, + { + "t": 1789766471000, + "lon": -74.028384, + "lat": 40.747623, + "altM": 442 + }, + { "t": 1789766472000, "lon": -74.028892, "lat": 40.74785, "altM": 442 }, + { + "t": 1789766473000, + "lon": -74.029262, + "lat": 40.748193, + "altM": 442 + }, + { + "t": 1789766474000, + "lon": -74.029627, + "lat": 40.748643, + "altM": 442 + }, + { "t": 1789766475000, "lon": -74.030161, "lat": 40.74913, "altM": 442 }, + { + "t": 1789766476000, + "lon": -74.030397, + "lat": 40.749576, + "altM": 442 + }, + { + "t": 1789766477000, + "lon": -74.030463, + "lat": 40.750083, + "altM": 442 + }, + { + "t": 1789766478000, + "lon": -74.030657, + "lat": 40.750519, + "altM": 442 + }, + { + "t": 1789766479000, + "lon": -74.030781, + "lat": 40.751068, + "altM": 442 + }, + { + "t": 1789766480000, + "lon": -74.030776, + "lat": 40.751621, + "altM": 442 + }, + { + "t": 1789766481000, + "lon": -74.030669, + "lat": 40.752113, + "altM": 442 + }, + { + "t": 1789766482000, + "lon": -74.030604, + "lat": 40.752758, + "altM": 442 + }, + { + "t": 1789766483000, + "lon": -74.030294, + "lat": 40.753185, + "altM": 450 + }, + { + "t": 1789766484000, + "lon": -74.030068, + "lat": 40.753657, + "altM": 450 + }, + { + "t": 1789766485000, + "lon": -74.029827, + "lat": 40.754104, + "altM": 450 + }, + { + "t": 1789766486000, + "lon": -74.029449, + "lat": 40.754592, + "altM": 450 + }, + { "t": 1789766487000, "lon": -74.029032, "lat": 40.75496, "altM": 450 }, + { + "t": 1789766488000, + "lon": -74.028581, + "lat": 40.755332, + "altM": 450 + }, + { + "t": 1789766489000, + "lon": -74.028028, + "lat": 40.755702, + "altM": 450 + }, + { + "t": 1789766490000, + "lon": -74.027355, + "lat": 40.756044, + "altM": 450 + }, + { + "t": 1789766491000, + "lon": -74.026806, + "lat": 40.756262, + "altM": 450 + }, + { + "t": 1789766492000, + "lon": -74.026257, + "lat": 40.756555, + "altM": 450 + }, + { + "t": 1789766493000, + "lon": -74.025459, + "lat": 40.756658, + "altM": 457 + }, + { + "t": 1789766494000, + "lon": -74.024768, + "lat": 40.756874, + "altM": 457 + }, + { "t": 1789766495000, "lon": -74.02415, "lat": 40.756966, "altM": 457 }, + { + "t": 1789766496000, + "lon": -74.023413, + "lat": 40.757079, + "altM": 457 + }, + { + "t": 1789766497000, + "lon": -74.022705, + "lat": 40.757039, + "altM": 457 + }, + { + "t": 1789766498000, + "lon": -74.022007, + "lat": 40.757005, + "altM": 457 + }, + { + "t": 1789766499000, + "lon": -74.021159, + "lat": 40.756989, + "altM": 457 + }, + { + "t": 1789766500000, + "lon": -74.020612, + "lat": 40.756771, + "altM": 457 + }, + { + "t": 1789766501000, + "lon": -74.019866, + "lat": 40.756627, + "altM": 457 + }, + { + "t": 1789766502000, + "lon": -74.019075, + "lat": 40.756522, + "altM": 457 + }, + { "t": 1789766503000, "lon": -74.01845, "lat": 40.756416, "altM": 457 }, + { + "t": 1789766504000, + "lon": -74.017714, + "lat": 40.756232, + "altM": 457 + }, + { + "t": 1789766505000, + "lon": -74.017016, + "lat": 40.756152, + "altM": 457 + }, + { + "t": 1789766506000, + "lon": -74.016272, + "lat": 40.755925, + "altM": 457 + }, + { + "t": 1789766507000, + "lon": -74.015592, + "lat": 40.755775, + "altM": 457 + }, + { + "t": 1789766508000, + "lon": -74.014902, + "lat": 40.755762, + "altM": 457 + }, + { + "t": 1789766509000, + "lon": -74.014265, + "lat": 40.755476, + "altM": 457 + }, + { + "t": 1789766510000, + "lon": -74.013525, + "lat": 40.755374, + "altM": 457 + }, + { + "t": 1789766511000, + "lon": -74.012772, + "lat": 40.755258, + "altM": 457 + }, + { + "t": 1789766512000, + "lon": -74.012082, + "lat": 40.755131, + "altM": 457 + }, + { + "t": 1789766513000, + "lon": -74.011385, + "lat": 40.755021, + "altM": 457 + }, + { + "t": 1789766514000, + "lon": -74.010723, + "lat": 40.754884, + "altM": 457 + }, + { + "t": 1789766515000, + "lon": -74.010016, + "lat": 40.754708, + "altM": 457 + }, + { "t": 1789766516000, "lon": -74.009311, "lat": 40.75463, "altM": 457 }, + { + "t": 1789766517000, + "lon": -74.008575, + "lat": 40.754537, + "altM": 457 + }, + { "t": 1789766518000, "lon": -74.007874, "lat": 40.75438, "altM": 457 }, + { "t": 1789766519000, "lon": -74.00718, "lat": 40.754151, "altM": 457 }, + { "t": 1789766520000, "lon": -74.006454, "lat": 40.75408, "altM": 457 }, + { + "t": 1789766521000, + "lon": -74.005833, + "lat": 40.753777, + "altM": 457 + }, + { "t": 1789766522000, "lon": -74.005094, "lat": 40.75377, "altM": 457 }, + { + "t": 1789766523000, + "lon": -74.004384, + "lat": 40.753633, + "altM": 457 + }, + { + "t": 1789766524000, + "lon": -74.003699, + "lat": 40.753506, + "altM": 457 + }, + { "t": 1789766525000, "lon": -74.003001, "lat": 40.75339, "altM": 457 }, + { + "t": 1789766526000, + "lon": -74.002233, + "lat": 40.753265, + "altM": 457 + }, + { + "t": 1789766527000, + "lon": -74.001485, + "lat": 40.753079, + "altM": 457 + }, + { + "t": 1789766528000, + "lon": -74.000939, + "lat": 40.752965, + "altM": 457 + }, + { + "t": 1789766529000, + "lon": -74.000133, + "lat": 40.752864, + "altM": 457 + }, + { "t": 1789766530000, "lon": -73.999494, "lat": 40.7528, "altM": 457 }, + { + "t": 1789766531000, + "lon": -73.998707, + "lat": 40.752568, + "altM": 457 + }, + { + "t": 1789766532000, + "lon": -73.998026, + "lat": 40.752501, + "altM": 457 + }, + { + "t": 1789766533000, + "lon": -73.997357, + "lat": 40.752331, + "altM": 457 + }, + { + "t": 1789766534000, + "lon": -73.996727, + "lat": 40.752242, + "altM": 457 + }, + { + "t": 1789766535000, + "lon": -73.996108, + "lat": 40.752184, + "altM": 457 + }, + { "t": 1789766536000, "lon": -73.995483, "lat": 40.752, "altM": 457 }, + { + "t": 1789766537000, + "lon": -73.994762, + "lat": 40.751939, + "altM": 457 + }, + { + "t": 1789766538000, + "lon": -73.994225, + "lat": 40.751854, + "altM": 457 + }, + { + "t": 1789766539000, + "lon": -73.993599, + "lat": 40.751631, + "altM": 457 + }, + { + "t": 1789766540000, + "lon": -73.993071, + "lat": 40.751709, + "altM": 457 + }, + { + "t": 1789766541000, + "lon": -73.992395, + "lat": 40.751557, + "altM": 457 + }, + { + "t": 1789766542000, + "lon": -73.991959, + "lat": 40.751548, + "altM": 457 + }, + { + "t": 1789766543000, + "lon": -73.991227, + "lat": 40.751527, + "altM": 457 + }, + { + "t": 1789766544000, + "lon": -73.990729, + "lat": 40.751653, + "altM": 457 + }, + { + "t": 1789766545000, + "lon": -73.990105, + "lat": 40.751683, + "altM": 457 + }, + { + "t": 1789766546000, + "lon": -73.989653, + "lat": 40.751837, + "altM": 457 + }, + { "t": 1789766547000, "lon": -73.9891, "lat": 40.751971, "altM": 457 }, + { + "t": 1789766548000, + "lon": -73.988411, + "lat": 40.752068, + "altM": 457 + }, + { + "t": 1789766549000, + "lon": -73.988071, + "lat": 40.752398, + "altM": 457 + }, + { + "t": 1789766550000, + "lon": -73.987668, + "lat": 40.752634, + "altM": 457 + }, + { + "t": 1789766551000, + "lon": -73.987282, + "lat": 40.752865, + "altM": 457 + }, + { + "t": 1789766552000, + "lon": -73.986914, + "lat": 40.753121, + "altM": 457 + }, + { "t": 1789766553000, "lon": -73.9865, "lat": 40.753481, "altM": 457 }, + { + "t": 1789766554000, + "lon": -73.986285, + "lat": 40.753698, + "altM": 457 + }, + { "t": 1789766555000, "lon": -73.986082, "lat": 40.75404, "altM": 457 }, + { + "t": 1789766556000, + "lon": -73.985852, + "lat": 40.754369, + "altM": 457 + }, + { + "t": 1789766557000, + "lon": -73.985724, + "lat": 40.754717, + "altM": 457 + }, + { + "t": 1789766558000, + "lon": -73.985755, + "lat": 40.755063, + "altM": 457 + }, + { + "t": 1789766559000, + "lon": -73.985556, + "lat": 40.755401, + "altM": 457 + }, + { + "t": 1789766560000, + "lon": -73.985586, + "lat": 40.755723, + "altM": 457 + }, + { + "t": 1789766561000, + "lon": -73.985592, + "lat": 40.756045, + "altM": 457 + }, + { + "t": 1789766562000, + "lon": -73.985804, + "lat": 40.756378, + "altM": 457 + }, + { + "t": 1789766563000, + "lon": -73.985811, + "lat": 40.756667, + "altM": 465 + }, + { "t": 1789766564000, "lon": -73.98611, "lat": 40.756965, "altM": 465 }, + { + "t": 1789766565000, + "lon": -73.986222, + "lat": 40.757253, + "altM": 465 + }, + { + "t": 1789766566000, + "lon": -73.986474, + "lat": 40.757521, + "altM": 465 + }, + { + "t": 1789766567000, + "lon": -73.986805, + "lat": 40.757691, + "altM": 465 + }, + { + "t": 1789766568000, + "lon": -73.986939, + "lat": 40.757865, + "altM": 465 + }, + { + "t": 1789766569000, + "lon": -73.987386, + "lat": 40.758069, + "altM": 465 + }, + { + "t": 1789766570000, + "lon": -73.987608, + "lat": 40.758132, + "altM": 465 + }, + { + "t": 1789766571000, + "lon": -73.988018, + "lat": 40.758265, + "altM": 465 + }, + { + "t": 1789766572000, + "lon": -73.988355, + "lat": 40.758445, + "altM": 465 + }, + { + "t": 1789766573000, + "lon": -73.988734, + "lat": 40.758366, + "altM": 465 + }, + { + "t": 1789766574000, + "lon": -73.989102, + "lat": 40.758346, + "altM": 465 + }, + { + "t": 1789766575000, + "lon": -73.989513, + "lat": 40.758426, + "altM": 465 + }, + { "t": 1789766576000, "lon": -73.989849, "lat": 40.75832, "altM": 465 }, + { + "t": 1789766577000, + "lon": -73.990299, + "lat": 40.758153, + "altM": 465 + }, + { + "t": 1789766578000, + "lon": -73.990612, + "lat": 40.758109, + "altM": 465 + }, + { + "t": 1789766579000, + "lon": -73.990878, + "lat": 40.757827, + "altM": 465 + }, + { + "t": 1789766580000, + "lon": -73.991352, + "lat": 40.757747, + "altM": 465 + }, + { + "t": 1789766581000, + "lon": -73.991583, + "lat": 40.757451, + "altM": 465 + }, + { + "t": 1789766582000, + "lon": -73.991833, + "lat": 40.757221, + "altM": 465 + }, + { + "t": 1789766583000, + "lon": -73.992156, + "lat": 40.756951, + "altM": 465 + }, + { + "t": 1789766584000, + "lon": -73.992361, + "lat": 40.756641, + "altM": 465 + }, + { + "t": 1789766585000, + "lon": -73.992491, + "lat": 40.756313, + "altM": 465 + }, + { + "t": 1789766586000, + "lon": -73.992642, + "lat": 40.755995, + "altM": 465 + }, + { + "t": 1789766587000, + "lon": -73.992657, + "lat": 40.755625, + "altM": 465 + }, + { + "t": 1789766588000, + "lon": -73.992813, + "lat": 40.755287, + "altM": 465 + }, + { "t": 1789766589000, "lon": -73.99283, "lat": 40.754925, "altM": 465 }, + { + "t": 1789766590000, + "lon": -73.992807, + "lat": 40.754605, + "altM": 465 + }, + { "t": 1789766591000, "lon": -73.992678, "lat": 40.75419, "altM": 465 }, + { + "t": 1789766592000, + "lon": -73.992626, + "lat": 40.753824, + "altM": 465 + }, + { "t": 1789766593000, "lon": -73.99239, "lat": 40.753497, "altM": 465 }, + { "t": 1789766594000, "lon": -73.992172, "lat": 40.75308, "altM": 465 }, + { + "t": 1789766595000, + "lon": -73.992037, + "lat": 40.752713, + "altM": 465 + }, + { "t": 1789766596000, "lon": -73.99178, "lat": 40.752413, "altM": 465 }, + { + "t": 1789766597000, + "lon": -73.991617, + "lat": 40.751958, + "altM": 465 + }, + { + "t": 1789766598000, + "lon": -73.991596, + "lat": 40.751633, + "altM": 465 + }, + { + "t": 1789766599000, + "lon": -73.991472, + "lat": 40.751208, + "altM": 465 + }, + { + "t": 1789766600000, + "lon": -73.991539, + "lat": 40.750877, + "altM": 465 + }, + { + "t": 1789766601000, + "lon": -73.991542, + "lat": 40.750522, + "altM": 465 + }, + { + "t": 1789766602000, + "lon": -73.991546, + "lat": 40.750137, + "altM": 465 + }, + { + "t": 1789766603000, + "lon": -73.991747, + "lat": 40.749802, + "altM": 465 + }, + { + "t": 1789766604000, + "lon": -73.991788, + "lat": 40.749447, + "altM": 465 + }, + { "t": 1789766605000, "lon": -73.99182, "lat": 40.749083, "altM": 465 }, + { + "t": 1789766606000, + "lon": -73.991764, + "lat": 40.748663, + "altM": 465 + }, + { + "t": 1789766607000, + "lon": -73.991737, + "lat": 40.748293, + "altM": 465 + }, + { + "t": 1789766608000, + "lon": -73.991644, + "lat": 40.747895, + "altM": 465 + }, + { + "t": 1789766609000, + "lon": -73.991484, + "lat": 40.747551, + "altM": 465 + }, + { + "t": 1789766610000, + "lon": -73.991296, + "lat": 40.747149, + "altM": 465 + }, + { "t": 1789766611000, "lon": -73.991152, "lat": 40.74685, "altM": 465 }, + { + "t": 1789766612000, + "lon": -73.990961, + "lat": 40.746504, + "altM": 465 + }, + { + "t": 1789766613000, + "lon": -73.990592, + "lat": 40.746155, + "altM": 465 + }, + { + "t": 1789766614000, + "lon": -73.990307, + "lat": 40.745816, + "altM": 465 + }, + { + "t": 1789766615000, + "lon": -73.989804, + "lat": 40.745434, + "altM": 465 + }, + { + "t": 1789766616000, + "lon": -73.989611, + "lat": 40.745179, + "altM": 465 + }, + { "t": 1789766617000, "lon": -73.98926, "lat": 40.74488, "altM": 465 }, + { + "t": 1789766618000, + "lon": -73.988755, + "lat": 40.744645, + "altM": 465 + }, + { "t": 1789766619000, "lon": -73.9883, "lat": 40.744474, "altM": 465 }, + { + "t": 1789766620000, + "lon": -73.988001, + "lat": 40.744186, + "altM": 465 + }, + { + "t": 1789766621000, + "lon": -73.987361, + "lat": 40.744045, + "altM": 465 + }, + { + "t": 1789766622000, + "lon": -73.986832, + "lat": 40.743819, + "altM": 465 + }, + { + "t": 1789766623000, + "lon": -73.986342, + "lat": 40.743756, + "altM": 465 + }, + { + "t": 1789766624000, + "lon": -73.985816, + "lat": 40.743632, + "altM": 465 + }, + { + "t": 1789766625000, + "lon": -73.985239, + "lat": 40.743567, + "altM": 465 + }, + { + "t": 1789766626000, + "lon": -73.984724, + "lat": 40.743447, + "altM": 465 + }, + { + "t": 1789766627000, + "lon": -73.984209, + "lat": 40.743511, + "altM": 465 + }, + { + "t": 1789766628000, + "lon": -73.983632, + "lat": 40.743529, + "altM": 465 + }, + { "t": 1789766629000, "lon": -73.983164, "lat": 40.74359, "altM": 465 }, + { "t": 1789766630000, "lon": -73.982597, "lat": 40.74369, "altM": 465 }, + { + "t": 1789766631000, + "lon": -73.982064, + "lat": 40.743698, + "altM": 465 + }, + { + "t": 1789766632000, + "lon": -73.981591, + "lat": 40.743867, + "altM": 465 + }, + { + "t": 1789766633000, + "lon": -73.981083, + "lat": 40.744014, + "altM": 465 + }, + { + "t": 1789766634000, + "lon": -73.980628, + "lat": 40.744267, + "altM": 465 + }, + { + "t": 1789766635000, + "lon": -73.980256, + "lat": 40.744487, + "altM": 465 + }, + { + "t": 1789766636000, + "lon": -73.979766, + "lat": 40.744641, + "altM": 465 + }, + { "t": 1789766637000, "lon": -73.979377, "lat": 40.74484, "altM": 457 }, + { + "t": 1789766638000, + "lon": -73.979065, + "lat": 40.745179, + "altM": 457 + }, + { + "t": 1789766639000, + "lon": -73.978634, + "lat": 40.745321, + "altM": 457 + }, + { + "t": 1789766640000, + "lon": -73.978415, + "lat": 40.745673, + "altM": 457 + }, + { + "t": 1789766641000, + "lon": -73.977994, + "lat": 40.746007, + "altM": 457 + }, + { + "t": 1789766642000, + "lon": -73.977797, + "lat": 40.746291, + "altM": 457 + }, + { + "t": 1789766643000, + "lon": -73.977586, + "lat": 40.746516, + "altM": 457 + }, + { + "t": 1789766644000, + "lon": -73.977403, + "lat": 40.746899, + "altM": 457 + }, + { + "t": 1789766645000, + "lon": -73.977172, + "lat": 40.747221, + "altM": 457 + }, + { + "t": 1789766646000, + "lon": -73.977051, + "lat": 40.747488, + "altM": 457 + }, + { "t": 1789766647000, "lon": -73.97688, "lat": 40.747892, "altM": 457 }, + { + "t": 1789766648000, + "lon": -73.976802, + "lat": 40.748258, + "altM": 457 + }, + { + "t": 1789766649000, + "lon": -73.976735, + "lat": 40.748527, + "altM": 457 + }, + { + "t": 1789766650000, + "lon": -73.976664, + "lat": 40.748834, + "altM": 457 + }, + { + "t": 1789766651000, + "lon": -73.976696, + "lat": 40.749178, + "altM": 457 + }, + { + "t": 1789766652000, + "lon": -73.976709, + "lat": 40.749474, + "altM": 457 + }, + { + "t": 1789766653000, + "lon": -73.976664, + "lat": 40.749801, + "altM": 457 + }, + { + "t": 1789766654000, + "lon": -73.976633, + "lat": 40.750235, + "altM": 457 + }, + { + "t": 1789766655000, + "lon": -73.976787, + "lat": 40.750448, + "altM": 457 + }, + { + "t": 1789766656000, + "lon": -73.976849, + "lat": 40.750753, + "altM": 457 + }, + { + "t": 1789766657000, + "lon": -73.976933, + "lat": 40.751113, + "altM": 457 + }, + { + "t": 1789766658000, + "lon": -73.976998, + "lat": 40.751426, + "altM": 457 + }, + { + "t": 1789766659000, + "lon": -73.977262, + "lat": 40.751646, + "altM": 457 + }, + { + "t": 1789766660000, + "lon": -73.977466, + "lat": 40.751982, + "altM": 457 + }, + { "t": 1789766661000, "lon": -73.97761, "lat": 40.752182, "altM": 457 }, + { + "t": 1789766662000, + "lon": -73.977724, + "lat": 40.752545, + "altM": 457 + }, + { + "t": 1789766663000, + "lon": -73.977986, + "lat": 40.752786, + "altM": 457 + }, + { + "t": 1789766664000, + "lon": -73.978193, + "lat": 40.752998, + "altM": 457 + }, + { "t": 1789766665000, "lon": -73.978418, "lat": 40.75321, "altM": 457 }, + { + "t": 1789766666000, + "lon": -73.978664, + "lat": 40.753469, + "altM": 457 + }, + { + "t": 1789766667000, + "lon": -73.978931, + "lat": 40.753678, + "altM": 457 + }, + { + "t": 1789766668000, + "lon": -73.979251, + "lat": 40.753897, + "altM": 457 + }, + { + "t": 1789766669000, + "lon": -73.979505, + "lat": 40.754013, + "altM": 457 + }, + { + "t": 1789766670000, + "lon": -73.979833, + "lat": 40.754301, + "altM": 457 + }, + { + "t": 1789766671000, + "lon": -73.980106, + "lat": 40.754444, + "altM": 457 + }, + { "t": 1789766672000, "lon": -73.980439, "lat": 40.7545, "altM": 457 }, + { + "t": 1789766673000, + "lon": -73.980691, + "lat": 40.754775, + "altM": 457 + }, + { + "t": 1789766674000, + "lon": -73.981056, + "lat": 40.754887, + "altM": 457 + }, + { + "t": 1789766675000, + "lon": -73.981452, + "lat": 40.754986, + "altM": 450 + }, + { + "t": 1789766676000, + "lon": -73.981789, + "lat": 40.755135, + "altM": 450 + }, + { + "t": 1789766677000, + "lon": -73.982166, + "lat": 40.755216, + "altM": 450 + }, + { + "t": 1789766678000, + "lon": -73.982486, + "lat": 40.755262, + "altM": 450 + }, + { + "t": 1789766679000, + "lon": -73.982961, + "lat": 40.755318, + "altM": 450 + }, + { + "t": 1789766680000, + "lon": -73.983225, + "lat": 40.755376, + "altM": 450 + }, + { "t": 1789766681000, "lon": -73.983627, "lat": 40.75539, "altM": 450 }, + { + "t": 1789766682000, + "lon": -73.983981, + "lat": 40.755458, + "altM": 450 + }, + { "t": 1789766683000, "lon": -73.98437, "lat": 40.755513, "altM": 450 }, + { "t": 1789766684000, "lon": -73.984774, "lat": 40.75552, "altM": 450 }, + { + "t": 1789766685000, + "lon": -73.985123, + "lat": 40.755553, + "altM": 450 + }, + { + "t": 1789766686000, + "lon": -73.985472, + "lat": 40.755466, + "altM": 450 + }, + { + "t": 1789766687000, + "lon": -73.985979, + "lat": 40.755425, + "altM": 450 + }, + { + "t": 1789766688000, + "lon": -73.986248, + "lat": 40.755446, + "altM": 450 + }, + { + "t": 1789766689000, + "lon": -73.986655, + "lat": 40.755261, + "altM": 450 + }, + { "t": 1789766690000, "lon": -73.987142, "lat": 40.75524, "altM": 450 }, + { + "t": 1789766691000, + "lon": -73.987439, + "lat": 40.755184, + "altM": 450 + }, + { + "t": 1789766692000, + "lon": -73.987772, + "lat": 40.755071, + "altM": 450 + }, + { "t": 1789766693000, "lon": -73.98818, "lat": 40.754915, "altM": 450 }, + { + "t": 1789766694000, + "lon": -73.988492, + "lat": 40.754784, + "altM": 450 + }, + { + "t": 1789766695000, + "lon": -73.988839, + "lat": 40.754611, + "altM": 450 + }, + { + "t": 1789766696000, + "lon": -73.989221, + "lat": 40.754457, + "altM": 450 + }, + { + "t": 1789766697000, + "lon": -73.989554, + "lat": 40.754366, + "altM": 450 + }, + { + "t": 1789766698000, + "lon": -73.989914, + "lat": 40.754055, + "altM": 450 + }, + { + "t": 1789766699000, + "lon": -73.990212, + "lat": 40.753877, + "altM": 450 + }, + { + "t": 1789766700000, + "lon": -73.990415, + "lat": 40.753695, + "altM": 450 + }, + { + "t": 1789766701000, + "lon": -73.990625, + "lat": 40.753389, + "altM": 450 + }, + { + "t": 1789766702000, + "lon": -73.991012, + "lat": 40.753125, + "altM": 450 + }, + { + "t": 1789766703000, + "lon": -73.991359, + "lat": 40.752868, + "altM": 450 + }, + { + "t": 1789766704000, + "lon": -73.991466, + "lat": 40.752647, + "altM": 450 + }, + { "t": 1789766705000, "lon": -73.991728, "lat": 40.75233, "altM": 450 }, + { + "t": 1789766706000, + "lon": -73.991978, + "lat": 40.751984, + "altM": 450 + }, + { + "t": 1789766707000, + "lon": -73.992046, + "lat": 40.751673, + "altM": 450 + }, + { + "t": 1789766708000, + "lon": -73.992301, + "lat": 40.751431, + "altM": 450 + }, + { + "t": 1789766709000, + "lon": -73.992468, + "lat": 40.751097, + "altM": 450 + }, + { "t": 1789766710000, "lon": -73.992601, "lat": 40.7507, "altM": 450 }, + { "t": 1789766711000, "lon": -73.992656, "lat": 40.75041, "altM": 450 }, + { "t": 1789766712000, "lon": -73.99283, "lat": 40.75003, "altM": 450 }, + { + "t": 1789766713000, + "lon": -73.992791, + "lat": 40.749672, + "altM": 450 + }, + { + "t": 1789766714000, + "lon": -73.992753, + "lat": 40.749267, + "altM": 450 + }, + { "t": 1789766715000, "lon": -73.992702, "lat": 40.7489, "altM": 450 }, + { + "t": 1789766716000, + "lon": -73.992693, + "lat": 40.748562, + "altM": 450 + }, + { + "t": 1789766717000, + "lon": -73.992713, + "lat": 40.748219, + "altM": 450 + }, + { + "t": 1789766718000, + "lon": -73.992553, + "lat": 40.747826, + "altM": 450 + }, + { + "t": 1789766719000, + "lon": -73.992262, + "lat": 40.747437, + "altM": 450 + }, + { + "t": 1789766720000, + "lon": -73.992243, + "lat": 40.747072, + "altM": 450 + }, + { "t": 1789766721000, "lon": -73.99193, "lat": 40.746665, "altM": 450 }, + { + "t": 1789766722000, + "lon": -73.991757, + "lat": 40.746324, + "altM": 450 + }, + { + "t": 1789766723000, + "lon": -73.991386, + "lat": 40.745976, + "altM": 450 + }, + { + "t": 1789766724000, + "lon": -73.991202, + "lat": 40.745643, + "altM": 450 + }, + { + "t": 1789766725000, + "lon": -73.990889, + "lat": 40.745315, + "altM": 450 + }, + { + "t": 1789766726000, + "lon": -73.990438, + "lat": 40.745081, + "altM": 450 + }, + { + "t": 1789766727000, + "lon": -73.990197, + "lat": 40.744733, + "altM": 450 + }, + { + "t": 1789766728000, + "lon": -73.989664, + "lat": 40.744402, + "altM": 450 + }, + { + "t": 1789766729000, + "lon": -73.989243, + "lat": 40.744196, + "altM": 450 + }, + { + "t": 1789766730000, + "lon": -73.988775, + "lat": 40.743945, + "altM": 450 + }, + { + "t": 1789766731000, + "lon": -73.988409, + "lat": 40.743767, + "altM": 450 + }, + { + "t": 1789766732000, + "lon": -73.987802, + "lat": 40.743565, + "altM": 450 + }, + { + "t": 1789766733000, + "lon": -73.987283, + "lat": 40.743398, + "altM": 450 + }, + { + "t": 1789766734000, + "lon": -73.986845, + "lat": 40.743202, + "altM": 450 + }, + { + "t": 1789766735000, + "lon": -73.986367, + "lat": 40.743221, + "altM": 450 + }, + { + "t": 1789766736000, + "lon": -73.985731, + "lat": 40.743067, + "altM": 450 + }, + { + "t": 1789766737000, + "lon": -73.985258, + "lat": 40.743068, + "altM": 450 + }, + { + "t": 1789766738000, + "lon": -73.984624, + "lat": 40.743022, + "altM": 450 + }, + { + "t": 1789766739000, + "lon": -73.984082, + "lat": 40.743015, + "altM": 450 + }, + { + "t": 1789766740000, + "lon": -73.983497, + "lat": 40.743017, + "altM": 450 + }, + { + "t": 1789766741000, + "lon": -73.983099, + "lat": 40.743103, + "altM": 450 + }, + { + "t": 1789766742000, + "lon": -73.982525, + "lat": 40.743114, + "altM": 450 + }, + { + "t": 1789766743000, + "lon": -73.981957, + "lat": 40.743214, + "altM": 450 + }, + { + "t": 1789766744000, + "lon": -73.981572, + "lat": 40.743407, + "altM": 450 + }, + { "t": 1789766745000, "lon": -73.9811, "lat": 40.743574, "altM": 450 }, + { "t": 1789766746000, "lon": -73.98058, "lat": 40.74365, "altM": 450 }, + { + "t": 1789766747000, + "lon": -73.980236, + "lat": 40.743922, + "altM": 450 + }, + { + "t": 1789766748000, + "lon": -73.979697, + "lat": 40.744102, + "altM": 450 + }, + { + "t": 1789766749000, + "lon": -73.979378, + "lat": 40.744334, + "altM": 450 + }, + { + "t": 1789766750000, + "lon": -73.978829, + "lat": 40.744618, + "altM": 450 + }, + { + "t": 1789766751000, + "lon": -73.978715, + "lat": 40.744875, + "altM": 450 + }, + { + "t": 1789766752000, + "lon": -73.978241, + "lat": 40.745274, + "altM": 450 + }, + { + "t": 1789766753000, + "lon": -73.977849, + "lat": 40.745419, + "altM": 450 + }, + { "t": 1789766754000, "lon": -73.977656, "lat": 40.74573, "altM": 450 }, + { + "t": 1789766755000, + "lon": -73.977448, + "lat": 40.746049, + "altM": 450 + }, + { + "t": 1789766756000, + "lon": -73.977214, + "lat": 40.746344, + "altM": 457 + }, + { + "t": 1789766757000, + "lon": -73.976921, + "lat": 40.746717, + "altM": 457 + }, + { "t": 1789766758000, "lon": -73.976881, "lat": 40.74705, "altM": 457 }, + { + "t": 1789766759000, + "lon": -73.976689, + "lat": 40.747337, + "altM": 457 + }, + { + "t": 1789766760000, + "lon": -73.976673, + "lat": 40.747615, + "altM": 457 + }, + { "t": 1789766761000, "lon": -73.97654, "lat": 40.747926, "altM": 457 }, + { + "t": 1789766762000, + "lon": -73.976348, + "lat": 40.748257, + "altM": 457 + }, + { + "t": 1789766763000, + "lon": -73.976403, + "lat": 40.748667, + "altM": 457 + }, + { + "t": 1789766764000, + "lon": -73.976454, + "lat": 40.749022, + "altM": 457 + }, + { + "t": 1789766765000, + "lon": -73.976415, + "lat": 40.749316, + "altM": 457 + }, + { + "t": 1789766766000, + "lon": -73.976384, + "lat": 40.749656, + "altM": 457 + }, + { + "t": 1789766767000, + "lon": -73.976447, + "lat": 40.749994, + "altM": 457 + }, + { "t": 1789766768000, "lon": -73.976407, "lat": 40.7503, "altM": 457 }, + { "t": 1789766769000, "lon": -73.97664, "lat": 40.750524, "altM": 457 }, + { + "t": 1789766770000, + "lon": -73.976748, + "lat": 40.750863, + "altM": 457 + }, + { + "t": 1789766771000, + "lon": -73.976843, + "lat": 40.751193, + "altM": 457 + }, + { "t": 1789766772000, "lon": -73.976996, "lat": 40.75148, "altM": 457 }, + { "t": 1789766773000, "lon": -73.97704, "lat": 40.751735, "altM": 457 }, + { + "t": 1789766774000, + "lon": -73.977258, + "lat": 40.752047, + "altM": 457 + }, + { + "t": 1789766775000, + "lon": -73.977446, + "lat": 40.752285, + "altM": 457 + }, + { + "t": 1789766776000, + "lon": -73.977687, + "lat": 40.752559, + "altM": 457 + }, + { + "t": 1789766777000, + "lon": -73.977837, + "lat": 40.752767, + "altM": 457 + }, + { + "t": 1789766778000, + "lon": -73.978237, + "lat": 40.753033, + "altM": 457 + }, + { + "t": 1789766779000, + "lon": -73.978368, + "lat": 40.753176, + "altM": 457 + }, + { + "t": 1789766780000, + "lon": -73.978656, + "lat": 40.753444, + "altM": 457 + }, + { + "t": 1789766781000, + "lon": -73.978898, + "lat": 40.753684, + "altM": 457 + }, + { "t": 1789766782000, "lon": -73.979182, "lat": 40.75384, "altM": 457 }, + { + "t": 1789766783000, + "lon": -73.979605, + "lat": 40.754007, + "altM": 457 + }, + { + "t": 1789766784000, + "lon": -73.979917, + "lat": 40.754203, + "altM": 457 + }, + { + "t": 1789766785000, + "lon": -73.980092, + "lat": 40.754367, + "altM": 457 + }, + { + "t": 1789766786000, + "lon": -73.980488, + "lat": 40.754508, + "altM": 457 + }, + { + "t": 1789766787000, + "lon": -73.980756, + "lat": 40.754704, + "altM": 457 + }, + { + "t": 1789766788000, + "lon": -73.981076, + "lat": 40.754719, + "altM": 457 + }, + { + "t": 1789766789000, + "lon": -73.981539, + "lat": 40.754924, + "altM": 457 + }, + { + "t": 1789766790000, + "lon": -73.981821, + "lat": 40.754966, + "altM": 457 + }, + { "t": 1789766791000, "lon": -73.982275, "lat": 40.75505, "altM": 457 }, + { + "t": 1789766792000, + "lon": -73.982559, + "lat": 40.755125, + "altM": 465 + }, + { + "t": 1789766793000, + "lon": -73.982882, + "lat": 40.755184, + "altM": 465 + }, + { + "t": 1789766794000, + "lon": -73.983391, + "lat": 40.755314, + "altM": 465 + }, + { + "t": 1789766795000, + "lon": -73.983689, + "lat": 40.755231, + "altM": 465 + }, + { + "t": 1789766796000, + "lon": -73.984011, + "lat": 40.755289, + "altM": 465 + }, + { "t": 1789766797000, "lon": -73.984439, "lat": 40.75535, "altM": 465 }, + { + "t": 1789766798000, + "lon": -73.984784, + "lat": 40.755274, + "altM": 465 + }, + { "t": 1789766799000, "lon": -73.985238, "lat": 40.75523, "altM": 465 }, + { + "t": 1789766800000, + "lon": -73.985604, + "lat": 40.755197, + "altM": 465 + }, + { + "t": 1789766801000, + "lon": -73.986032, + "lat": 40.755133, + "altM": 465 + }, + { + "t": 1789766802000, + "lon": -73.986395, + "lat": 40.755078, + "altM": 465 + }, + { + "t": 1789766803000, + "lon": -73.986753, + "lat": 40.754995, + "altM": 465 + }, + { + "t": 1789766804000, + "lon": -73.987121, + "lat": 40.754894, + "altM": 465 + }, + { + "t": 1789766805000, + "lon": -73.987416, + "lat": 40.754811, + "altM": 465 + }, + { + "t": 1789766806000, + "lon": -73.987824, + "lat": 40.754658, + "altM": 465 + }, + { + "t": 1789766807000, + "lon": -73.988226, + "lat": 40.754424, + "altM": 465 + }, + { "t": 1789766808000, "lon": -73.98855, "lat": 40.754363, "altM": 465 }, + { + "t": 1789766809000, + "lon": -73.988903, + "lat": 40.754184, + "altM": 465 + }, + { + "t": 1789766810000, + "lon": -73.989178, + "lat": 40.753953, + "altM": 465 + }, + { "t": 1789766811000, "lon": -73.98962, "lat": 40.753791, "altM": 465 }, + { "t": 1789766812000, "lon": -73.989885, "lat": 40.75356, "altM": 465 }, + { + "t": 1789766813000, + "lon": -73.990117, + "lat": 40.753264, + "altM": 465 + }, + { + "t": 1789766814000, + "lon": -73.990429, + "lat": 40.753084, + "altM": 465 + }, + { + "t": 1789766815000, + "lon": -73.990541, + "lat": 40.752789, + "altM": 465 + }, + { + "t": 1789766816000, + "lon": -73.990918, + "lat": 40.752528, + "altM": 465 + }, + { + "t": 1789766817000, + "lon": -73.991151, + "lat": 40.752283, + "altM": 465 + }, + { + "t": 1789766818000, + "lon": -73.991387, + "lat": 40.751958, + "altM": 465 + }, + { + "t": 1789766819000, + "lon": -73.991558, + "lat": 40.751563, + "altM": 465 + }, + { + "t": 1789766820000, + "lon": -73.991665, + "lat": 40.751277, + "altM": 465 + }, + { + "t": 1789766821000, + "lon": -73.991767, + "lat": 40.750933, + "altM": 465 + }, + { "t": 1789766822000, "lon": -73.991804, "lat": 40.75061, "altM": 465 }, + { + "t": 1789766823000, + "lon": -73.992004, + "lat": 40.750282, + "altM": 465 + }, + { + "t": 1789766824000, + "lon": -73.992006, + "lat": 40.749955, + "altM": 465 + }, + { + "t": 1789766825000, + "lon": -73.992015, + "lat": 40.749559, + "altM": 465 + }, + { + "t": 1789766826000, + "lon": -73.992009, + "lat": 40.749186, + "altM": 465 + }, + { + "t": 1789766827000, + "lon": -73.991981, + "lat": 40.748837, + "altM": 465 + }, + { + "t": 1789766828000, + "lon": -73.991947, + "lat": 40.748505, + "altM": 465 + }, + { + "t": 1789766829000, + "lon": -73.991792, + "lat": 40.748012, + "altM": 465 + }, + { + "t": 1789766830000, + "lon": -73.991609, + "lat": 40.747735, + "altM": 465 + }, + { + "t": 1789766831000, + "lon": -73.991416, + "lat": 40.747323, + "altM": 465 + }, + { + "t": 1789766832000, + "lon": -73.991262, + "lat": 40.746926, + "altM": 465 + }, + { + "t": 1789766833000, + "lon": -73.991035, + "lat": 40.746636, + "altM": 465 + }, + { + "t": 1789766834000, + "lon": -73.990737, + "lat": 40.746229, + "altM": 465 + }, + { + "t": 1789766835000, + "lon": -73.990428, + "lat": 40.745948, + "altM": 465 + }, + { "t": 1789766836000, "lon": -73.99007, "lat": 40.745563, "altM": 465 }, + { + "t": 1789766837000, + "lon": -73.989674, + "lat": 40.745318, + "altM": 465 + }, + { + "t": 1789766838000, + "lon": -73.989386, + "lat": 40.745054, + "altM": 465 + }, + { + "t": 1789766839000, + "lon": -73.988963, + "lat": 40.744692, + "altM": 465 + }, + { + "t": 1789766840000, + "lon": -73.988554, + "lat": 40.744552, + "altM": 465 + }, + { + "t": 1789766841000, + "lon": -73.988042, + "lat": 40.744283, + "altM": 465 + }, + { + "t": 1789766842000, + "lon": -73.987435, + "lat": 40.744123, + "altM": 465 + }, + { + "t": 1789766843000, + "lon": -73.987048, + "lat": 40.743992, + "altM": 465 + }, + { "t": 1789766844000, "lon": -73.986413, "lat": 40.74388, "altM": 465 }, + { + "t": 1789766845000, + "lon": -73.985949, + "lat": 40.743772, + "altM": 465 + }, + { + "t": 1789766846000, + "lon": -73.985386, + "lat": 40.743713, + "altM": 465 + }, + { + "t": 1789766847000, + "lon": -73.984766, + "lat": 40.743666, + "altM": 465 + }, + { + "t": 1789766848000, + "lon": -73.984355, + "lat": 40.743665, + "altM": 465 + }, + { + "t": 1789766849000, + "lon": -73.983743, + "lat": 40.743715, + "altM": 465 + }, + { + "t": 1789766850000, + "lon": -73.983232, + "lat": 40.743689, + "altM": 465 + }, + { + "t": 1789766851000, + "lon": -73.982639, + "lat": 40.743825, + "altM": 465 + }, + { + "t": 1789766852000, + "lon": -73.982218, + "lat": 40.743928, + "altM": 465 + }, + { + "t": 1789766853000, + "lon": -73.981678, + "lat": 40.744061, + "altM": 465 + }, + { + "t": 1789766854000, + "lon": -73.981236, + "lat": 40.744243, + "altM": 465 + }, + { + "t": 1789766855000, + "lon": -73.980768, + "lat": 40.744401, + "altM": 465 + }, + { + "t": 1789766856000, + "lon": -73.980342, + "lat": 40.744578, + "altM": 465 + }, + { + "t": 1789766857000, + "lon": -73.979921, + "lat": 40.744882, + "altM": 465 + }, + { + "t": 1789766858000, + "lon": -73.979541, + "lat": 40.745137, + "altM": 465 + }, + { + "t": 1789766859000, + "lon": -73.979243, + "lat": 40.745344, + "altM": 465 + }, + { + "t": 1789766860000, + "lon": -73.978862, + "lat": 40.745591, + "altM": 465 + }, + { + "t": 1789766861000, + "lon": -73.978582, + "lat": 40.745901, + "altM": 465 + }, + { + "t": 1789766862000, + "lon": -73.978306, + "lat": 40.746264, + "altM": 465 + }, + { + "t": 1789766863000, + "lon": -73.978014, + "lat": 40.746536, + "altM": 465 + }, + { + "t": 1789766864000, + "lon": -73.977871, + "lat": 40.746808, + "altM": 465 + }, + { "t": 1789766865000, "lon": -73.97761, "lat": 40.747169, "altM": 465 }, + { + "t": 1789766866000, + "lon": -73.977484, + "lat": 40.747501, + "altM": 465 + }, + { + "t": 1789766867000, + "lon": -73.977451, + "lat": 40.747775, + "altM": 465 + }, + { + "t": 1789766868000, + "lon": -73.977266, + "lat": 40.748153, + "altM": 465 + }, + { "t": 1789766869000, "lon": -73.977198, "lat": 40.74845, "altM": 465 }, + { + "t": 1789766870000, + "lon": -73.977173, + "lat": 40.748845, + "altM": 457 + }, + { + "t": 1789766871000, + "lon": -73.977162, + "lat": 40.749087, + "altM": 457 + }, + { + "t": 1789766872000, + "lon": -73.977087, + "lat": 40.749441, + "altM": 457 + }, + { + "t": 1789766873000, + "lon": -73.977202, + "lat": 40.749861, + "altM": 457 + }, + { + "t": 1789766874000, + "lon": -73.977224, + "lat": 40.750135, + "altM": 457 + }, + { + "t": 1789766875000, + "lon": -73.977225, + "lat": 40.750418, + "altM": 457 + }, + { + "t": 1789766876000, + "lon": -73.977388, + "lat": 40.750756, + "altM": 457 + }, + { + "t": 1789766877000, + "lon": -73.977539, + "lat": 40.750987, + "altM": 457 + }, + { "t": 1789766878000, "lon": -73.97769, "lat": 40.751285, "altM": 457 }, + { + "t": 1789766879000, + "lon": -73.977798, + "lat": 40.751583, + "altM": 457 + }, + { "t": 1789766880000, "lon": -73.977985, "lat": 40.75187, "altM": 457 }, + { + "t": 1789766881000, + "lon": -73.978147, + "lat": 40.752121, + "altM": 457 + }, + { + "t": 1789766882000, + "lon": -73.978418, + "lat": 40.752442, + "altM": 457 + }, + { + "t": 1789766883000, + "lon": -73.978633, + "lat": 40.752559, + "altM": 457 + }, + { "t": 1789766884000, "lon": -73.97887, "lat": 40.752928, "altM": 457 }, + { + "t": 1789766885000, + "lon": -73.979021, + "lat": 40.753103, + "altM": 457 + }, + { + "t": 1789766886000, + "lon": -73.979299, + "lat": 40.753225, + "altM": 457 + }, + { + "t": 1789766887000, + "lon": -73.979612, + "lat": 40.753512, + "altM": 457 + }, + { + "t": 1789766888000, + "lon": -73.979882, + "lat": 40.753655, + "altM": 457 + }, + { + "t": 1789766889000, + "lon": -73.980182, + "lat": 40.753897, + "altM": 457 + }, + { + "t": 1789766890000, + "lon": -73.980445, + "lat": 40.754075, + "altM": 457 + }, + { + "t": 1789766891000, + "lon": -73.980925, + "lat": 40.754186, + "altM": 457 + }, + { + "t": 1789766892000, + "lon": -73.981133, + "lat": 40.754427, + "altM": 457 + }, + { + "t": 1789766893000, + "lon": -73.981507, + "lat": 40.754502, + "altM": 457 + }, + { + "t": 1789766894000, + "lon": -73.981786, + "lat": 40.754596, + "altM": 457 + }, + { "t": 1789766895000, "lon": -73.98223, "lat": 40.754633, "altM": 457 }, + { + "t": 1789766896000, + "lon": -73.982583, + "lat": 40.754813, + "altM": 457 + }, + { "t": 1789766897000, "lon": -73.9829, "lat": 40.754865, "altM": 457 }, + { + "t": 1789766898000, + "lon": -73.983236, + "lat": 40.754899, + "altM": 457 + }, + { + "t": 1789766899000, + "lon": -73.983709, + "lat": 40.754944, + "altM": 457 + }, + { + "t": 1789766900000, + "lon": -73.984074, + "lat": 40.755024, + "altM": 457 + }, + { + "t": 1789766901000, + "lon": -73.984519, + "lat": 40.754945, + "altM": 457 + }, + { + "t": 1789766902000, + "lon": -73.984824, + "lat": 40.754993, + "altM": 457 + }, + { + "t": 1789766903000, + "lon": -73.985152, + "lat": 40.754925, + "altM": 450 + }, + { + "t": 1789766904000, + "lon": -73.985542, + "lat": 40.755005, + "altM": 450 + }, + { + "t": 1789766905000, + "lon": -73.985992, + "lat": 40.754914, + "altM": 450 + }, + { + "t": 1789766906000, + "lon": -73.986332, + "lat": 40.754908, + "altM": 450 + }, + { + "t": 1789766907000, + "lon": -73.986709, + "lat": 40.754806, + "altM": 450 + }, + { + "t": 1789766908000, + "lon": -73.987148, + "lat": 40.754696, + "altM": 450 + }, + { + "t": 1789766909000, + "lon": -73.987432, + "lat": 40.754586, + "altM": 450 + }, + { + "t": 1789766910000, + "lon": -73.987872, + "lat": 40.754491, + "altM": 450 + }, + { + "t": 1789766911000, + "lon": -73.988173, + "lat": 40.754356, + "altM": 450 + }, + { + "t": 1789766912000, + "lon": -73.988568, + "lat": 40.754165, + "altM": 450 + }, + { + "t": 1789766913000, + "lon": -73.988881, + "lat": 40.754039, + "altM": 450 + }, + { + "t": 1789766914000, + "lon": -73.989187, + "lat": 40.753904, + "altM": 450 + }, + { + "t": 1789766915000, + "lon": -73.989486, + "lat": 40.753643, + "altM": 450 + }, + { + "t": 1789766916000, + "lon": -73.989871, + "lat": 40.753404, + "altM": 450 + }, + { + "t": 1789766917000, + "lon": -73.990168, + "lat": 40.753164, + "altM": 450 + }, + { + "t": 1789766918000, + "lon": -73.990365, + "lat": 40.752945, + "altM": 450 + }, + { + "t": 1789766919000, + "lon": -73.990666, + "lat": 40.752637, + "altM": 450 + }, + { + "t": 1789766920000, + "lon": -73.991031, + "lat": 40.752471, + "altM": 450 + }, + { + "t": 1789766921000, + "lon": -73.991152, + "lat": 40.752097, + "altM": 450 + }, + { + "t": 1789766922000, + "lon": -73.991392, + "lat": 40.751818, + "altM": 450 + }, + { + "t": 1789766923000, + "lon": -73.991582, + "lat": 40.751536, + "altM": 450 + }, + { + "t": 1789766924000, + "lon": -73.991783, + "lat": 40.751143, + "altM": 450 + }, + { + "t": 1789766925000, + "lon": -73.991918, + "lat": 40.750834, + "altM": 450 + }, + { "t": 1789766926000, "lon": -73.99205, "lat": 40.750493, "altM": 450 }, + { + "t": 1789766927000, + "lon": -73.992129, + "lat": 40.750178, + "altM": 450 + }, + { + "t": 1789766928000, + "lon": -73.992102, + "lat": 40.749809, + "altM": 450 + }, + { + "t": 1789766929000, + "lon": -73.992112, + "lat": 40.749375, + "altM": 450 + }, + { + "t": 1789766930000, + "lon": -73.992148, + "lat": 40.749015, + "altM": 450 + }, + { + "t": 1789766931000, + "lon": -73.992074, + "lat": 40.748679, + "altM": 450 + }, + { + "t": 1789766932000, + "lon": -73.992048, + "lat": 40.748355, + "altM": 450 + }, + { + "t": 1789766933000, + "lon": -73.991944, + "lat": 40.747919, + "altM": 450 + }, + { + "t": 1789766934000, + "lon": -73.991706, + "lat": 40.747585, + "altM": 450 + }, + { "t": 1789766935000, "lon": -73.991623, "lat": 40.74719, "altM": 450 }, + { + "t": 1789766936000, + "lon": -73.991494, + "lat": 40.746806, + "altM": 450 + }, + { + "t": 1789766937000, + "lon": -73.991104, + "lat": 40.746464, + "altM": 450 + }, + { "t": 1789766938000, "lon": -73.990965, "lat": 40.74608, "altM": 450 }, + { "t": 1789766939000, "lon": -73.990624, "lat": 40.74573, "altM": 450 }, + { "t": 1789766940000, "lon": -73.99038, "lat": 40.745435, "altM": 450 }, + { + "t": 1789766941000, + "lon": -73.989956, + "lat": 40.745145, + "altM": 450 + }, + { + "t": 1789766942000, + "lon": -73.989491, + "lat": 40.744921, + "altM": 450 + }, + { + "t": 1789766943000, + "lon": -73.989147, + "lat": 40.744582, + "altM": 450 + }, + { + "t": 1789766944000, + "lon": -73.988778, + "lat": 40.744361, + "altM": 450 + }, + { + "t": 1789766945000, + "lon": -73.988281, + "lat": 40.744055, + "altM": 450 + }, + { + "t": 1789766946000, + "lon": -73.987757, + "lat": 40.743917, + "altM": 450 + }, + { + "t": 1789766947000, + "lon": -73.987297, + "lat": 40.743751, + "altM": 450 + }, + { + "t": 1789766948000, + "lon": -73.986768, + "lat": 40.743628, + "altM": 450 + }, + { + "t": 1789766949000, + "lon": -73.986329, + "lat": 40.743483, + "altM": 450 + }, + { "t": 1789766950000, "lon": -73.98573, "lat": 40.743414, "altM": 450 }, + { + "t": 1789766951000, + "lon": -73.985162, + "lat": 40.743323, + "altM": 450 + }, + { + "t": 1789766952000, + "lon": -73.984584, + "lat": 40.743355, + "altM": 450 + }, + { + "t": 1789766953000, + "lon": -73.984067, + "lat": 40.743283, + "altM": 450 + }, + { + "t": 1789766954000, + "lon": -73.983581, + "lat": 40.743334, + "altM": 450 + }, + { + "t": 1789766955000, + "lon": -73.983028, + "lat": 40.743301, + "altM": 450 + }, + { "t": 1789766956000, "lon": -73.98256, "lat": 40.743424, "altM": 450 }, + { "t": 1789766957000, "lon": -73.981908, "lat": 40.74348, "altM": 450 }, + { + "t": 1789766958000, + "lon": -73.981434, + "lat": 40.743675, + "altM": 450 + }, + { + "t": 1789766959000, + "lon": -73.980941, + "lat": 40.743868, + "altM": 450 + }, + { + "t": 1789766960000, + "lon": -73.980485, + "lat": 40.744023, + "altM": 450 + }, + { "t": 1789766961000, "lon": -73.97992, "lat": 40.744155, "altM": 450 }, + { + "t": 1789766962000, + "lon": -73.979642, + "lat": 40.744428, + "altM": 450 + }, + { + "t": 1789766963000, + "lon": -73.979316, + "lat": 40.744663, + "altM": 450 + }, + { + "t": 1789766964000, + "lon": -73.978972, + "lat": 40.744898, + "altM": 450 + }, + { "t": 1789766965000, "lon": -73.978577, "lat": 40.74513, "altM": 450 }, + { + "t": 1789766966000, + "lon": -73.978231, + "lat": 40.745461, + "altM": 450 + }, + { + "t": 1789766967000, + "lon": -73.977879, + "lat": 40.745694, + "altM": 450 + }, + { + "t": 1789766968000, + "lon": -73.977578, + "lat": 40.746016, + "altM": 450 + }, + { + "t": 1789766969000, + "lon": -73.977501, + "lat": 40.746381, + "altM": 450 + }, + { "t": 1789766970000, "lon": -73.977151, "lat": 40.74668, "altM": 450 }, + { "t": 1789766971000, "lon": -73.97701, "lat": 40.746972, "altM": 450 }, + { + "t": 1789766972000, + "lon": -73.976803, + "lat": 40.747335, + "altM": 450 + }, + { + "t": 1789766973000, + "lon": -73.976729, + "lat": 40.747702, + "altM": 450 + }, + { "t": 1789766974000, "lon": -73.976598, "lat": 40.74796, "altM": 450 }, + { "t": 1789766975000, "lon": -73.976421, "lat": 40.74826, "altM": 450 }, + { + "t": 1789766976000, + "lon": -73.976457, + "lat": 40.748572, + "altM": 450 + }, + { + "t": 1789766977000, + "lon": -73.976449, + "lat": 40.748952, + "altM": 450 + }, + { + "t": 1789766978000, + "lon": -73.976372, + "lat": 40.749357, + "altM": 450 + }, + { + "t": 1789766979000, + "lon": -73.976404, + "lat": 40.749616, + "altM": 450 + }, + { "t": 1789766980000, "lon": -73.97639, "lat": 40.749962, "altM": 450 }, + { "t": 1789766981000, "lon": -73.97647, "lat": 40.75013, "altM": 450 }, + { + "t": 1789766982000, + "lon": -73.976504, + "lat": 40.750532, + "altM": 450 + }, + { "t": 1789766983000, "lon": -73.97652, "lat": 40.750879, "altM": 450 }, + { + "t": 1789766984000, + "lon": -73.976637, + "lat": 40.751151, + "altM": 450 + }, + { + "t": 1789766985000, + "lon": -73.976803, + "lat": 40.751439, + "altM": 450 + }, + { + "t": 1789766986000, + "lon": -73.976997, + "lat": 40.751736, + "altM": 450 + }, + { "t": 1789766987000, "lon": -73.97716, "lat": 40.752049, "altM": 450 }, + { + "t": 1789766988000, + "lon": -73.977365, + "lat": 40.752257, + "altM": 450 + }, + { + "t": 1789766989000, + "lon": -73.977488, + "lat": 40.752527, + "altM": 450 + }, + { + "t": 1789766990000, + "lon": -73.977703, + "lat": 40.752844, + "altM": 457 + }, + { "t": 1789766991000, "lon": -73.978013, "lat": 40.753, "altM": 457 }, + { "t": 1789766992000, "lon": -73.978244, "lat": 40.75329, "altM": 457 }, + { + "t": 1789766993000, + "lon": -73.978365, + "lat": 40.753562, + "altM": 457 + }, + { "t": 1789766994000, "lon": -73.97854, "lat": 40.753792, "altM": 457 }, + { "t": 1789766995000, "lon": -73.97885, "lat": 40.753919, "altM": 457 }, + { + "t": 1789766996000, + "lon": -73.979195, + "lat": 40.754138, + "altM": 457 + }, + { + "t": 1789766997000, + "lon": -73.979551, + "lat": 40.754345, + "altM": 457 + }, + { + "t": 1789766998000, + "lon": -73.979876, + "lat": 40.754516, + "altM": 457 + }, + { + "t": 1789766999000, + "lon": -73.980134, + "lat": 40.754676, + "altM": 457 + }, + { + "t": 1789767000000, + "lon": -73.980474, + "lat": 40.754794, + "altM": 457 + }, + { + "t": 1789767001000, + "lon": -73.980843, + "lat": 40.754948, + "altM": 457 + }, + { + "t": 1789767002000, + "lon": -73.981195, + "lat": 40.755059, + "altM": 457 + }, + { "t": 1789767003000, "lon": -73.98153, "lat": 40.755151, "altM": 457 }, + { + "t": 1789767004000, + "lon": -73.981973, + "lat": 40.755304, + "altM": 457 + }, + { + "t": 1789767005000, + "lon": -73.982267, + "lat": 40.755358, + "altM": 457 + }, + { + "t": 1789767006000, + "lon": -73.982611, + "lat": 40.755468, + "altM": 457 + }, + { + "t": 1789767007000, + "lon": -73.982952, + "lat": 40.755564, + "altM": 457 + }, + { + "t": 1789767008000, + "lon": -73.983411, + "lat": 40.755593, + "altM": 457 + }, + { + "t": 1789767009000, + "lon": -73.983734, + "lat": 40.755588, + "altM": 457 + }, + { "t": 1789767010000, "lon": -73.984099, "lat": 40.75567, "altM": 457 }, + { + "t": 1789767011000, + "lon": -73.984503, + "lat": 40.755625, + "altM": 457 + }, + { + "t": 1789767012000, + "lon": -73.984924, + "lat": 40.755599, + "altM": 457 + }, + { + "t": 1789767013000, + "lon": -73.985256, + "lat": 40.755578, + "altM": 457 + }, + { + "t": 1789767014000, + "lon": -73.985607, + "lat": 40.755609, + "altM": 457 + }, + { "t": 1789767015000, "lon": -73.98607, "lat": 40.75549, "altM": 457 }, + { "t": 1789767016000, "lon": -73.986353, "lat": 40.75554, "altM": 457 }, + { + "t": 1789767017000, + "lon": -73.986769, + "lat": 40.755407, + "altM": 457 + }, + { + "t": 1789767018000, + "lon": -73.987127, + "lat": 40.755299, + "altM": 457 + }, + { + "t": 1789767019000, + "lon": -73.987494, + "lat": 40.755234, + "altM": 457 + }, + { + "t": 1789767020000, + "lon": -73.988009, + "lat": 40.755084, + "altM": 457 + }, + { + "t": 1789767021000, + "lon": -73.988225, + "lat": 40.754897, + "altM": 457 + }, + { + "t": 1789767022000, + "lon": -73.988618, + "lat": 40.754816, + "altM": 457 + }, + { + "t": 1789767023000, + "lon": -73.988929, + "lat": 40.754612, + "altM": 457 + }, + { + "t": 1789767024000, + "lon": -73.989226, + "lat": 40.754481, + "altM": 457 + }, + { + "t": 1789767025000, + "lon": -73.989679, + "lat": 40.754338, + "altM": 457 + }, + { "t": 1789767026000, "lon": -73.990002, "lat": 40.75408, "altM": 457 }, + { + "t": 1789767027000, + "lon": -73.990219, + "lat": 40.753882, + "altM": 465 + }, + { "t": 1789767028000, "lon": -73.9905, "lat": 40.753655, "altM": 465 }, + { + "t": 1789767029000, + "lon": -73.990764, + "lat": 40.753421, + "altM": 465 + }, + { + "t": 1789767030000, + "lon": -73.991108, + "lat": 40.753132, + "altM": 465 + }, + { + "t": 1789767031000, + "lon": -73.991298, + "lat": 40.752884, + "altM": 465 + }, + { + "t": 1789767032000, + "lon": -73.991576, + "lat": 40.752599, + "altM": 465 + }, + { + "t": 1789767033000, + "lon": -73.991784, + "lat": 40.752272, + "altM": 465 + }, + { + "t": 1789767034000, + "lon": -73.991917, + "lat": 40.752005, + "altM": 465 + }, + { + "t": 1789767035000, + "lon": -73.992158, + "lat": 40.751647, + "altM": 465 + }, + { + "t": 1789767036000, + "lon": -73.992293, + "lat": 40.751408, + "altM": 465 + }, + { + "t": 1789767037000, + "lon": -73.992442, + "lat": 40.751017, + "altM": 465 + }, + { + "t": 1789767038000, + "lon": -73.992564, + "lat": 40.750687, + "altM": 465 + }, + { + "t": 1789767039000, + "lon": -73.992556, + "lat": 40.750279, + "altM": 465 + }, + { + "t": 1789767040000, + "lon": -73.992701, + "lat": 40.749973, + "altM": 465 + }, + { + "t": 1789767041000, + "lon": -73.992852, + "lat": 40.749612, + "altM": 465 + }, + { + "t": 1789767042000, + "lon": -73.992701, + "lat": 40.749209, + "altM": 465 + }, + { + "t": 1789767043000, + "lon": -73.992727, + "lat": 40.748847, + "altM": 465 + }, + { "t": 1789767044000, "lon": -73.9926, "lat": 40.748506, "altM": 465 }, + { + "t": 1789767045000, + "lon": -73.992578, + "lat": 40.748113, + "altM": 465 + }, + { + "t": 1789767046000, + "lon": -73.992397, + "lat": 40.747748, + "altM": 465 + }, + { + "t": 1789767047000, + "lon": -73.992185, + "lat": 40.747326, + "altM": 465 + }, + { + "t": 1789767048000, + "lon": -73.991956, + "lat": 40.746956, + "altM": 465 + }, + { "t": 1789767049000, "lon": -73.991975, "lat": 40.74657, "altM": 465 }, + { + "t": 1789767050000, + "lon": -73.991593, + "lat": 40.746309, + "altM": 465 + }, + { + "t": 1789767051000, + "lon": -73.991325, + "lat": 40.745964, + "altM": 465 + }, + { + "t": 1789767052000, + "lon": -73.991023, + "lat": 40.745662, + "altM": 465 + }, + { + "t": 1789767053000, + "lon": -73.990661, + "lat": 40.745238, + "altM": 465 + }, + { + "t": 1789767054000, + "lon": -73.990347, + "lat": 40.744988, + "altM": 465 + }, + { + "t": 1789767055000, + "lon": -73.989877, + "lat": 40.744707, + "altM": 465 + }, + { + "t": 1789767056000, + "lon": -73.989413, + "lat": 40.744407, + "altM": 465 + }, + { + "t": 1789767057000, + "lon": -73.989068, + "lat": 40.744196, + "altM": 465 + }, + { + "t": 1789767058000, + "lon": -73.988525, + "lat": 40.743997, + "altM": 465 + }, + { "t": 1789767059000, "lon": -73.98814, "lat": 40.743797, "altM": 465 }, + { + "t": 1789767060000, + "lon": -73.987688, + "lat": 40.743573, + "altM": 465 + }, + { + "t": 1789767061000, + "lon": -73.987052, + "lat": 40.743484, + "altM": 465 + }, + { + "t": 1789767062000, + "lon": -73.986581, + "lat": 40.743351, + "altM": 465 + }, + { + "t": 1789767063000, + "lon": -73.986059, + "lat": 40.743252, + "altM": 465 + }, + { + "t": 1789767064000, + "lon": -73.985554, + "lat": 40.743126, + "altM": 465 + }, + { + "t": 1789767065000, + "lon": -73.984994, + "lat": 40.743141, + "altM": 465 + }, + { "t": 1789767066000, "lon": -73.98442, "lat": 40.743138, "altM": 465 }, + { + "t": 1789767067000, + "lon": -73.983864, + "lat": 40.743166, + "altM": 465 + }, + { "t": 1789767068000, "lon": -73.98338, "lat": 40.743196, "altM": 465 }, + { + "t": 1789767069000, + "lon": -73.982836, + "lat": 40.743292, + "altM": 465 + }, + { + "t": 1789767070000, + "lon": -73.982324, + "lat": 40.743344, + "altM": 465 + }, + { + "t": 1789767071000, + "lon": -73.981783, + "lat": 40.743504, + "altM": 465 + }, + { + "t": 1789767072000, + "lon": -73.981303, + "lat": 40.743611, + "altM": 465 + }, + { + "t": 1789767073000, + "lon": -73.980851, + "lat": 40.743833, + "altM": 465 + }, + { + "t": 1789767074000, + "lon": -73.980456, + "lat": 40.744029, + "altM": 465 + }, + { + "t": 1789767075000, + "lon": -73.979996, + "lat": 40.744201, + "altM": 465 + }, + { + "t": 1789767076000, + "lon": -73.979563, + "lat": 40.744473, + "altM": 465 + }, + { + "t": 1789767077000, + "lon": -73.979177, + "lat": 40.744721, + "altM": 465 + }, + { + "t": 1789767078000, + "lon": -73.978851, + "lat": 40.744948, + "altM": 465 + }, + { + "t": 1789767079000, + "lon": -73.978376, + "lat": 40.745247, + "altM": 465 + }, + { + "t": 1789767080000, + "lon": -73.978174, + "lat": 40.745539, + "altM": 465 + }, + { + "t": 1789767081000, + "lon": -73.977875, + "lat": 40.745806, + "altM": 465 + }, + { + "t": 1789767082000, + "lon": -73.977655, + "lat": 40.746138, + "altM": 465 + }, + { "t": 1789767083000, "lon": -73.97734, "lat": 40.746462, "altM": 465 }, + { + "t": 1789767084000, + "lon": -73.977278, + "lat": 40.746778, + "altM": 465 + }, + { + "t": 1789767085000, + "lon": -73.977039, + "lat": 40.747136, + "altM": 465 + }, + { + "t": 1789767086000, + "lon": -73.976889, + "lat": 40.747471, + "altM": 465 + }, + { + "t": 1789767087000, + "lon": -73.976865, + "lat": 40.747796, + "altM": 465 + }, + { "t": 1789767088000, "lon": -73.97681, "lat": 40.748045, "altM": 465 }, + { + "t": 1789767089000, + "lon": -73.976687, + "lat": 40.748412, + "altM": 465 + }, + { + "t": 1789767090000, + "lon": -73.976596, + "lat": 40.748734, + "altM": 465 + }, + { + "t": 1789767091000, + "lon": -73.976611, + "lat": 40.749088, + "altM": 465 + }, + { + "t": 1789767092000, + "lon": -73.976605, + "lat": 40.749419, + "altM": 465 + }, + { + "t": 1789767093000, + "lon": -73.976677, + "lat": 40.749702, + "altM": 465 + }, + { + "t": 1789767094000, + "lon": -73.976726, + "lat": 40.750029, + "altM": 465 + }, + { + "t": 1789767095000, + "lon": -73.976879, + "lat": 40.750341, + "altM": 465 + }, + { "t": 1789767096000, "lon": -73.97692, "lat": 40.750676, "altM": 465 }, + { + "t": 1789767097000, + "lon": -73.977038, + "lat": 40.750976, + "altM": 465 + }, + { + "t": 1789767098000, + "lon": -73.977143, + "lat": 40.751256, + "altM": 465 + }, + { + "t": 1789767099000, + "lon": -73.977284, + "lat": 40.751577, + "altM": 465 + }, + { + "t": 1789767100000, + "lon": -73.977478, + "lat": 40.751827, + "altM": 465 + }, + { "t": 1789767101000, "lon": -73.97763, "lat": 40.752082, "altM": 457 }, + { + "t": 1789767102000, + "lon": -73.977803, + "lat": 40.752321, + "altM": 457 + }, + { + "t": 1789767103000, + "lon": -73.978038, + "lat": 40.752625, + "altM": 457 + }, + { + "t": 1789767104000, + "lon": -73.978444, + "lat": 40.752802, + "altM": 457 + }, + { + "t": 1789767105000, + "lon": -73.978596, + "lat": 40.753032, + "altM": 457 + }, + { + "t": 1789767106000, + "lon": -73.978796, + "lat": 40.753253, + "altM": 457 + }, + { + "t": 1789767107000, + "lon": -73.979157, + "lat": 40.753427, + "altM": 457 + }, + { + "t": 1789767108000, + "lon": -73.979397, + "lat": 40.753613, + "altM": 457 + }, + { + "t": 1789767109000, + "lon": -73.979658, + "lat": 40.753819, + "altM": 457 + }, + { "t": 1789767110000, "lon": -73.97995, "lat": 40.753964, "altM": 457 }, + { + "t": 1789767111000, + "lon": -73.980259, + "lat": 40.754131, + "altM": 457 + }, + { + "t": 1789767112000, + "lon": -73.980688, + "lat": 40.754277, + "altM": 457 + }, + { "t": 1789767113000, "lon": -73.980966, "lat": 40.75446, "altM": 457 }, + { + "t": 1789767114000, + "lon": -73.981395, + "lat": 40.754601, + "altM": 457 + }, + { "t": 1789767115000, "lon": -73.98167, "lat": 40.754669, "altM": 457 }, + { + "t": 1789767116000, + "lon": -73.982041, + "lat": 40.754816, + "altM": 457 + }, + { + "t": 1789767117000, + "lon": -73.982364, + "lat": 40.754854, + "altM": 457 + }, + { + "t": 1789767118000, + "lon": -73.982834, + "lat": 40.754944, + "altM": 457 + }, + { + "t": 1789767119000, + "lon": -73.983044, + "lat": 40.754979, + "altM": 457 + }, + { + "t": 1789767120000, + "lon": -73.983463, + "lat": 40.754999, + "altM": 457 + }, + { + "t": 1789767121000, + "lon": -73.983884, + "lat": 40.755153, + "altM": 457 + }, + { + "t": 1789767122000, + "lon": -73.984202, + "lat": 40.755108, + "altM": 457 + }, + { + "t": 1789767123000, + "lon": -73.984683, + "lat": 40.755087, + "altM": 457 + }, + { "t": 1789767124000, "lon": -73.985016, "lat": 40.75507, "altM": 457 }, + { + "t": 1789767125000, + "lon": -73.985399, + "lat": 40.755036, + "altM": 457 + }, + { "t": 1789767126000, "lon": -73.98573, "lat": 40.754957, "altM": 457 }, + { + "t": 1789767127000, + "lon": -73.986116, + "lat": 40.754934, + "altM": 457 + }, + { + "t": 1789767128000, + "lon": -73.986543, + "lat": 40.754876, + "altM": 457 + }, + { + "t": 1789767129000, + "lon": -73.986886, + "lat": 40.754769, + "altM": 457 + }, + { + "t": 1789767130000, + "lon": -73.987258, + "lat": 40.754646, + "altM": 457 + }, + { + "t": 1789767131000, + "lon": -73.987633, + "lat": 40.754542, + "altM": 457 + }, + { + "t": 1789767132000, + "lon": -73.987966, + "lat": 40.754376, + "altM": 457 + }, + { "t": 1789767133000, "lon": -73.98834, "lat": 40.754251, "altM": 457 }, + { + "t": 1789767134000, + "lon": -73.988583, + "lat": 40.754029, + "altM": 457 + }, + { + "t": 1789767135000, + "lon": -73.988974, + "lat": 40.753866, + "altM": 457 + }, + { "t": 1789767136000, "lon": -73.98942, "lat": 40.753704, "altM": 457 }, + { + "t": 1789767137000, + "lon": -73.989615, + "lat": 40.753472, + "altM": 457 + }, + { + "t": 1789767138000, + "lon": -73.989856, + "lat": 40.753219, + "altM": 450 + }, + { "t": 1789767139000, "lon": -73.99026, "lat": 40.753046, "altM": 450 }, + { + "t": 1789767140000, + "lon": -73.990422, + "lat": 40.752726, + "altM": 450 + }, + { + "t": 1789767141000, + "lon": -73.990687, + "lat": 40.752388, + "altM": 450 + }, + { "t": 1789767142000, "lon": -73.991006, "lat": 40.75215, "altM": 450 }, + { + "t": 1789767143000, + "lon": -73.991154, + "lat": 40.751853, + "altM": 450 + }, + { + "t": 1789767144000, + "lon": -73.991422, + "lat": 40.751544, + "altM": 450 + }, + { + "t": 1789767145000, + "lon": -73.991484, + "lat": 40.751225, + "altM": 450 + }, + { + "t": 1789767146000, + "lon": -73.991553, + "lat": 40.750914, + "altM": 450 + }, + { + "t": 1789767147000, + "lon": -73.991792, + "lat": 40.750545, + "altM": 450 + }, + { "t": 1789767148000, "lon": -73.991828, "lat": 40.75016, "altM": 450 }, + { + "t": 1789767149000, + "lon": -73.991879, + "lat": 40.749762, + "altM": 450 + }, + { + "t": 1789767150000, + "lon": -73.991804, + "lat": 40.749466, + "altM": 450 + }, + { + "t": 1789767151000, + "lon": -73.991755, + "lat": 40.749116, + "altM": 450 + }, + { + "t": 1789767152000, + "lon": -73.991745, + "lat": 40.748678, + "altM": 450 + }, + { "t": 1789767153000, "lon": -73.99165, "lat": 40.748283, "altM": 450 }, + { "t": 1789767154000, "lon": -73.99154, "lat": 40.747958, "altM": 450 }, + { + "t": 1789767155000, + "lon": -73.991478, + "lat": 40.747573, + "altM": 450 + }, + { + "t": 1789767156000, + "lon": -73.991286, + "lat": 40.747199, + "altM": 450 + }, + { + "t": 1789767157000, + "lon": -73.991089, + "lat": 40.746828, + "altM": 450 + }, + { + "t": 1789767158000, + "lon": -73.990823, + "lat": 40.746452, + "altM": 450 + }, + { + "t": 1789767159000, + "lon": -73.990563, + "lat": 40.746161, + "altM": 450 + }, + { "t": 1789767160000, "lon": -73.99018, "lat": 40.745787, "altM": 450 }, + { + "t": 1789767161000, + "lon": -73.989835, + "lat": 40.745556, + "altM": 450 + }, + { + "t": 1789767162000, + "lon": -73.989432, + "lat": 40.745219, + "altM": 450 + }, + { "t": 1789767163000, "lon": -73.98905, "lat": 40.744986, "altM": 450 }, + { "t": 1789767164000, "lon": -73.988539, "lat": 40.74466, "altM": 450 }, + { + "t": 1789767165000, + "lon": -73.988049, + "lat": 40.744474, + "altM": 450 + }, + { + "t": 1789767166000, + "lon": -73.987699, + "lat": 40.744306, + "altM": 450 + }, + { + "t": 1789767167000, + "lon": -73.987177, + "lat": 40.744115, + "altM": 450 + }, + { + "t": 1789767168000, + "lon": -73.986704, + "lat": 40.743956, + "altM": 450 + }, + { + "t": 1789767169000, + "lon": -73.986082, + "lat": 40.743858, + "altM": 450 + }, + { + "t": 1789767170000, + "lon": -73.985639, + "lat": 40.743789, + "altM": 450 + }, + { + "t": 1789767171000, + "lon": -73.985033, + "lat": 40.743756, + "altM": 450 + }, + { + "t": 1789767172000, + "lon": -73.984488, + "lat": 40.743753, + "altM": 450 + }, + { + "t": 1789767173000, + "lon": -73.983912, + "lat": 40.743692, + "altM": 450 + }, + { + "t": 1789767174000, + "lon": -73.983475, + "lat": 40.743812, + "altM": 450 + }, + { + "t": 1789767175000, + "lon": -73.982877, + "lat": 40.743813, + "altM": 450 + }, + { + "t": 1789767176000, + "lon": -73.982319, + "lat": 40.743941, + "altM": 450 + }, + { + "t": 1789767177000, + "lon": -73.981954, + "lat": 40.744071, + "altM": 450 + }, + { "t": 1789767178000, "lon": -73.98143, "lat": 40.744219, "altM": 450 }, + { + "t": 1789767179000, + "lon": -73.980965, + "lat": 40.744298, + "altM": 450 + }, + { + "t": 1789767180000, + "lon": -73.980461, + "lat": 40.744567, + "altM": 450 + }, + { + "t": 1789767181000, + "lon": -73.980024, + "lat": 40.744753, + "altM": 450 + }, + { + "t": 1789767182000, + "lon": -73.979641, + "lat": 40.745023, + "altM": 450 + }, + { + "t": 1789767183000, + "lon": -73.979242, + "lat": 40.745212, + "altM": 450 + }, + { + "t": 1789767184000, + "lon": -73.978992, + "lat": 40.745474, + "altM": 450 + }, + { + "t": 1789767185000, + "lon": -73.978697, + "lat": 40.745782, + "altM": 450 + }, + { "t": 1789767186000, "lon": -73.978402, "lat": 40.74611, "altM": 450 }, + { + "t": 1789767187000, + "lon": -73.978056, + "lat": 40.746391, + "altM": 450 + }, + { "t": 1789767188000, "lon": -73.97788, "lat": 40.74681, "altM": 450 }, + { + "t": 1789767189000, + "lon": -73.977743, + "lat": 40.747097, + "altM": 450 + }, + { "t": 1789767190000, "lon": -73.977422, "lat": 40.74735, "altM": 450 }, + { + "t": 1789767191000, + "lon": -73.977389, + "lat": 40.747725, + "altM": 450 + }, + { + "t": 1789767192000, + "lon": -73.977189, + "lat": 40.748057, + "altM": 450 + }, + { + "t": 1789767193000, + "lon": -73.977159, + "lat": 40.748346, + "altM": 450 + }, + { + "t": 1789767194000, + "lon": -73.977154, + "lat": 40.748699, + "altM": 450 + }, + { + "t": 1789767195000, + "lon": -73.977044, + "lat": 40.749006, + "altM": 450 + }, + { + "t": 1789767196000, + "lon": -73.977028, + "lat": 40.749322, + "altM": 450 + }, + { + "t": 1789767197000, + "lon": -73.976966, + "lat": 40.749702, + "altM": 450 + }, + { + "t": 1789767198000, + "lon": -73.977145, + "lat": 40.750057, + "altM": 450 + }, + { + "t": 1789767199000, + "lon": -73.977051, + "lat": 40.750302, + "altM": 450 + }, + { + "t": 1789767200000, + "lon": -73.977225, + "lat": 40.750584, + "altM": 450 + }, + { + "t": 1789767201000, + "lon": -73.977304, + "lat": 40.750855, + "altM": 450 + }, + { + "t": 1789767202000, + "lon": -73.977397, + "lat": 40.751185, + "altM": 450 + }, + { + "t": 1789767203000, + "lon": -73.977621, + "lat": 40.751466, + "altM": 450 + }, + { + "t": 1789767204000, + "lon": -73.977693, + "lat": 40.751766, + "altM": 450 + }, + { + "t": 1789767205000, + "lon": -73.978034, + "lat": 40.752085, + "altM": 450 + }, + { + "t": 1789767206000, + "lon": -73.978096, + "lat": 40.752234, + "altM": 450 + }, + { + "t": 1789767207000, + "lon": -73.978277, + "lat": 40.752495, + "altM": 450 + }, + { "t": 1789767208000, "lon": -73.97863, "lat": 40.752864, "altM": 450 }, + { + "t": 1789767209000, + "lon": -73.978747, + "lat": 40.753067, + "altM": 450 + }, + { + "t": 1789767210000, + "lon": -73.979082, + "lat": 40.753243, + "altM": 450 + }, + { + "t": 1789767211000, + "lon": -73.979264, + "lat": 40.753464, + "altM": 450 + }, + { + "t": 1789767212000, + "lon": -73.979642, + "lat": 40.753723, + "altM": 450 + }, + { + "t": 1789767213000, + "lon": -73.979846, + "lat": 40.753849, + "altM": 450 + }, + { + "t": 1789767214000, + "lon": -73.980213, + "lat": 40.754018, + "altM": 450 + }, + { + "t": 1789767215000, + "lon": -73.980521, + "lat": 40.754196, + "altM": 450 + }, + { + "t": 1789767216000, + "lon": -73.980803, + "lat": 40.754379, + "altM": 450 + }, + { + "t": 1789767217000, + "lon": -73.981166, + "lat": 40.754499, + "altM": 450 + }, + { "t": 1789767218000, "lon": -73.981437, "lat": 40.75464, "altM": 450 }, + { + "t": 1789767219000, + "lon": -73.981831, + "lat": 40.754782, + "altM": 450 + }, + { + "t": 1789767220000, + "lon": -73.982107, + "lat": 40.754871, + "altM": 450 + }, + { "t": 1789767221000, "lon": -73.982596, "lat": 40.75496, "altM": 450 }, + { "t": 1789767222000, "lon": -73.98295, "lat": 40.755059, "altM": 450 }, + { + "t": 1789767223000, + "lon": -73.983292, + "lat": 40.755043, + "altM": 457 + }, + { + "t": 1789767224000, + "lon": -73.983724, + "lat": 40.755146, + "altM": 457 + }, + { + "t": 1789767225000, + "lon": -73.984005, + "lat": 40.755193, + "altM": 457 + }, + { + "t": 1789767226000, + "lon": -73.984401, + "lat": 40.755145, + "altM": 457 + }, + { "t": 1789767227000, "lon": -73.984899, "lat": 40.75517, "altM": 457 }, + { + "t": 1789767228000, + "lon": -73.985154, + "lat": 40.755208, + "altM": 457 + }, + { + "t": 1789767229000, + "lon": -73.985508, + "lat": 40.755192, + "altM": 457 + }, + { "t": 1789767230000, "lon": -73.98595, "lat": 40.755137, "altM": 457 }, + { + "t": 1789767231000, + "lon": -73.986333, + "lat": 40.755056, + "altM": 457 + }, + { "t": 1789767232000, "lon": -73.98673, "lat": 40.75498, "altM": 457 }, + { + "t": 1789767233000, + "lon": -73.987147, + "lat": 40.754853, + "altM": 457 + }, + { + "t": 1789767234000, + "lon": -73.987477, + "lat": 40.754815, + "altM": 457 + }, + { + "t": 1789767235000, + "lon": -73.987807, + "lat": 40.754678, + "altM": 457 + }, + { + "t": 1789767236000, + "lon": -73.988162, + "lat": 40.754585, + "altM": 457 + }, + { "t": 1789767237000, "lon": -73.988576, "lat": 40.75442, "altM": 457 }, + { + "t": 1789767238000, + "lon": -73.988871, + "lat": 40.754208, + "altM": 457 + }, + { + "t": 1789767239000, + "lon": -73.989314, + "lat": 40.754049, + "altM": 457 + }, + { + "t": 1789767240000, + "lon": -73.989511, + "lat": 40.753897, + "altM": 457 + }, + { + "t": 1789767241000, + "lon": -73.989931, + "lat": 40.753702, + "altM": 457 + }, + { + "t": 1789767242000, + "lon": -73.990194, + "lat": 40.753371, + "altM": 457 + }, + { + "t": 1789767243000, + "lon": -73.990468, + "lat": 40.753197, + "altM": 457 + }, + { + "t": 1789767244000, + "lon": -73.990708, + "lat": 40.752961, + "altM": 457 + }, + { + "t": 1789767245000, + "lon": -73.991001, + "lat": 40.752776, + "altM": 457 + }, + { "t": 1789767246000, "lon": -73.991333, "lat": 40.75235, "altM": 457 }, + { + "t": 1789767247000, + "lon": -73.991483, + "lat": 40.752139, + "altM": 457 + }, + { "t": 1789767248000, "lon": -73.99167, "lat": 40.751847, "altM": 457 }, + { + "t": 1789767249000, + "lon": -73.991849, + "lat": 40.751554, + "altM": 457 + }, + { + "t": 1789767250000, + "lon": -73.991963, + "lat": 40.751153, + "altM": 457 + }, + { + "t": 1789767251000, + "lon": -73.992146, + "lat": 40.750901, + "altM": 457 + }, + { + "t": 1789767252000, + "lon": -73.992286, + "lat": 40.750555, + "altM": 457 + }, + { + "t": 1789767253000, + "lon": -73.992295, + "lat": 40.750154, + "altM": 457 + }, + { + "t": 1789767254000, + "lon": -73.992382, + "lat": 40.749814, + "altM": 457 + }, + { "t": 1789767255000, "lon": -73.992351, "lat": 40.74948, "altM": 457 }, + { + "t": 1789767256000, + "lon": -73.992422, + "lat": 40.749069, + "altM": 457 + }, + { + "t": 1789767257000, + "lon": -73.992448, + "lat": 40.748716, + "altM": 457 + }, + { + "t": 1789767258000, + "lon": -73.992236, + "lat": 40.748336, + "altM": 465 + }, + { + "t": 1789767259000, + "lon": -73.992217, + "lat": 40.747968, + "altM": 465 + }, + { + "t": 1789767260000, + "lon": -73.992102, + "lat": 40.747578, + "altM": 465 + }, + { "t": 1789767261000, "lon": -73.99193, "lat": 40.747187, "altM": 465 }, + { + "t": 1789767262000, + "lon": -73.991713, + "lat": 40.746877, + "altM": 465 + }, + { "t": 1789767263000, "lon": -73.991521, "lat": 40.74648, "altM": 465 }, + { + "t": 1789767264000, + "lon": -73.991278, + "lat": 40.746137, + "altM": 465 + }, + { "t": 1789767265000, "lon": -73.99105, "lat": 40.745799, "altM": 465 }, + { + "t": 1789767266000, + "lon": -73.990653, + "lat": 40.745478, + "altM": 465 + }, + { + "t": 1789767267000, + "lon": -73.990316, + "lat": 40.745188, + "altM": 465 + }, + { + "t": 1789767268000, + "lon": -73.989911, + "lat": 40.744853, + "altM": 465 + }, + { + "t": 1789767269000, + "lon": -73.989566, + "lat": 40.744531, + "altM": 465 + }, + { + "t": 1789767270000, + "lon": -73.989258, + "lat": 40.744329, + "altM": 465 + }, + { "t": 1789767271000, "lon": -73.988714, "lat": 40.74406, "altM": 465 }, + { "t": 1789767272000, "lon": -73.98825, "lat": 40.74381, "altM": 465 }, + { "t": 1789767273000, "lon": -73.98782, "lat": 40.743649, "altM": 465 }, + { "t": 1789767274000, "lon": -73.98724, "lat": 40.743487, "altM": 465 }, + { + "t": 1789767275000, + "lon": -73.986746, + "lat": 40.743356, + "altM": 465 + }, + { + "t": 1789767276000, + "lon": -73.986268, + "lat": 40.743304, + "altM": 465 + }, + { + "t": 1789767277000, + "lon": -73.985646, + "lat": 40.743164, + "altM": 465 + }, + { + "t": 1789767278000, + "lon": -73.985069, + "lat": 40.743098, + "altM": 465 + }, + { "t": 1789767279000, "lon": -73.984676, "lat": 40.74315, "altM": 465 }, + { + "t": 1789767280000, + "lon": -73.983971, + "lat": 40.743093, + "altM": 465 + }, + { + "t": 1789767281000, + "lon": -73.983439, + "lat": 40.743045, + "altM": 465 + }, + { + "t": 1789767282000, + "lon": -73.982971, + "lat": 40.743141, + "altM": 465 + }, + { + "t": 1789767283000, + "lon": -73.982456, + "lat": 40.743331, + "altM": 465 + }, + { + "t": 1789767284000, + "lon": -73.981957, + "lat": 40.743299, + "altM": 465 + }, + { + "t": 1789767285000, + "lon": -73.981465, + "lat": 40.743482, + "altM": 465 + }, + { + "t": 1789767286000, + "lon": -73.980856, + "lat": 40.743619, + "altM": 465 + }, + { + "t": 1789767287000, + "lon": -73.980391, + "lat": 40.743772, + "altM": 465 + }, + { + "t": 1789767288000, + "lon": -73.980071, + "lat": 40.743971, + "altM": 465 + }, + { + "t": 1789767289000, + "lon": -73.979607, + "lat": 40.744192, + "altM": 465 + }, + { "t": 1789767290000, "lon": -73.979155, "lat": 40.7445, "altM": 465 }, + { + "t": 1789767291000, + "lon": -73.978768, + "lat": 40.744704, + "altM": 465 + }, + { + "t": 1789767292000, + "lon": -73.978507, + "lat": 40.745004, + "altM": 465 + }, + { + "t": 1789767293000, + "lon": -73.978176, + "lat": 40.745287, + "altM": 465 + }, + { + "t": 1789767294000, + "lon": -73.977886, + "lat": 40.745605, + "altM": 465 + }, + { + "t": 1789767295000, + "lon": -73.977557, + "lat": 40.745812, + "altM": 465 + }, + { "t": 1789767296000, "lon": -73.9773, "lat": 40.746095, "altM": 465 }, + { "t": 1789767297000, "lon": -73.977047, "lat": 40.74641, "altM": 465 }, + { + "t": 1789767298000, + "lon": -73.976933, + "lat": 40.746858, + "altM": 465 + }, + { "t": 1789767299000, "lon": -73.976719, "lat": 40.74702, "altM": 465 }, + { "t": 1789767300000, "lon": -73.97652, "lat": 40.747417, "altM": 465 }, + { + "t": 1789767301000, + "lon": -73.976537, + "lat": 40.747758, + "altM": 465 + }, + { + "t": 1789767302000, + "lon": -73.976352, + "lat": 40.748058, + "altM": 465 + }, + { + "t": 1789767303000, + "lon": -73.976284, + "lat": 40.748392, + "altM": 465 + }, + { + "t": 1789767304000, + "lon": -73.976179, + "lat": 40.748748, + "altM": 465 + }, + { + "t": 1789767305000, + "lon": -73.976224, + "lat": 40.749041, + "altM": 465 + }, + { + "t": 1789767306000, + "lon": -73.976179, + "lat": 40.749412, + "altM": 465 + }, + { + "t": 1789767307000, + "lon": -73.976215, + "lat": 40.749639, + "altM": 465 + }, + { + "t": 1789767308000, + "lon": -73.976205, + "lat": 40.750012, + "altM": 465 + }, + { "t": 1789767309000, "lon": -73.97626, "lat": 40.750318, "altM": 465 }, + { + "t": 1789767310000, + "lon": -73.976408, + "lat": 40.750661, + "altM": 465 + }, + { + "t": 1789767311000, + "lon": -73.976462, + "lat": 40.750997, + "altM": 465 + }, + { + "t": 1789767312000, + "lon": -73.976632, + "lat": 40.751333, + "altM": 465 + }, + { + "t": 1789767313000, + "lon": -73.976696, + "lat": 40.751531, + "altM": 465 + }, + { + "t": 1789767314000, + "lon": -73.976908, + "lat": 40.751807, + "altM": 465 + }, + { + "t": 1789767315000, + "lon": -73.977155, + "lat": 40.752075, + "altM": 465 + }, + { + "t": 1789767316000, + "lon": -73.977189, + "lat": 40.752387, + "altM": 465 + }, + { "t": 1789767317000, "lon": -73.97744, "lat": 40.752633, "altM": 465 }, + { "t": 1789767318000, "lon": -73.97775, "lat": 40.752839, "altM": 465 }, + { + "t": 1789767319000, + "lon": -73.977847, + "lat": 40.753106, + "altM": 465 + }, + { + "t": 1789767320000, + "lon": -73.978127, + "lat": 40.753298, + "altM": 465 + }, + { + "t": 1789767321000, + "lon": -73.978347, + "lat": 40.753509, + "altM": 465 + }, + { + "t": 1789767322000, + "lon": -73.978554, + "lat": 40.753848, + "altM": 465 + }, + { + "t": 1789767323000, + "lon": -73.978906, + "lat": 40.753992, + "altM": 465 + }, + { + "t": 1789767324000, + "lon": -73.979221, + "lat": 40.754128, + "altM": 465 + }, + { "t": 1789767325000, "lon": -73.979555, "lat": 40.75439, "altM": 465 }, + { "t": 1789767326000, "lon": -73.979763, "lat": 40.75457, "altM": 465 }, + { + "t": 1789767327000, + "lon": -73.980146, + "lat": 40.754676, + "altM": 465 + }, + { + "t": 1789767328000, + "lon": -73.980505, + "lat": 40.754823, + "altM": 465 + }, + { + "t": 1789767329000, + "lon": -73.980868, + "lat": 40.754967, + "altM": 465 + }, + { + "t": 1789767330000, + "lon": -73.981142, + "lat": 40.755077, + "altM": 465 + }, + { "t": 1789767331000, "lon": -73.98149, "lat": 40.755225, "altM": 465 }, + { + "t": 1789767332000, + "lon": -73.981859, + "lat": 40.755282, + "altM": 465 + }, + { + "t": 1789767333000, + "lon": -73.982314, + "lat": 40.755345, + "altM": 465 + }, + { + "t": 1789767334000, + "lon": -73.982622, + "lat": 40.755417, + "altM": 465 + }, + { + "t": 1789767335000, + "lon": -73.982902, + "lat": 40.755501, + "altM": 457 + }, + { + "t": 1789767336000, + "lon": -73.983258, + "lat": 40.755571, + "altM": 457 + }, + { "t": 1789767337000, "lon": -73.98375, "lat": 40.755563, "altM": 457 }, + { + "t": 1789767338000, + "lon": -73.984093, + "lat": 40.755603, + "altM": 457 + }, + { + "t": 1789767339000, + "lon": -73.984524, + "lat": 40.755613, + "altM": 457 + }, + { + "t": 1789767340000, + "lon": -73.984908, + "lat": 40.755592, + "altM": 457 + }, + { + "t": 1789767341000, + "lon": -73.985214, + "lat": 40.755533, + "altM": 457 + }, + { "t": 1789767342000, "lon": -73.98566, "lat": 40.755514, "altM": 457 }, + { + "t": 1789767343000, + "lon": -73.986002, + "lat": 40.755523, + "altM": 457 + }, + { + "t": 1789767344000, + "lon": -73.986325, + "lat": 40.755378, + "altM": 457 + }, + { + "t": 1789767345000, + "lon": -73.986826, + "lat": 40.755293, + "altM": 457 + }, + { + "t": 1789767346000, + "lon": -73.987251, + "lat": 40.755296, + "altM": 457 + }, + { + "t": 1789767347000, + "lon": -73.987529, + "lat": 40.755128, + "altM": 457 + }, + { "t": 1789767348000, "lon": -73.9879, "lat": 40.755033, "altM": 457 }, + { + "t": 1789767349000, + "lon": -73.988206, + "lat": 40.754871, + "altM": 457 + }, + { + "t": 1789767350000, + "lon": -73.988632, + "lat": 40.754757, + "altM": 457 + }, + { "t": 1789767351000, "lon": -73.98893, "lat": 40.754536, "altM": 457 }, + { + "t": 1789767352000, + "lon": -73.989205, + "lat": 40.754353, + "altM": 457 + }, + { "t": 1789767353000, "lon": -73.989618, "lat": 40.75413, "altM": 457 }, + { + "t": 1789767354000, + "lon": -73.989824, + "lat": 40.754006, + "altM": 457 + }, + { + "t": 1789767355000, + "lon": -73.990168, + "lat": 40.753686, + "altM": 457 + }, + { + "t": 1789767356000, + "lon": -73.990439, + "lat": 40.753495, + "altM": 457 + }, + { + "t": 1789767357000, + "lon": -73.990789, + "lat": 40.753259, + "altM": 457 + }, + { + "t": 1789767358000, + "lon": -73.991003, + "lat": 40.753011, + "altM": 457 + }, + { + "t": 1789767359000, + "lon": -73.991284, + "lat": 40.752697, + "altM": 457 + }, + { + "t": 1789767360000, + "lon": -73.991506, + "lat": 40.752506, + "altM": 457 + }, + { "t": 1789767361000, "lon": -73.991695, "lat": 40.75215, "altM": 457 }, + { + "t": 1789767362000, + "lon": -73.991917, + "lat": 40.751773, + "altM": 457 + }, + { + "t": 1789767363000, + "lon": -73.992048, + "lat": 40.751515, + "altM": 457 + }, + { "t": 1789767364000, "lon": -73.99218, "lat": 40.751232, "altM": 457 }, + { + "t": 1789767365000, + "lon": -73.992246, + "lat": 40.750817, + "altM": 457 + }, + { "t": 1789767366000, "lon": -73.99237, "lat": 40.750438, "altM": 457 }, + { "t": 1789767367000, "lon": -73.992443, "lat": 40.7501, "altM": 457 }, + { + "t": 1789767368000, + "lon": -73.992533, + "lat": 40.749669, + "altM": 457 + }, + { + "t": 1789767369000, + "lon": -73.992496, + "lat": 40.749283, + "altM": 457 + }, + { + "t": 1789767370000, + "lon": -73.992403, + "lat": 40.749013, + "altM": 457 + }, + { + "t": 1789767371000, + "lon": -73.992342, + "lat": 40.748628, + "altM": 450 + }, + { + "t": 1789767372000, + "lon": -73.992334, + "lat": 40.748296, + "altM": 450 + }, + { + "t": 1789767373000, + "lon": -73.992174, + "lat": 40.747863, + "altM": 450 + }, + { + "t": 1789767374000, + "lon": -73.992032, + "lat": 40.747503, + "altM": 450 + }, + { "t": 1789767375000, "lon": -73.991859, "lat": 40.74713, "altM": 450 }, + { + "t": 1789767376000, + "lon": -73.991725, + "lat": 40.746811, + "altM": 450 + }, + { "t": 1789767377000, "lon": -73.99142, "lat": 40.746381, "altM": 450 }, + { "t": 1789767378000, "lon": -73.991128, "lat": 40.746, "altM": 450 }, + { "t": 1789767379000, "lon": -73.990731, "lat": 40.74578, "altM": 450 }, + { + "t": 1789767380000, + "lon": -73.990457, + "lat": 40.745418, + "altM": 450 + }, + { + "t": 1789767381000, + "lon": -73.990012, + "lat": 40.745122, + "altM": 450 + }, + { + "t": 1789767382000, + "lon": -73.989714, + "lat": 40.744819, + "altM": 450 + }, + { + "t": 1789767383000, + "lon": -73.989265, + "lat": 40.744537, + "altM": 450 + }, + { + "t": 1789767384000, + "lon": -73.988707, + "lat": 40.744406, + "altM": 450 + }, + { + "t": 1789767385000, + "lon": -73.988313, + "lat": 40.744085, + "altM": 450 + }, + { + "t": 1789767386000, + "lon": -73.987943, + "lat": 40.743936, + "altM": 450 + }, + { "t": 1789767387000, "lon": -73.987359, "lat": 40.74374, "altM": 450 }, + { + "t": 1789767388000, + "lon": -73.986925, + "lat": 40.743628, + "altM": 450 + }, + { + "t": 1789767389000, + "lon": -73.986313, + "lat": 40.743521, + "altM": 450 + }, + { + "t": 1789767390000, + "lon": -73.985829, + "lat": 40.743488, + "altM": 450 + }, + { "t": 1789767391000, "lon": -73.985203, "lat": 40.74339, "altM": 450 }, + { + "t": 1789767392000, + "lon": -73.984736, + "lat": 40.743342, + "altM": 450 + }, + { + "t": 1789767393000, + "lon": -73.984193, + "lat": 40.743324, + "altM": 450 + }, + { + "t": 1789767394000, + "lon": -73.983644, + "lat": 40.743355, + "altM": 450 + }, + { "t": 1789767395000, "lon": -73.983065, "lat": 40.7435, "altM": 450 }, + { + "t": 1789767396000, + "lon": -73.982609, + "lat": 40.743524, + "altM": 450 + }, + { + "t": 1789767397000, + "lon": -73.982145, + "lat": 40.743652, + "altM": 450 + }, + { + "t": 1789767398000, + "lon": -73.981638, + "lat": 40.743728, + "altM": 450 + }, + { + "t": 1789767399000, + "lon": -73.981037, + "lat": 40.743945, + "altM": 450 + }, + { "t": 1789767400000, "lon": -73.9806, "lat": 40.744084, "altM": 450 }, + { + "t": 1789767401000, + "lon": -73.980151, + "lat": 40.744337, + "altM": 450 + }, + { + "t": 1789767402000, + "lon": -73.979727, + "lat": 40.744529, + "altM": 450 + }, + { + "t": 1789767403000, + "lon": -73.979486, + "lat": 40.744866, + "altM": 450 + }, + { "t": 1789767404000, "lon": -73.97908, "lat": 40.745089, "altM": 450 }, + { "t": 1789767405000, "lon": -73.978773, "lat": 40.74541, "altM": 450 }, + { "t": 1789767406000, "lon": -73.97839, "lat": 40.745689, "altM": 450 }, + { + "t": 1789767407000, + "lon": -73.978117, + "lat": 40.745892, + "altM": 450 + }, + { + "t": 1789767408000, + "lon": -73.978009, + "lat": 40.746306, + "altM": 450 + }, + { "t": 1789767409000, "lon": -73.97769, "lat": 40.746546, "altM": 450 }, + { "t": 1789767410000, "lon": -73.97748, "lat": 40.746867, "altM": 450 }, + { + "t": 1789767411000, + "lon": -73.977353, + "lat": 40.747233, + "altM": 450 + }, + { + "t": 1789767412000, + "lon": -73.977213, + "lat": 40.747516, + "altM": 450 + }, + { + "t": 1789767413000, + "lon": -73.977089, + "lat": 40.747894, + "altM": 450 + }, + { + "t": 1789767414000, + "lon": -73.976991, + "lat": 40.748235, + "altM": 450 + }, + { + "t": 1789767415000, + "lon": -73.976959, + "lat": 40.748577, + "altM": 450 + }, + { + "t": 1789767416000, + "lon": -73.976929, + "lat": 40.748821, + "altM": 450 + }, + { + "t": 1789767417000, + "lon": -73.976992, + "lat": 40.749196, + "altM": 450 + }, + { "t": 1789767418000, "lon": -73.976989, "lat": 40.74947, "altM": 450 }, + { + "t": 1789767419000, + "lon": -73.976941, + "lat": 40.749828, + "altM": 450 + }, + { "t": 1789767420000, "lon": -73.97712, "lat": 40.750175, "altM": 450 }, + { + "t": 1789767421000, + "lon": -73.977178, + "lat": 40.750462, + "altM": 450 + }, + { + "t": 1789767422000, + "lon": -73.977176, + "lat": 40.750809, + "altM": 450 + }, + { + "t": 1789767423000, + "lon": -73.977416, + "lat": 40.751127, + "altM": 450 + }, + { + "t": 1789767424000, + "lon": -73.977472, + "lat": 40.751325, + "altM": 450 + }, + { "t": 1789767425000, "lon": -73.977642, "lat": 40.75164, "altM": 450 }, + { + "t": 1789767426000, + "lon": -73.977816, + "lat": 40.751903, + "altM": 450 + }, + { "t": 1789767427000, "lon": -73.978, "lat": 40.752188, "altM": 450 }, + { + "t": 1789767428000, + "lon": -73.978271, + "lat": 40.752431, + "altM": 450 + }, + { "t": 1789767429000, "lon": -73.97844, "lat": 40.752697, "altM": 450 }, + { + "t": 1789767430000, + "lon": -73.978669, + "lat": 40.752918, + "altM": 450 + }, + { "t": 1789767431000, "lon": -73.978965, "lat": 40.75316, "altM": 450 }, + { "t": 1789767432000, "lon": -73.97937, "lat": 40.753325, "altM": 450 }, + { "t": 1789767433000, "lon": -73.979584, "lat": 40.75356, "altM": 450 }, + { + "t": 1789767434000, + "lon": -73.979765, + "lat": 40.753685, + "altM": 450 + }, + { + "t": 1789767435000, + "lon": -73.980018, + "lat": 40.753916, + "altM": 450 + }, + { + "t": 1789767436000, + "lon": -73.980487, + "lat": 40.754051, + "altM": 450 + }, + { "t": 1789767437000, "lon": -73.9807, "lat": 40.754199, "altM": 450 }, + { + "t": 1789767438000, + "lon": -73.981124, + "lat": 40.754298, + "altM": 450 + }, + { + "t": 1789767439000, + "lon": -73.981392, + "lat": 40.754491, + "altM": 450 + }, + { + "t": 1789767440000, + "lon": -73.981823, + "lat": 40.754547, + "altM": 450 + }, + { + "t": 1789767441000, + "lon": -73.982204, + "lat": 40.754691, + "altM": 450 + }, + { + "t": 1789767442000, + "lon": -73.982515, + "lat": 40.754771, + "altM": 450 + }, + { + "t": 1789767443000, + "lon": -73.982903, + "lat": 40.754782, + "altM": 450 + }, + { + "t": 1789767444000, + "lon": -73.983266, + "lat": 40.754896, + "altM": 450 + }, + { + "t": 1789767445000, + "lon": -73.983592, + "lat": 40.754902, + "altM": 450 + }, + { + "t": 1789767446000, + "lon": -73.984049, + "lat": 40.754974, + "altM": 450 + }, + { + "t": 1789767447000, + "lon": -73.984396, + "lat": 40.754958, + "altM": 450 + }, + { "t": 1789767448000, "lon": -73.98477, "lat": 40.754923, "altM": 450 }, + { + "t": 1789767449000, + "lon": -73.985149, + "lat": 40.754882, + "altM": 450 + }, + { + "t": 1789767450000, + "lon": -73.985487, + "lat": 40.754877, + "altM": 450 + }, + { + "t": 1789767451000, + "lon": -73.985901, + "lat": 40.754897, + "altM": 457 + }, + { "t": 1789767452000, "lon": -73.98632, "lat": 40.754772, "altM": 457 }, + { + "t": 1789767453000, + "lon": -73.986768, + "lat": 40.754743, + "altM": 457 + }, + { "t": 1789767454000, "lon": -73.98712, "lat": 40.754594, "altM": 457 }, + { + "t": 1789767455000, + "lon": -73.987448, + "lat": 40.754537, + "altM": 457 + }, + { "t": 1789767456000, "lon": -73.987742, "lat": 40.75435, "altM": 457 }, + { "t": 1789767457000, "lon": -73.988088, "lat": 40.75417, "altM": 457 }, + { "t": 1789767458000, "lon": -73.988471, "lat": 40.75406, "altM": 457 }, + { + "t": 1789767459000, + "lon": -73.988786, + "lat": 40.753885, + "altM": 457 + }, + { + "t": 1789767460000, + "lon": -73.989162, + "lat": 40.753629, + "altM": 457 + }, + { + "t": 1789767461000, + "lon": -73.989468, + "lat": 40.753462, + "altM": 457 + }, + { + "t": 1789767462000, + "lon": -73.989723, + "lat": 40.753285, + "altM": 457 + }, + { + "t": 1789767463000, + "lon": -73.989996, + "lat": 40.752992, + "altM": 457 + }, + { + "t": 1789767464000, + "lon": -73.990317, + "lat": 40.752735, + "altM": 457 + }, + { + "t": 1789767465000, + "lon": -73.990557, + "lat": 40.752548, + "altM": 457 + }, + { + "t": 1789767466000, + "lon": -73.990788, + "lat": 40.752218, + "altM": 457 + }, + { + "t": 1789767467000, + "lon": -73.991029, + "lat": 40.751922, + "altM": 457 + }, + { + "t": 1789767468000, + "lon": -73.991217, + "lat": 40.751581, + "altM": 457 + }, + { + "t": 1789767469000, + "lon": -73.991432, + "lat": 40.751308, + "altM": 457 + }, + { + "t": 1789767470000, + "lon": -73.991528, + "lat": 40.750958, + "altM": 457 + }, + { + "t": 1789767471000, + "lon": -73.991588, + "lat": 40.750624, + "altM": 457 + }, + { + "t": 1789767472000, + "lon": -73.991747, + "lat": 40.750249, + "altM": 457 + }, + { + "t": 1789767473000, + "lon": -73.991792, + "lat": 40.749895, + "altM": 457 + }, + { + "t": 1789767474000, + "lon": -73.991825, + "lat": 40.749628, + "altM": 457 + }, + { + "t": 1789767475000, + "lon": -73.991872, + "lat": 40.749187, + "altM": 457 + }, + { + "t": 1789767476000, + "lon": -73.991794, + "lat": 40.748842, + "altM": 457 + }, + { + "t": 1789767477000, + "lon": -73.991806, + "lat": 40.748476, + "altM": 457 + }, + { + "t": 1789767478000, + "lon": -73.991619, + "lat": 40.748093, + "altM": 457 + }, + { + "t": 1789767479000, + "lon": -73.991516, + "lat": 40.747729, + "altM": 457 + }, + { "t": 1789767480000, "lon": -73.991337, "lat": 40.74734, "altM": 457 }, + { "t": 1789767481000, "lon": -73.991164, "lat": 40.74697, "altM": 457 }, + { + "t": 1789767482000, + "lon": -73.990952, + "lat": 40.746568, + "altM": 457 + }, + { + "t": 1789767483000, + "lon": -73.990627, + "lat": 40.746278, + "altM": 457 + }, + { + "t": 1789767484000, + "lon": -73.990348, + "lat": 40.745967, + "altM": 457 + }, + { + "t": 1789767485000, + "lon": -73.990015, + "lat": 40.745619, + "altM": 457 + }, + { + "t": 1789767486000, + "lon": -73.989564, + "lat": 40.745269, + "altM": 457 + }, + { + "t": 1789767487000, + "lon": -73.989208, + "lat": 40.745038, + "altM": 465 + }, + { + "t": 1789767488000, + "lon": -73.988735, + "lat": 40.744726, + "altM": 465 + }, + { + "t": 1789767489000, + "lon": -73.988386, + "lat": 40.744573, + "altM": 465 + }, + { + "t": 1789767490000, + "lon": -73.987865, + "lat": 40.744337, + "altM": 465 + }, + { "t": 1789767491000, "lon": -73.98737, "lat": 40.744088, "altM": 465 }, + { + "t": 1789767492000, + "lon": -73.986874, + "lat": 40.743908, + "altM": 465 + }, + { + "t": 1789767493000, + "lon": -73.986339, + "lat": 40.743872, + "altM": 465 + }, + { "t": 1789767494000, "lon": -73.98586, "lat": 40.743732, "altM": 465 }, + { + "t": 1789767495000, + "lon": -73.985398, + "lat": 40.743627, + "altM": 465 + }, + { + "t": 1789767496000, + "lon": -73.984831, + "lat": 40.743693, + "altM": 465 + }, + { "t": 1789767497000, "lon": -73.984244, "lat": 40.74365, "altM": 465 }, + { + "t": 1789767498000, + "lon": -73.983667, + "lat": 40.743623, + "altM": 465 + }, + { + "t": 1789767499000, + "lon": -73.983113, + "lat": 40.743728, + "altM": 465 + }, + { + "t": 1789767500000, + "lon": -73.982637, + "lat": 40.743769, + "altM": 465 + }, + { "t": 1789767501000, "lon": -73.98211, "lat": 40.743829, "altM": 465 }, + { + "t": 1789767502000, + "lon": -73.981539, + "lat": 40.744019, + "altM": 465 + }, + { + "t": 1789767503000, + "lon": -73.981111, + "lat": 40.744073, + "altM": 465 + }, + { + "t": 1789767504000, + "lon": -73.980686, + "lat": 40.744401, + "altM": 465 + }, + { + "t": 1789767505000, + "lon": -73.980295, + "lat": 40.744545, + "altM": 465 + }, + { + "t": 1789767506000, + "lon": -73.979805, + "lat": 40.744686, + "altM": 465 + }, + { + "t": 1789767507000, + "lon": -73.979522, + "lat": 40.744953, + "altM": 465 + }, + { + "t": 1789767508000, + "lon": -73.979119, + "lat": 40.745293, + "altM": 465 + }, + { "t": 1789767509000, "lon": -73.978774, "lat": 40.74553, "altM": 465 }, + { + "t": 1789767510000, + "lon": -73.978385, + "lat": 40.745832, + "altM": 465 + }, + { + "t": 1789767511000, + "lon": -73.978091, + "lat": 40.746167, + "altM": 465 + }, + { + "t": 1789767512000, + "lon": -73.977844, + "lat": 40.746373, + "altM": 465 + }, + { + "t": 1789767513000, + "lon": -73.977624, + "lat": 40.746691, + "altM": 465 + }, + { "t": 1789767514000, "lon": -73.97748, "lat": 40.747015, "altM": 465 }, + { + "t": 1789767515000, + "lon": -73.977237, + "lat": 40.747351, + "altM": 465 + }, + { + "t": 1789767516000, + "lon": -73.977136, + "lat": 40.747706, + "altM": 465 + }, + { + "t": 1789767517000, + "lon": -73.977048, + "lat": 40.747984, + "altM": 465 + }, + { + "t": 1789767518000, + "lon": -73.976913, + "lat": 40.748309, + "altM": 465 + }, + { "t": 1789767519000, "lon": -73.976918, "lat": 40.74875, "altM": 465 }, + { + "t": 1789767520000, + "lon": -73.976856, + "lat": 40.749095, + "altM": 465 + }, + { + "t": 1789767521000, + "lon": -73.976802, + "lat": 40.749328, + "altM": 465 + }, + { + "t": 1789767522000, + "lon": -73.976823, + "lat": 40.749695, + "altM": 465 + }, + { "t": 1789767523000, "lon": -73.97685, "lat": 40.750009, "altM": 465 }, + { + "t": 1789767524000, + "lon": -73.976858, + "lat": 40.750376, + "altM": 465 + }, + { + "t": 1789767525000, + "lon": -73.976882, + "lat": 40.750599, + "altM": 465 + }, + { + "t": 1789767526000, + "lon": -73.977101, + "lat": 40.750912, + "altM": 465 + }, + { "t": 1789767527000, "lon": -73.97718, "lat": 40.751196, "altM": 465 }, + { + "t": 1789767528000, + "lon": -73.977312, + "lat": 40.751499, + "altM": 465 + }, + { + "t": 1789767529000, + "lon": -73.977514, + "lat": 40.751799, + "altM": 465 + }, + { + "t": 1789767530000, + "lon": -73.977668, + "lat": 40.752116, + "altM": 465 + }, + { + "t": 1789767531000, + "lon": -73.977818, + "lat": 40.752329, + "altM": 465 + }, + { + "t": 1789767532000, + "lon": -73.978052, + "lat": 40.752564, + "altM": 465 + }, + { "t": 1789767533000, "lon": -73.97835, "lat": 40.752759, "altM": 465 }, + { "t": 1789767534000, "lon": -73.97849, "lat": 40.753093, "altM": 465 }, + { + "t": 1789767535000, + "lon": -73.978731, + "lat": 40.753308, + "altM": 465 + }, + { + "t": 1789767536000, + "lon": -73.978975, + "lat": 40.753552, + "altM": 465 + }, + { + "t": 1789767537000, + "lon": -73.979221, + "lat": 40.753761, + "altM": 465 + }, + { + "t": 1789767538000, + "lon": -73.979538, + "lat": 40.753853, + "altM": 465 + }, + { + "t": 1789767539000, + "lon": -73.979829, + "lat": 40.754066, + "altM": 465 + }, + { + "t": 1789767540000, + "lon": -73.980066, + "lat": 40.754308, + "altM": 465 + }, + { + "t": 1789767541000, + "lon": -73.980514, + "lat": 40.754439, + "altM": 465 + }, + { "t": 1789767542000, "lon": -73.98079, "lat": 40.754645, "altM": 465 }, + { + "t": 1789767543000, + "lon": -73.981177, + "lat": 40.754745, + "altM": 465 + }, + { + "t": 1789767544000, + "lon": -73.981465, + "lat": 40.754903, + "altM": 465 + }, + { + "t": 1789767545000, + "lon": -73.981799, + "lat": 40.755004, + "altM": 465 + }, + { + "t": 1789767546000, + "lon": -73.982178, + "lat": 40.755078, + "altM": 465 + }, + { + "t": 1789767547000, + "lon": -73.982511, + "lat": 40.755139, + "altM": 465 + }, + { "t": 1789767548000, "lon": -73.982835, "lat": 40.75531, "altM": 465 }, + { + "t": 1789767549000, + "lon": -73.983231, + "lat": 40.755312, + "altM": 465 + }, + { + "t": 1789767550000, + "lon": -73.983631, + "lat": 40.755323, + "altM": 465 + }, + { + "t": 1789767551000, + "lon": -73.983926, + "lat": 40.755422, + "altM": 465 + }, + { + "t": 1789767552000, + "lon": -73.984376, + "lat": 40.755371, + "altM": 465 + }, + { "t": 1789767553000, "lon": -73.98478, "lat": 40.755473, "altM": 465 }, + { + "t": 1789767554000, + "lon": -73.985144, + "lat": 40.755418, + "altM": 465 + }, + { + "t": 1789767555000, + "lon": -73.985504, + "lat": 40.755352, + "altM": 465 + }, + { + "t": 1789767556000, + "lon": -73.985865, + "lat": 40.755402, + "altM": 465 + }, + { + "t": 1789767557000, + "lon": -73.986274, + "lat": 40.755316, + "altM": 465 + }, + { + "t": 1789767558000, + "lon": -73.986696, + "lat": 40.755269, + "altM": 465 + }, + { + "t": 1789767559000, + "lon": -73.986953, + "lat": 40.755142, + "altM": 465 + }, + { + "t": 1789767560000, + "lon": -73.987371, + "lat": 40.755015, + "altM": 465 + }, + { + "t": 1789767561000, + "lon": -73.987859, + "lat": 40.754943, + "altM": 465 + }, + { "t": 1789767562000, "lon": -73.988114, "lat": 40.75483, "altM": 465 }, + { + "t": 1789767563000, + "lon": -73.988592, + "lat": 40.754637, + "altM": 465 + }, + { + "t": 1789767564000, + "lon": -73.988803, + "lat": 40.754506, + "altM": 465 + }, + { + "t": 1789767565000, + "lon": -73.989233, + "lat": 40.754338, + "altM": 465 + }, + { + "t": 1789767566000, + "lon": -73.989474, + "lat": 40.754142, + "altM": 465 + }, + { + "t": 1789767567000, + "lon": -73.989883, + "lat": 40.754053, + "altM": 465 + }, + { + "t": 1789767568000, + "lon": -73.990208, + "lat": 40.753755, + "altM": 465 + }, + { + "t": 1789767569000, + "lon": -73.990463, + "lat": 40.753518, + "altM": 465 + }, + { + "t": 1789767570000, + "lon": -73.990806, + "lat": 40.753307, + "altM": 457 + }, + { + "t": 1789767571000, + "lon": -73.990978, + "lat": 40.753051, + "altM": 457 + }, + { "t": 1789767572000, "lon": -73.991326, "lat": 40.75278, "altM": 457 }, + { "t": 1789767573000, "lon": -73.99147, "lat": 40.75251, "altM": 457 }, + { + "t": 1789767574000, + "lon": -73.991794, + "lat": 40.752208, + "altM": 457 + }, + { + "t": 1789767575000, + "lon": -73.991912, + "lat": 40.751884, + "altM": 457 + }, + { + "t": 1789767576000, + "lon": -73.992152, + "lat": 40.751579, + "altM": 457 + }, + { + "t": 1789767577000, + "lon": -73.992211, + "lat": 40.751227, + "altM": 457 + }, + { + "t": 1789767578000, + "lon": -73.992382, + "lat": 40.750984, + "altM": 457 + }, + { + "t": 1789767579000, + "lon": -73.992529, + "lat": 40.750606, + "altM": 457 + }, + { + "t": 1789767580000, + "lon": -73.992565, + "lat": 40.750141, + "altM": 457 + }, + { "t": 1789767581000, "lon": -73.992604, "lat": 40.7499, "altM": 457 }, + { + "t": 1789767582000, + "lon": -73.992714, + "lat": 40.749544, + "altM": 457 + }, + { "t": 1789767583000, "lon": -73.99262, "lat": 40.749142, "altM": 457 }, + { + "t": 1789767584000, + "lon": -73.992685, + "lat": 40.748716, + "altM": 457 + }, + { + "t": 1789767585000, + "lon": -73.992634, + "lat": 40.748423, + "altM": 457 + }, + { + "t": 1789767586000, + "lon": -73.992466, + "lat": 40.747978, + "altM": 457 + }, + { "t": 1789767587000, "lon": -73.992326, "lat": 40.74761, "altM": 457 }, + { + "t": 1789767588000, + "lon": -73.992181, + "lat": 40.747249, + "altM": 457 + }, + { + "t": 1789767589000, + "lon": -73.992095, + "lat": 40.746861, + "altM": 457 + }, + { + "t": 1789767590000, + "lon": -73.991836, + "lat": 40.746526, + "altM": 457 + }, + { + "t": 1789767591000, + "lon": -73.991576, + "lat": 40.746147, + "altM": 457 + }, + { + "t": 1789767592000, + "lon": -73.991297, + "lat": 40.745812, + "altM": 457 + }, + { "t": 1789767593000, "lon": -73.990979, "lat": 40.7455, "altM": 457 }, + { + "t": 1789767594000, + "lon": -73.990618, + "lat": 40.745182, + "altM": 457 + }, + { + "t": 1789767595000, + "lon": -73.990261, + "lat": 40.744815, + "altM": 457 + }, + { "t": 1789767596000, "lon": -73.989966, "lat": 40.74459, "altM": 457 }, + { + "t": 1789767597000, + "lon": -73.989556, + "lat": 40.744305, + "altM": 457 + }, + { + "t": 1789767598000, + "lon": -73.989015, + "lat": 40.744068, + "altM": 457 + }, + { "t": 1789767599000, "lon": -73.988601, "lat": 40.74386, "altM": 457 }, + { + "t": 1789767600000, + "lon": -73.988153, + "lat": 40.743626, + "altM": 457 + }, + { + "t": 1789767601000, + "lon": -73.987638, + "lat": 40.743446, + "altM": 457 + }, + { + "t": 1789767602000, + "lon": -73.987102, + "lat": 40.743336, + "altM": 457 + }, + { + "t": 1789767603000, + "lon": -73.986622, + "lat": 40.743216, + "altM": 457 + }, + { "t": 1789767604000, "lon": -73.986118, "lat": 40.7431, "altM": 457 }, + { + "t": 1789767605000, + "lon": -73.985489, + "lat": 40.742994, + "altM": 450 + }, + { + "t": 1789767606000, + "lon": -73.984891, + "lat": 40.743021, + "altM": 450 + }, + { + "t": 1789767607000, + "lon": -73.984379, + "lat": 40.742958, + "altM": 450 + }, + { + "t": 1789767608000, + "lon": -73.983918, + "lat": 40.742984, + "altM": 450 + }, + { + "t": 1789767609000, + "lon": -73.983416, + "lat": 40.743036, + "altM": 450 + }, + { + "t": 1789767610000, + "lon": -73.982718, + "lat": 40.743033, + "altM": 450 + }, + { + "t": 1789767611000, + "lon": -73.982364, + "lat": 40.743201, + "altM": 450 + }, + { "t": 1789767612000, "lon": -73.981765, "lat": 40.74331, "altM": 450 }, + { + "t": 1789767613000, + "lon": -73.981339, + "lat": 40.743418, + "altM": 450 + }, + { "t": 1789767614000, "lon": -73.98084, "lat": 40.743586, "altM": 450 }, + { + "t": 1789767615000, + "lon": -73.980311, + "lat": 40.743773, + "altM": 450 + }, + { + "t": 1789767616000, + "lon": -73.979993, + "lat": 40.743927, + "altM": 450 + }, + { "t": 1789767617000, "lon": -73.97956, "lat": 40.744154, "altM": 450 }, + { "t": 1789767618000, "lon": -73.979069, "lat": 40.74445, "altM": 450 }, + { + "t": 1789767619000, + "lon": -73.978773, + "lat": 40.744759, + "altM": 450 + }, + { + "t": 1789767620000, + "lon": -73.978436, + "lat": 40.745003, + "altM": 450 + }, + { + "t": 1789767621000, + "lon": -73.978093, + "lat": 40.745229, + "altM": 450 + }, + { "t": 1789767622000, "lon": -73.977764, "lat": 40.74553, "altM": 450 }, + { + "t": 1789767623000, + "lon": -73.977549, + "lat": 40.745847, + "altM": 450 + }, + { + "t": 1789767624000, + "lon": -73.977261, + "lat": 40.746168, + "altM": 450 + }, + { + "t": 1789767625000, + "lon": -73.977111, + "lat": 40.746418, + "altM": 450 + }, + { + "t": 1789767626000, + "lon": -73.976933, + "lat": 40.746726, + "altM": 450 + }, + { + "t": 1789767627000, + "lon": -73.976728, + "lat": 40.747167, + "altM": 450 + }, + { + "t": 1789767628000, + "lon": -73.976623, + "lat": 40.747457, + "altM": 450 + }, + { + "t": 1789767629000, + "lon": -73.976496, + "lat": 40.747715, + "altM": 450 + }, + { "t": 1789767630000, "lon": -73.976438, "lat": 40.74806, "altM": 450 }, + { "t": 1789767631000, "lon": -73.976236, "lat": 40.74848, "altM": 450 }, + { + "t": 1789767632000, + "lon": -73.976254, + "lat": 40.748756, + "altM": 450 + }, + { "t": 1789767633000, "lon": -73.976283, "lat": 40.74906, "altM": 450 }, + { + "t": 1789767634000, + "lon": -73.976185, + "lat": 40.749443, + "altM": 450 + }, + { + "t": 1789767635000, + "lon": -73.976306, + "lat": 40.749742, + "altM": 450 + }, + { + "t": 1789767636000, + "lon": -73.976279, + "lat": 40.750071, + "altM": 450 + }, + { + "t": 1789767637000, + "lon": -73.976406, + "lat": 40.750315, + "altM": 450 + }, + { + "t": 1789767638000, + "lon": -73.976457, + "lat": 40.750696, + "altM": 450 + }, + { + "t": 1789767639000, + "lon": -73.976623, + "lat": 40.751014, + "altM": 450 + }, + { "t": 1789767640000, "lon": -73.976718, "lat": 40.75123, "altM": 450 }, + { + "t": 1789767641000, + "lon": -73.976847, + "lat": 40.751553, + "altM": 450 + }, + { + "t": 1789767642000, + "lon": -73.976976, + "lat": 40.751865, + "altM": 450 + }, + { + "t": 1789767643000, + "lon": -73.977161, + "lat": 40.752125, + "altM": 450 + }, + { "t": 1789767644000, "lon": -73.97743, "lat": 40.752412, "altM": 450 }, + { "t": 1789767645000, "lon": -73.977589, "lat": 40.75263, "altM": 450 }, + { + "t": 1789767646000, + "lon": -73.977752, + "lat": 40.752893, + "altM": 450 + }, + { "t": 1789767647000, "lon": -73.97809, "lat": 40.753126, "altM": 450 }, + { + "t": 1789767648000, + "lon": -73.978325, + "lat": 40.753334, + "altM": 450 + }, + { + "t": 1789767649000, + "lon": -73.978607, + "lat": 40.753534, + "altM": 450 + }, + { + "t": 1789767650000, + "lon": -73.978947, + "lat": 40.753746, + "altM": 450 + }, + { + "t": 1789767651000, + "lon": -73.979165, + "lat": 40.753934, + "altM": 450 + }, + { "t": 1789767652000, "lon": -73.97946, "lat": 40.754131, "altM": 450 }, + { "t": 1789767653000, "lon": -73.97973, "lat": 40.754284, "altM": 450 }, + { "t": 1789767654000, "lon": -73.980022, "lat": 40.75446, "altM": 450 }, + { + "t": 1789767655000, + "lon": -73.980445, + "lat": 40.754563, + "altM": 450 + }, + { "t": 1789767656000, "lon": -73.980755, "lat": 40.75478, "altM": 450 }, + { + "t": 1789767657000, + "lon": -73.981024, + "lat": 40.754833, + "altM": 450 + }, + { + "t": 1789767658000, + "lon": -73.981366, + "lat": 40.754956, + "altM": 450 + }, + { + "t": 1789767659000, + "lon": -73.981688, + "lat": 40.755098, + "altM": 450 + }, + { + "t": 1789767660000, + "lon": -73.982166, + "lat": 40.755121, + "altM": 450 + }, + { + "t": 1789767661000, + "lon": -73.982388, + "lat": 40.755285, + "altM": 450 + }, + { + "t": 1789767662000, + "lon": -73.982813, + "lat": 40.755238, + "altM": 450 + }, + { + "t": 1789767663000, + "lon": -73.983182, + "lat": 40.755363, + "altM": 450 + }, + { + "t": 1789767664000, + "lon": -73.983575, + "lat": 40.755372, + "altM": 450 + }, + { "t": 1789767665000, "lon": -73.983985, "lat": 40.75542, "altM": 450 }, + { + "t": 1789767666000, + "lon": -73.984282, + "lat": 40.755434, + "altM": 450 + }, + { + "t": 1789767667000, + "lon": -73.984707, + "lat": 40.755421, + "altM": 450 + }, + { + "t": 1789767668000, + "lon": -73.985172, + "lat": 40.755403, + "altM": 450 + }, + { + "t": 1789767669000, + "lon": -73.985547, + "lat": 40.755313, + "altM": 450 + }, + { + "t": 1789767670000, + "lon": -73.985887, + "lat": 40.755337, + "altM": 450 + }, + { + "t": 1789767671000, + "lon": -73.986317, + "lat": 40.755246, + "altM": 450 + }, + { + "t": 1789767672000, + "lon": -73.986662, + "lat": 40.755143, + "altM": 450 + }, + { + "t": 1789767673000, + "lon": -73.986995, + "lat": 40.755079, + "altM": 450 + }, + { + "t": 1789767674000, + "lon": -73.987387, + "lat": 40.755008, + "altM": 450 + }, + { + "t": 1789767675000, + "lon": -73.987782, + "lat": 40.754825, + "altM": 450 + }, + { + "t": 1789767676000, + "lon": -73.988094, + "lat": 40.754701, + "altM": 450 + }, + { + "t": 1789767677000, + "lon": -73.988428, + "lat": 40.754521, + "altM": 450 + }, + { "t": 1789767678000, "lon": -73.98875, "lat": 40.754355, "altM": 450 }, + { + "t": 1789767679000, + "lon": -73.989145, + "lat": 40.754144, + "altM": 450 + }, + { + "t": 1789767680000, + "lon": -73.989444, + "lat": 40.754009, + "altM": 450 + }, + { + "t": 1789767681000, + "lon": -73.989769, + "lat": 40.753777, + "altM": 450 + }, + { + "t": 1789767682000, + "lon": -73.990129, + "lat": 40.753533, + "altM": 450 + }, + { + "t": 1789767683000, + "lon": -73.990341, + "lat": 40.753326, + "altM": 450 + }, + { + "t": 1789767684000, + "lon": -73.990583, + "lat": 40.753058, + "altM": 450 + }, + { + "t": 1789767685000, + "lon": -73.990893, + "lat": 40.752808, + "altM": 450 + }, + { + "t": 1789767686000, + "lon": -73.991065, + "lat": 40.752524, + "altM": 457 + }, + { + "t": 1789767687000, + "lon": -73.991267, + "lat": 40.752194, + "altM": 457 + }, + { + "t": 1789767688000, + "lon": -73.991558, + "lat": 40.751942, + "altM": 457 + }, + { + "t": 1789767689000, + "lon": -73.991709, + "lat": 40.751497, + "altM": 457 + }, + { + "t": 1789767690000, + "lon": -73.991838, + "lat": 40.751204, + "altM": 457 + }, + { + "t": 1789767691000, + "lon": -73.991973, + "lat": 40.750926, + "altM": 457 + }, + { + "t": 1789767692000, + "lon": -73.992054, + "lat": 40.750546, + "altM": 457 + }, + { "t": 1789767693000, "lon": -73.99214, "lat": 40.750261, "altM": 457 }, + { + "t": 1789767694000, + "lon": -73.992157, + "lat": 40.749803, + "altM": 457 + }, + { + "t": 1789767695000, + "lon": -73.992209, + "lat": 40.749475, + "altM": 457 + }, + { + "t": 1789767696000, + "lon": -73.992093, + "lat": 40.749091, + "altM": 457 + }, + { + "t": 1789767697000, + "lon": -73.992137, + "lat": 40.748717, + "altM": 457 + }, + { + "t": 1789767698000, + "lon": -73.992003, + "lat": 40.748349, + "altM": 457 + }, + { + "t": 1789767699000, + "lon": -73.991959, + "lat": 40.747984, + "altM": 457 + }, + { + "t": 1789767700000, + "lon": -73.991771, + "lat": 40.747605, + "altM": 457 + }, + { + "t": 1789767701000, + "lon": -73.991693, + "lat": 40.747262, + "altM": 457 + }, + { "t": 1789767702000, "lon": -73.99136, "lat": 40.746925, "altM": 457 }, + { + "t": 1789767703000, + "lon": -73.991098, + "lat": 40.746484, + "altM": 457 + }, + { "t": 1789767704000, "lon": -73.99082, "lat": 40.746175, "altM": 457 }, + { + "t": 1789767705000, + "lon": -73.990598, + "lat": 40.745909, + "altM": 457 + }, + { + "t": 1789767706000, + "lon": -73.990273, + "lat": 40.745568, + "altM": 457 + }, + { + "t": 1789767707000, + "lon": -73.989815, + "lat": 40.745281, + "altM": 457 + }, + { + "t": 1789767708000, + "lon": -73.989453, + "lat": 40.744961, + "altM": 457 + }, + { + "t": 1789767709000, + "lon": -73.989043, + "lat": 40.744738, + "altM": 457 + }, + { + "t": 1789767710000, + "lon": -73.988579, + "lat": 40.744474, + "altM": 457 + }, + { + "t": 1789767711000, + "lon": -73.988135, + "lat": 40.744292, + "altM": 457 + }, + { + "t": 1789767712000, + "lon": -73.987623, + "lat": 40.744125, + "altM": 457 + }, + { + "t": 1789767713000, + "lon": -73.987106, + "lat": 40.743937, + "altM": 457 + }, + { + "t": 1789767714000, + "lon": -73.986629, + "lat": 40.743781, + "altM": 457 + }, + { + "t": 1789767715000, + "lon": -73.986022, + "lat": 40.743727, + "altM": 457 + }, + { + "t": 1789767716000, + "lon": -73.985471, + "lat": 40.743594, + "altM": 457 + }, + { + "t": 1789767717000, + "lon": -73.984938, + "lat": 40.743571, + "altM": 457 + }, + { "t": 1789767718000, "lon": -73.98441, "lat": 40.743596, "altM": 457 }, + { + "t": 1789767719000, + "lon": -73.983897, + "lat": 40.743594, + "altM": 457 + }, + { + "t": 1789767720000, + "lon": -73.983354, + "lat": 40.743625, + "altM": 457 + }, + { + "t": 1789767721000, + "lon": -73.982798, + "lat": 40.743729, + "altM": 457 + }, + { + "t": 1789767722000, + "lon": -73.982292, + "lat": 40.743824, + "altM": 457 + }, + { "t": 1789767723000, "lon": -73.981815, "lat": 40.74394, "altM": 465 }, + { "t": 1789767724000, "lon": -73.981285, "lat": 40.74417, "altM": 465 }, + { + "t": 1789767725000, + "lon": -73.980784, + "lat": 40.744258, + "altM": 465 + }, + { "t": 1789767726000, "lon": -73.980428, "lat": 40.74452, "altM": 465 }, + { + "t": 1789767727000, + "lon": -73.979981, + "lat": 40.744757, + "altM": 465 + }, + { + "t": 1789767728000, + "lon": -73.979539, + "lat": 40.745003, + "altM": 465 + }, + { + "t": 1789767729000, + "lon": -73.979171, + "lat": 40.745181, + "altM": 465 + }, + { + "t": 1789767730000, + "lon": -73.978908, + "lat": 40.745522, + "altM": 465 + }, + { "t": 1789767731000, "lon": -73.97861, "lat": 40.745756, "altM": 465 }, + { + "t": 1789767732000, + "lon": -73.978378, + "lat": 40.746088, + "altM": 465 + }, + { + "t": 1789767733000, + "lon": -73.978105, + "lat": 40.746391, + "altM": 465 + }, + { + "t": 1789767734000, + "lon": -73.977786, + "lat": 40.746721, + "altM": 465 + }, + { + "t": 1789767735000, + "lon": -73.977756, + "lat": 40.746982, + "altM": 465 + }, + { + "t": 1789767736000, + "lon": -73.977533, + "lat": 40.747323, + "altM": 465 + }, + { + "t": 1789767737000, + "lon": -73.977384, + "lat": 40.747672, + "altM": 465 + }, + { + "t": 1789767738000, + "lon": -73.977279, + "lat": 40.748043, + "altM": 465 + }, + { + "t": 1789767739000, + "lon": -73.977188, + "lat": 40.748338, + "altM": 465 + }, + { + "t": 1789767740000, + "lon": -73.977183, + "lat": 40.748641, + "altM": 465 + }, + { + "t": 1789767741000, + "lon": -73.977199, + "lat": 40.748949, + "altM": 465 + }, + { + "t": 1789767742000, + "lon": -73.977118, + "lat": 40.749394, + "altM": 465 + }, + { + "t": 1789767743000, + "lon": -73.977154, + "lat": 40.749642, + "altM": 465 + }, + { + "t": 1789767744000, + "lon": -73.977131, + "lat": 40.750069, + "altM": 465 + }, + { + "t": 1789767745000, + "lon": -73.977154, + "lat": 40.750301, + "altM": 465 + }, + { + "t": 1789767746000, + "lon": -73.977356, + "lat": 40.750613, + "altM": 465 + }, + { + "t": 1789767747000, + "lon": -73.977374, + "lat": 40.750862, + "altM": 465 + }, + { "t": 1789767748000, "lon": -73.977536, "lat": 40.75116, "altM": 465 }, + { "t": 1789767749000, "lon": -73.977709, "lat": 40.75145, "altM": 465 }, + { + "t": 1789767750000, + "lon": -73.977863, + "lat": 40.751783, + "altM": 465 + }, + { + "t": 1789767751000, + "lon": -73.978107, + "lat": 40.752018, + "altM": 465 + }, + { + "t": 1789767752000, + "lon": -73.978267, + "lat": 40.752294, + "altM": 465 + }, + { + "t": 1789767753000, + "lon": -73.978392, + "lat": 40.752538, + "altM": 465 + }, + { + "t": 1789767754000, + "lon": -73.978707, + "lat": 40.752713, + "altM": 465 + }, + { + "t": 1789767755000, + "lon": -73.978878, + "lat": 40.752997, + "altM": 465 + }, + { + "t": 1789767756000, + "lon": -73.979231, + "lat": 40.753283, + "altM": 465 + }, + { + "t": 1789767757000, + "lon": -73.979424, + "lat": 40.753337, + "altM": 465 + }, + { + "t": 1789767758000, + "lon": -73.979789, + "lat": 40.753586, + "altM": 465 + }, + { + "t": 1789767759000, + "lon": -73.980103, + "lat": 40.753693, + "altM": 465 + }, + { "t": 1789767760000, "lon": -73.98037, "lat": 40.753929, "altM": 465 }, + { + "t": 1789767761000, + "lon": -73.980725, + "lat": 40.754069, + "altM": 465 + }, + { + "t": 1789767762000, + "lon": -73.981017, + "lat": 40.754289, + "altM": 465 + }, + { + "t": 1789767763000, + "lon": -73.981314, + "lat": 40.754351, + "altM": 465 + }, + { + "t": 1789767764000, + "lon": -73.981646, + "lat": 40.754521, + "altM": 465 + }, + { + "t": 1789767765000, + "lon": -73.982049, + "lat": 40.754604, + "altM": 465 + }, + { + "t": 1789767766000, + "lon": -73.982457, + "lat": 40.754697, + "altM": 465 + }, + { + "t": 1789767767000, + "lon": -73.982781, + "lat": 40.754811, + "altM": 465 + }, + { "t": 1789767768000, "lon": -73.983198, "lat": 40.75482, "altM": 465 }, + { + "t": 1789767769000, + "lon": -73.983517, + "lat": 40.754828, + "altM": 465 + }, + { + "t": 1789767770000, + "lon": -73.983901, + "lat": 40.754896, + "altM": 465 + }, + { + "t": 1789767771000, + "lon": -73.984196, + "lat": 40.754894, + "altM": 465 + }, + { + "t": 1789767772000, + "lon": -73.984655, + "lat": 40.754926, + "altM": 465 + }, + { + "t": 1789767773000, + "lon": -73.985084, + "lat": 40.754929, + "altM": 465 + }, + { + "t": 1789767774000, + "lon": -73.985405, + "lat": 40.754953, + "altM": 465 + }, + { + "t": 1789767775000, + "lon": -73.985877, + "lat": 40.754899, + "altM": 465 + }, + { + "t": 1789767776000, + "lon": -73.986217, + "lat": 40.754794, + "altM": 465 + }, + { + "t": 1789767777000, + "lon": -73.986598, + "lat": 40.754746, + "altM": 465 + }, + { + "t": 1789767778000, + "lon": -73.986906, + "lat": 40.754666, + "altM": 465 + }, + { + "t": 1789767779000, + "lon": -73.987339, + "lat": 40.754507, + "altM": 465 + }, + { "t": 1789767780000, "lon": -73.987677, "lat": 40.754459, "altM": 465 } + ] + }, + { + "id": "sky-4", + "kind": "helicopter", + "label": "SKY-4 (illustrative)", + "callsign": "SKY4", + "registration": "ILLUS-04", + "type": "Airbus H130", + "operator": "Sky 4 News (fictional)", + "role": "news", + "color": "#FF9F6B", + "points": [ + { "t": 1789766610000, "lon": -73.971705, "lat": 40.742402, "altM": 15 }, + { "t": 1789766611000, "lon": -73.971864, "lat": 40.742451, "altM": 15 }, + { "t": 1789766612000, "lon": -73.971694, "lat": 40.742471, "altM": 15 }, + { "t": 1789766613000, "lon": -73.971788, "lat": 40.742507, "altM": 15 }, + { "t": 1789766614000, "lon": -73.971627, "lat": 40.742458, "altM": 15 }, + { "t": 1789766615000, "lon": -73.971678, "lat": 40.742482, "altM": 15 }, + { "t": 1789766616000, "lon": -73.971778, "lat": 40.742461, "altM": 15 }, + { "t": 1789766617000, "lon": -73.971718, "lat": 40.742457, "altM": 15 }, + { "t": 1789766618000, "lon": -73.97176, "lat": 40.742432, "altM": 15 }, + { "t": 1789766619000, "lon": -73.971726, "lat": 40.742485, "altM": 15 }, + { "t": 1789766620000, "lon": -73.971757, "lat": 40.742477, "altM": 15 }, + { "t": 1789766621000, "lon": -73.971711, "lat": 40.742479, "altM": 15 }, + { "t": 1789766622000, "lon": -73.971788, "lat": 40.742474, "altM": 15 }, + { "t": 1789766623000, "lon": -73.971757, "lat": 40.742462, "altM": 15 }, + { "t": 1789766624000, "lon": -73.971781, "lat": 40.742411, "altM": 15 }, + { "t": 1789766625000, "lon": -73.971692, "lat": 40.74247, "altM": 15 }, + { "t": 1789766626000, "lon": -73.971722, "lat": 40.742398, "altM": 15 }, + { "t": 1789766627000, "lon": -73.971709, "lat": 40.742447, "altM": 15 }, + { "t": 1789766628000, "lon": -73.97177, "lat": 40.742458, "altM": 15 }, + { "t": 1789766629000, "lon": -73.971758, "lat": 40.742467, "altM": 15 }, + { "t": 1789766630000, "lon": -73.971756, "lat": 40.7424, "altM": 15 }, + { "t": 1789766631000, "lon": -73.971779, "lat": 40.742483, "altM": 15 }, + { "t": 1789766632000, "lon": -73.971758, "lat": 40.742436, "altM": 15 }, + { "t": 1789766633000, "lon": -73.971751, "lat": 40.742382, "altM": 15 }, + { "t": 1789766634000, "lon": -73.971684, "lat": 40.74248, "altM": 15 }, + { "t": 1789766635000, "lon": -73.97177, "lat": 40.742464, "altM": 15 }, + { "t": 1789766636000, "lon": -73.971707, "lat": 40.74239, "altM": 15 }, + { "t": 1789766637000, "lon": -73.97181, "lat": 40.742442, "altM": 15 }, + { "t": 1789766638000, "lon": -73.97181, "lat": 40.742487, "altM": 15 }, + { "t": 1789766639000, "lon": -73.971808, "lat": 40.742466, "altM": 15 }, + { "t": 1789766640000, "lon": -73.971759, "lat": 40.742457, "altM": 23 }, + { "t": 1789766641000, "lon": -73.971882, "lat": 40.742453, "altM": 61 }, + { "t": 1789766642000, "lon": -73.971877, "lat": 40.74252, "altM": 99 }, + { + "t": 1789766643000, + "lon": -73.971811, + "lat": 40.742518, + "altM": 130 + }, + { + "t": 1789766644000, + "lon": -73.972012, + "lat": 40.742503, + "altM": 160 + }, + { + "t": 1789766645000, + "lon": -73.972248, + "lat": 40.742486, + "altM": 183 + }, + { + "t": 1789766646000, + "lon": -73.972376, + "lat": 40.742491, + "altM": 206 + }, + { + "t": 1789766647000, + "lon": -73.972377, + "lat": 40.742523, + "altM": 229 + }, + { + "t": 1789766648000, + "lon": -73.972791, + "lat": 40.742594, + "altM": 244 + }, + { + "t": 1789766649000, + "lon": -73.972975, + "lat": 40.742634, + "altM": 259 + }, + { + "t": 1789766650000, + "lon": -73.973232, + "lat": 40.742699, + "altM": 274 + }, + { "t": 1789766651000, "lon": -73.97342, "lat": 40.742688, "altM": 290 }, + { "t": 1789766652000, "lon": -73.97379, "lat": 40.742799, "altM": 297 }, + { + "t": 1789766653000, + "lon": -73.974077, + "lat": 40.742806, + "altM": 312 + }, + { + "t": 1789766654000, + "lon": -73.974343, + "lat": 40.742854, + "altM": 320 + }, + { "t": 1789766655000, "lon": -73.974615, "lat": 40.74303, "altM": 328 }, + { + "t": 1789766656000, + "lon": -73.974918, + "lat": 40.743045, + "altM": 335 + }, + { "t": 1789766657000, "lon": -73.97524, "lat": 40.743075, "altM": 343 }, + { + "t": 1789766658000, + "lon": -73.975592, + "lat": 40.743125, + "altM": 343 + }, + { + "t": 1789766659000, + "lon": -73.975884, + "lat": 40.743203, + "altM": 351 + }, + { + "t": 1789766660000, + "lon": -73.976173, + "lat": 40.743281, + "altM": 358 + }, + { + "t": 1789766661000, + "lon": -73.976352, + "lat": 40.743249, + "altM": 358 + }, + { + "t": 1789766662000, + "lon": -73.976688, + "lat": 40.743388, + "altM": 366 + }, + { + "t": 1789766663000, + "lon": -73.977059, + "lat": 40.743365, + "altM": 366 + }, + { + "t": 1789766664000, + "lon": -73.977322, + "lat": 40.743447, + "altM": 373 + }, + { "t": 1789766665000, "lon": -73.977546, "lat": 40.74352, "altM": 373 }, + { + "t": 1789766666000, + "lon": -73.977834, + "lat": 40.743549, + "altM": 373 + }, + { + "t": 1789766667000, + "lon": -73.978167, + "lat": 40.743708, + "altM": 381 + }, + { "t": 1789766668000, "lon": -73.97848, "lat": 40.743708, "altM": 381 }, + { + "t": 1789766669000, + "lon": -73.978716, + "lat": 40.743725, + "altM": 381 + }, + { + "t": 1789766670000, + "lon": -73.978948, + "lat": 40.743782, + "altM": 381 + }, + { + "t": 1789766671000, + "lon": -73.979187, + "lat": 40.743943, + "altM": 381 + }, + { "t": 1789766672000, "lon": -73.979577, "lat": 40.74398, "altM": 389 }, + { + "t": 1789766673000, + "lon": -73.979777, + "lat": 40.744026, + "altM": 389 + }, + { "t": 1789766674000, "lon": -73.98013, "lat": 40.74406, "altM": 389 }, + { + "t": 1789766675000, + "lon": -73.980458, + "lat": 40.744134, + "altM": 389 + }, + { "t": 1789766676000, "lon": -73.98073, "lat": 40.744183, "altM": 389 }, + { + "t": 1789766677000, + "lon": -73.981007, + "lat": 40.744239, + "altM": 389 + }, + { + "t": 1789766678000, + "lon": -73.981225, + "lat": 40.744344, + "altM": 389 + }, + { "t": 1789766679000, "lon": -73.981462, "lat": 40.74443, "altM": 389 }, + { "t": 1789766680000, "lon": -73.981811, "lat": 40.74453, "altM": 389 }, + { + "t": 1789766681000, + "lon": -73.982031, + "lat": 40.744709, + "altM": 389 + }, + { "t": 1789766682000, "lon": -73.982172, "lat": 40.74489, "altM": 396 }, + { "t": 1789766683000, "lon": -73.9824, "lat": 40.745105, "altM": 396 }, + { "t": 1789766684000, "lon": -73.982508, "lat": 40.74526, "altM": 396 }, + { + "t": 1789766685000, + "lon": -73.982588, + "lat": 40.745453, + "altM": 396 + }, + { "t": 1789766686000, "lon": -73.982708, "lat": 40.74572, "altM": 396 }, + { + "t": 1789766687000, + "lon": -73.982799, + "lat": 40.745923, + "altM": 396 + }, + { + "t": 1789766688000, + "lon": -73.982675, + "lat": 40.746262, + "altM": 396 + }, + { "t": 1789766689000, "lon": -73.98277, "lat": 40.746502, "altM": 396 }, + { + "t": 1789766690000, + "lon": -73.982668, + "lat": 40.746761, + "altM": 396 + }, + { "t": 1789766691000, "lon": -73.98258, "lat": 40.746961, "altM": 396 }, + { + "t": 1789766692000, + "lon": -73.982528, + "lat": 40.747319, + "altM": 396 + }, + { + "t": 1789766693000, + "lon": -73.982237, + "lat": 40.747587, + "altM": 396 + }, + { + "t": 1789766694000, + "lon": -73.982096, + "lat": 40.747764, + "altM": 396 + }, + { "t": 1789766695000, "lon": -73.98183, "lat": 40.748022, "altM": 396 }, + { + "t": 1789766696000, + "lon": -73.981689, + "lat": 40.748338, + "altM": 396 + }, + { + "t": 1789766697000, + "lon": -73.981315, + "lat": 40.748478, + "altM": 396 + }, + { + "t": 1789766698000, + "lon": -73.981015, + "lat": 40.748698, + "altM": 396 + }, + { + "t": 1789766699000, + "lon": -73.980652, + "lat": 40.748852, + "altM": 396 + }, + { + "t": 1789766700000, + "lon": -73.980343, + "lat": 40.749039, + "altM": 396 + }, + { "t": 1789766701000, "lon": -73.97986, "lat": 40.749253, "altM": 396 }, + { "t": 1789766702000, "lon": -73.9794, "lat": 40.749261, "altM": 396 }, + { + "t": 1789766703000, + "lon": -73.979034, + "lat": 40.749387, + "altM": 396 + }, + { "t": 1789766704000, "lon": -73.978547, "lat": 40.74945, "altM": 396 }, + { + "t": 1789766705000, + "lon": -73.978132, + "lat": 40.749516, + "altM": 396 + }, + { + "t": 1789766706000, + "lon": -73.977613, + "lat": 40.749416, + "altM": 396 + }, + { + "t": 1789766707000, + "lon": -73.977109, + "lat": 40.749457, + "altM": 396 + }, + { + "t": 1789766708000, + "lon": -73.976709, + "lat": 40.749417, + "altM": 396 + }, + { + "t": 1789766709000, + "lon": -73.976213, + "lat": 40.749364, + "altM": 396 + }, + { + "t": 1789766710000, + "lon": -73.975729, + "lat": 40.749175, + "altM": 396 + }, + { + "t": 1789766711000, + "lon": -73.975213, + "lat": 40.749069, + "altM": 396 + }, + { + "t": 1789766712000, + "lon": -73.974798, + "lat": 40.748954, + "altM": 396 + }, + { "t": 1789766713000, "lon": -73.97437, "lat": 40.748771, "altM": 396 }, + { "t": 1789766714000, "lon": -73.973886, "lat": 40.74847, "altM": 396 }, + { + "t": 1789766715000, + "lon": -73.973493, + "lat": 40.748259, + "altM": 396 + }, + { + "t": 1789766716000, + "lon": -73.973183, + "lat": 40.748031, + "altM": 396 + }, + { + "t": 1789766717000, + "lon": -73.972867, + "lat": 40.747724, + "altM": 396 + }, + { + "t": 1789766718000, + "lon": -73.972596, + "lat": 40.747406, + "altM": 396 + }, + { + "t": 1789766719000, + "lon": -73.972335, + "lat": 40.747163, + "altM": 396 + }, + { + "t": 1789766720000, + "lon": -73.972132, + "lat": 40.746789, + "altM": 396 + }, + { + "t": 1789766721000, + "lon": -73.971914, + "lat": 40.746427, + "altM": 396 + }, + { + "t": 1789766722000, + "lon": -73.971781, + "lat": 40.746135, + "altM": 396 + }, + { + "t": 1789766723000, + "lon": -73.971642, + "lat": 40.745768, + "altM": 396 + }, + { + "t": 1789766724000, + "lon": -73.971632, + "lat": 40.745346, + "altM": 396 + }, + { + "t": 1789766725000, + "lon": -73.971581, + "lat": 40.745128, + "altM": 396 + }, + { "t": 1789766726000, "lon": -73.97168, "lat": 40.744719, "altM": 396 }, + { "t": 1789766727000, "lon": -73.97158, "lat": 40.744369, "altM": 396 }, + { + "t": 1789766728000, + "lon": -73.971754, + "lat": 40.744101, + "altM": 396 + }, + { + "t": 1789766729000, + "lon": -73.971906, + "lat": 40.743744, + "altM": 396 + }, + { + "t": 1789766730000, + "lon": -73.972053, + "lat": 40.743492, + "altM": 396 + }, + { + "t": 1789766731000, + "lon": -73.972255, + "lat": 40.743251, + "altM": 396 + }, + { "t": 1789766732000, "lon": -73.972575, "lat": 40.74299, "altM": 404 }, + { + "t": 1789766733000, + "lon": -73.972832, + "lat": 40.742728, + "altM": 404 + }, + { + "t": 1789766734000, + "lon": -73.973019, + "lat": 40.742571, + "altM": 404 + }, + { + "t": 1789766735000, + "lon": -73.973319, + "lat": 40.742398, + "altM": 404 + }, + { "t": 1789766736000, "lon": -73.97364, "lat": 40.742262, "altM": 404 }, + { + "t": 1789766737000, + "lon": -73.973959, + "lat": 40.742157, + "altM": 404 + }, + { + "t": 1789766738000, + "lon": -73.974347, + "lat": 40.742109, + "altM": 404 + }, + { "t": 1789766739000, "lon": -73.97458, "lat": 40.742113, "altM": 404 }, + { "t": 1789766740000, "lon": -73.974978, "lat": 40.74206, "altM": 404 }, + { "t": 1789766741000, "lon": -73.975307, "lat": 40.74207, "altM": 404 }, + { + "t": 1789766742000, + "lon": -73.975609, + "lat": 40.742119, + "altM": 404 + }, + { + "t": 1789766743000, + "lon": -73.975904, + "lat": 40.742168, + "altM": 404 + }, + { + "t": 1789766744000, + "lon": -73.976184, + "lat": 40.742277, + "altM": 404 + }, + { "t": 1789766745000, "lon": -73.97655, "lat": 40.742402, "altM": 404 }, + { + "t": 1789766746000, + "lon": -73.976886, + "lat": 40.742509, + "altM": 404 + }, + { + "t": 1789766747000, + "lon": -73.977049, + "lat": 40.742693, + "altM": 404 + }, + { + "t": 1789766748000, + "lon": -73.977204, + "lat": 40.742915, + "altM": 404 + }, + { "t": 1789766749000, "lon": -73.977448, "lat": 40.74321, "altM": 404 }, + { + "t": 1789766750000, + "lon": -73.977499, + "lat": 40.743348, + "altM": 404 + }, + { + "t": 1789766751000, + "lon": -73.977599, + "lat": 40.743664, + "altM": 404 + }, + { + "t": 1789766752000, + "lon": -73.977744, + "lat": 40.743948, + "altM": 404 + }, + { + "t": 1789766753000, + "lon": -73.977786, + "lat": 40.744219, + "altM": 404 + }, + { "t": 1789766754000, "lon": -73.977884, "lat": 40.74449, "altM": 404 }, + { + "t": 1789766755000, + "lon": -73.977967, + "lat": 40.744732, + "altM": 404 + }, + { + "t": 1789766756000, + "lon": -73.978051, + "lat": 40.745018, + "altM": 404 + }, + { + "t": 1789766757000, + "lon": -73.978094, + "lat": 40.745252, + "altM": 404 + }, + { "t": 1789766758000, "lon": -73.978169, "lat": 40.74557, "altM": 404 }, + { + "t": 1789766759000, + "lon": -73.978134, + "lat": 40.745882, + "altM": 404 + }, + { + "t": 1789766760000, + "lon": -73.978156, + "lat": 40.746108, + "altM": 404 + }, + { + "t": 1789766761000, + "lon": -73.978201, + "lat": 40.746482, + "altM": 404 + }, + { + "t": 1789766762000, + "lon": -73.978203, + "lat": 40.746714, + "altM": 396 + }, + { + "t": 1789766763000, + "lon": -73.978214, + "lat": 40.747003, + "altM": 396 + }, + { + "t": 1789766764000, + "lon": -73.978252, + "lat": 40.747294, + "altM": 396 + }, + { + "t": 1789766765000, + "lon": -73.978342, + "lat": 40.747573, + "altM": 396 + }, + { + "t": 1789766766000, + "lon": -73.978426, + "lat": 40.747774, + "altM": 396 + }, + { "t": 1789766767000, "lon": -73.978453, "lat": 40.74815, "altM": 396 }, + { + "t": 1789766768000, + "lon": -73.978468, + "lat": 40.748388, + "altM": 396 + }, + { + "t": 1789766769000, + "lon": -73.978616, + "lat": 40.748669, + "altM": 396 + }, + { + "t": 1789766770000, + "lon": -73.978637, + "lat": 40.748902, + "altM": 396 + }, + { + "t": 1789766771000, + "lon": -73.978756, + "lat": 40.749168, + "altM": 396 + }, + { + "t": 1789766772000, + "lon": -73.978905, + "lat": 40.749347, + "altM": 396 + }, + { + "t": 1789766773000, + "lon": -73.979108, + "lat": 40.749642, + "altM": 396 + }, + { + "t": 1789766774000, + "lon": -73.979245, + "lat": 40.749903, + "altM": 396 + }, + { "t": 1789766775000, "lon": -73.979503, "lat": 40.75016, "altM": 396 }, + { + "t": 1789766776000, + "lon": -73.979597, + "lat": 40.750337, + "altM": 396 + }, + { "t": 1789766777000, "lon": -73.979783, "lat": 40.75054, "altM": 396 }, + { + "t": 1789766778000, + "lon": -73.980092, + "lat": 40.750753, + "altM": 396 + }, + { + "t": 1789766779000, + "lon": -73.980301, + "lat": 40.750931, + "altM": 396 + }, + { + "t": 1789766780000, + "lon": -73.980523, + "lat": 40.751098, + "altM": 396 + }, + { "t": 1789766781000, "lon": -73.98072, "lat": 40.751259, "altM": 396 }, + { + "t": 1789766782000, + "lon": -73.981093, + "lat": 40.751431, + "altM": 396 + }, + { + "t": 1789766783000, + "lon": -73.981315, + "lat": 40.751608, + "altM": 396 + }, + { + "t": 1789766784000, + "lon": -73.981636, + "lat": 40.751723, + "altM": 396 + }, + { + "t": 1789766785000, + "lon": -73.981863, + "lat": 40.751825, + "altM": 396 + }, + { + "t": 1789766786000, + "lon": -73.982166, + "lat": 40.751905, + "altM": 396 + }, + { "t": 1789766787000, "lon": -73.982517, "lat": 40.75206, "altM": 396 }, + { + "t": 1789766788000, + "lon": -73.982756, + "lat": 40.752097, + "altM": 396 + }, + { + "t": 1789766789000, + "lon": -73.983117, + "lat": 40.752184, + "altM": 396 + }, + { + "t": 1789766790000, + "lon": -73.983396, + "lat": 40.752331, + "altM": 396 + }, + { + "t": 1789766791000, + "lon": -73.983749, + "lat": 40.752352, + "altM": 396 + }, + { + "t": 1789766792000, + "lon": -73.984084, + "lat": 40.752352, + "altM": 396 + }, + { + "t": 1789766793000, + "lon": -73.984429, + "lat": 40.752406, + "altM": 396 + }, + { "t": 1789766794000, "lon": -73.98473, "lat": 40.752348, "altM": 396 }, + { + "t": 1789766795000, + "lon": -73.985084, + "lat": 40.752354, + "altM": 396 + }, + { "t": 1789766796000, "lon": -73.9854, "lat": 40.75234, "altM": 396 }, + { + "t": 1789766797000, + "lon": -73.985715, + "lat": 40.752349, + "altM": 396 + }, + { + "t": 1789766798000, + "lon": -73.986139, + "lat": 40.752278, + "altM": 396 + }, + { "t": 1789766799000, "lon": -73.986375, "lat": 40.75222, "altM": 396 }, + { + "t": 1789766800000, + "lon": -73.986796, + "lat": 40.752183, + "altM": 396 + }, + { + "t": 1789766801000, + "lon": -73.987114, + "lat": 40.752165, + "altM": 389 + }, + { + "t": 1789766802000, + "lon": -73.987322, + "lat": 40.751978, + "altM": 389 + }, + { + "t": 1789766803000, + "lon": -73.987676, + "lat": 40.751836, + "altM": 389 + }, + { + "t": 1789766804000, + "lon": -73.988097, + "lat": 40.751736, + "altM": 389 + }, + { + "t": 1789766805000, + "lon": -73.988341, + "lat": 40.751561, + "altM": 389 + }, + { + "t": 1789766806000, + "lon": -73.988525, + "lat": 40.751435, + "altM": 389 + }, + { "t": 1789766807000, "lon": -73.98891, "lat": 40.751232, "altM": 389 }, + { + "t": 1789766808000, + "lon": -73.989158, + "lat": 40.751004, + "altM": 389 + }, + { "t": 1789766809000, "lon": -73.989352, "lat": 40.75086, "altM": 389 }, + { + "t": 1789766810000, + "lon": -73.989649, + "lat": 40.750645, + "altM": 389 + }, + { + "t": 1789766811000, + "lon": -73.989943, + "lat": 40.750433, + "altM": 389 + }, + { + "t": 1789766812000, + "lon": -73.990125, + "lat": 40.750085, + "altM": 389 + }, + { + "t": 1789766813000, + "lon": -73.990294, + "lat": 40.749921, + "altM": 389 + }, + { + "t": 1789766814000, + "lon": -73.990544, + "lat": 40.749579, + "altM": 389 + }, + { + "t": 1789766815000, + "lon": -73.990634, + "lat": 40.749322, + "altM": 389 + }, + { + "t": 1789766816000, + "lon": -73.990792, + "lat": 40.748992, + "altM": 389 + }, + { + "t": 1789766817000, + "lon": -73.990805, + "lat": 40.748701, + "altM": 389 + }, + { "t": 1789766818000, "lon": -73.991001, "lat": 40.74839, "altM": 389 }, + { + "t": 1789766819000, + "lon": -73.991121, + "lat": 40.748145, + "altM": 389 + }, + { "t": 1789766820000, "lon": -73.991159, "lat": 40.74784, "altM": 389 }, + { "t": 1789766821000, "lon": -73.990962, "lat": 40.74747, "altM": 389 }, + { + "t": 1789766822000, + "lon": -73.990981, + "lat": 40.747128, + "altM": 389 + }, + { "t": 1789766823000, "lon": -73.991002, "lat": 40.74675, "altM": 389 }, + { + "t": 1789766824000, + "lon": -73.990908, + "lat": 40.746479, + "altM": 389 + }, + { + "t": 1789766825000, + "lon": -73.990655, + "lat": 40.746099, + "altM": 389 + }, + { + "t": 1789766826000, + "lon": -73.990575, + "lat": 40.745814, + "altM": 389 + }, + { + "t": 1789766827000, + "lon": -73.990343, + "lat": 40.745428, + "altM": 389 + }, + { + "t": 1789766828000, + "lon": -73.990121, + "lat": 40.745142, + "altM": 389 + }, + { + "t": 1789766829000, + "lon": -73.989838, + "lat": 40.744834, + "altM": 389 + }, + { + "t": 1789766830000, + "lon": -73.989602, + "lat": 40.744495, + "altM": 389 + }, + { + "t": 1789766831000, + "lon": -73.989182, + "lat": 40.744258, + "altM": 389 + }, + { "t": 1789766832000, "lon": -73.988882, "lat": 40.74399, "altM": 389 }, + { + "t": 1789766833000, + "lon": -73.988464, + "lat": 40.743789, + "altM": 389 + }, + { + "t": 1789766834000, + "lon": -73.988039, + "lat": 40.743494, + "altM": 389 + }, + { + "t": 1789766835000, + "lon": -73.987659, + "lat": 40.743267, + "altM": 389 + }, + { + "t": 1789766836000, + "lon": -73.987165, + "lat": 40.743115, + "altM": 389 + }, + { + "t": 1789766837000, + "lon": -73.986746, + "lat": 40.743077, + "altM": 389 + }, + { + "t": 1789766838000, + "lon": -73.986247, + "lat": 40.742866, + "altM": 389 + }, + { + "t": 1789766839000, + "lon": -73.985753, + "lat": 40.742897, + "altM": 389 + }, + { + "t": 1789766840000, + "lon": -73.985297, + "lat": 40.742772, + "altM": 389 + }, + { + "t": 1789766841000, + "lon": -73.984807, + "lat": 40.742702, + "altM": 389 + }, + { "t": 1789766842000, "lon": -73.98431, "lat": 40.742748, "altM": 389 }, + { "t": 1789766843000, "lon": -73.98384, "lat": 40.742794, "altM": 389 }, + { + "t": 1789766844000, + "lon": -73.983335, + "lat": 40.742763, + "altM": 389 + }, + { + "t": 1789766845000, + "lon": -73.982785, + "lat": 40.742873, + "altM": 389 + }, + { + "t": 1789766846000, + "lon": -73.982426, + "lat": 40.743022, + "altM": 389 + }, + { + "t": 1789766847000, + "lon": -73.981927, + "lat": 40.743092, + "altM": 389 + }, + { + "t": 1789766848000, + "lon": -73.981574, + "lat": 40.743298, + "altM": 389 + }, + { + "t": 1789766849000, + "lon": -73.981107, + "lat": 40.743484, + "altM": 389 + }, + { + "t": 1789766850000, + "lon": -73.980763, + "lat": 40.743665, + "altM": 389 + }, + { + "t": 1789766851000, + "lon": -73.980363, + "lat": 40.743909, + "altM": 389 + }, + { "t": 1789766852000, "lon": -73.980118, "lat": 40.74419, "altM": 389 }, + { + "t": 1789766853000, + "lon": -73.979771, + "lat": 40.744348, + "altM": 389 + }, + { + "t": 1789766854000, + "lon": -73.979614, + "lat": 40.744677, + "altM": 389 + }, + { "t": 1789766855000, "lon": -73.97927, "lat": 40.744925, "altM": 389 }, + { + "t": 1789766856000, + "lon": -73.979051, + "lat": 40.745178, + "altM": 389 + }, + { + "t": 1789766857000, + "lon": -73.978936, + "lat": 40.745461, + "altM": 389 + }, + { + "t": 1789766858000, + "lon": -73.978706, + "lat": 40.745697, + "altM": 389 + }, + { + "t": 1789766859000, + "lon": -73.978551, + "lat": 40.746063, + "altM": 389 + }, + { + "t": 1789766860000, + "lon": -73.978446, + "lat": 40.746382, + "altM": 389 + }, + { + "t": 1789766861000, + "lon": -73.978266, + "lat": 40.746629, + "altM": 389 + }, + { + "t": 1789766862000, + "lon": -73.978284, + "lat": 40.746956, + "altM": 389 + }, + { + "t": 1789766863000, + "lon": -73.978281, + "lat": 40.747261, + "altM": 389 + }, + { + "t": 1789766864000, + "lon": -73.978181, + "lat": 40.747539, + "altM": 389 + }, + { "t": 1789766865000, "lon": -73.978206, "lat": 40.74776, "altM": 389 }, + { + "t": 1789766866000, + "lon": -73.978198, + "lat": 40.748052, + "altM": 389 + }, + { + "t": 1789766867000, + "lon": -73.978201, + "lat": 40.748387, + "altM": 389 + }, + { + "t": 1789766868000, + "lon": -73.978268, + "lat": 40.748587, + "altM": 389 + }, + { "t": 1789766869000, "lon": -73.978391, "lat": 40.74888, "altM": 389 }, + { + "t": 1789766870000, + "lon": -73.978473, + "lat": 40.749183, + "altM": 389 + }, + { + "t": 1789766871000, + "lon": -73.978654, + "lat": 40.749491, + "altM": 389 + }, + { + "t": 1789766872000, + "lon": -73.978818, + "lat": 40.749665, + "altM": 389 + }, + { + "t": 1789766873000, + "lon": -73.978912, + "lat": 40.749867, + "altM": 389 + }, + { + "t": 1789766874000, + "lon": -73.979015, + "lat": 40.750107, + "altM": 389 + }, + { "t": 1789766875000, "lon": -73.979191, "lat": 40.75034, "altM": 389 }, + { "t": 1789766876000, "lon": -73.97938, "lat": 40.750604, "altM": 389 }, + { + "t": 1789766877000, + "lon": -73.979589, + "lat": 40.750842, + "altM": 389 + }, + { + "t": 1789766878000, + "lon": -73.979843, + "lat": 40.751021, + "altM": 389 + }, + { + "t": 1789766879000, + "lon": -73.980011, + "lat": 40.751208, + "altM": 389 + }, + { + "t": 1789766880000, + "lon": -73.980291, + "lat": 40.751371, + "altM": 389 + }, + { + "t": 1789766881000, + "lon": -73.980573, + "lat": 40.751523, + "altM": 389 + }, + { + "t": 1789766882000, + "lon": -73.980706, + "lat": 40.751643, + "altM": 396 + }, + { + "t": 1789766883000, + "lon": -73.980936, + "lat": 40.751846, + "altM": 396 + }, + { + "t": 1789766884000, + "lon": -73.981282, + "lat": 40.752051, + "altM": 396 + }, + { + "t": 1789766885000, + "lon": -73.981688, + "lat": 40.752149, + "altM": 396 + }, + { + "t": 1789766886000, + "lon": -73.981835, + "lat": 40.752292, + "altM": 396 + }, + { + "t": 1789766887000, + "lon": -73.982224, + "lat": 40.752366, + "altM": 396 + }, + { + "t": 1789766888000, + "lon": -73.982558, + "lat": 40.752499, + "altM": 396 + }, + { + "t": 1789766889000, + "lon": -73.982832, + "lat": 40.752612, + "altM": 396 + }, + { + "t": 1789766890000, + "lon": -73.983089, + "lat": 40.752633, + "altM": 396 + }, + { + "t": 1789766891000, + "lon": -73.983405, + "lat": 40.752653, + "altM": 396 + }, + { + "t": 1789766892000, + "lon": -73.983797, + "lat": 40.752791, + "altM": 396 + }, + { "t": 1789766893000, "lon": -73.984, "lat": 40.752818, "altM": 396 }, + { + "t": 1789766894000, + "lon": -73.984514, + "lat": 40.752805, + "altM": 396 + }, + { + "t": 1789766895000, + "lon": -73.984695, + "lat": 40.752894, + "altM": 396 + }, + { + "t": 1789766896000, + "lon": -73.985136, + "lat": 40.752784, + "altM": 396 + }, + { + "t": 1789766897000, + "lon": -73.985402, + "lat": 40.752834, + "altM": 396 + }, + { + "t": 1789766898000, + "lon": -73.985707, + "lat": 40.752838, + "altM": 396 + }, + { + "t": 1789766899000, + "lon": -73.986049, + "lat": 40.752706, + "altM": 396 + }, + { + "t": 1789766900000, + "lon": -73.986539, + "lat": 40.752719, + "altM": 396 + }, + { + "t": 1789766901000, + "lon": -73.986801, + "lat": 40.752669, + "altM": 396 + }, + { + "t": 1789766902000, + "lon": -73.987135, + "lat": 40.752619, + "altM": 396 + }, + { "t": 1789766903000, "lon": -73.98733, "lat": 40.752539, "altM": 396 }, + { "t": 1789766904000, "lon": -73.987697, "lat": 40.75241, "altM": 396 }, + { + "t": 1789766905000, + "lon": -73.988042, + "lat": 40.752299, + "altM": 396 + }, + { + "t": 1789766906000, + "lon": -73.988322, + "lat": 40.752165, + "altM": 396 + }, + { "t": 1789766907000, "lon": -73.98854, "lat": 40.75208, "altM": 396 }, + { + "t": 1789766908000, + "lon": -73.988953, + "lat": 40.751749, + "altM": 396 + }, + { + "t": 1789766909000, + "lon": -73.989194, + "lat": 40.751643, + "altM": 396 + }, + { "t": 1789766910000, "lon": -73.98953, "lat": 40.751476, "altM": 396 }, + { + "t": 1789766911000, + "lon": -73.989797, + "lat": 40.751384, + "altM": 396 + }, + { + "t": 1789766912000, + "lon": -73.990076, + "lat": 40.751071, + "altM": 396 + }, + { + "t": 1789766913000, + "lon": -73.990276, + "lat": 40.750915, + "altM": 396 + }, + { + "t": 1789766914000, + "lon": -73.990558, + "lat": 40.750644, + "altM": 396 + }, + { + "t": 1789766915000, + "lon": -73.990673, + "lat": 40.750372, + "altM": 396 + }, + { + "t": 1789766916000, + "lon": -73.990976, + "lat": 40.750112, + "altM": 396 + }, + { + "t": 1789766917000, + "lon": -73.991115, + "lat": 40.749941, + "altM": 396 + }, + { + "t": 1789766918000, + "lon": -73.991283, + "lat": 40.749601, + "altM": 396 + }, + { + "t": 1789766919000, + "lon": -73.991344, + "lat": 40.749379, + "altM": 396 + }, + { + "t": 1789766920000, + "lon": -73.991478, + "lat": 40.748993, + "altM": 404 + }, + { + "t": 1789766921000, + "lon": -73.991686, + "lat": 40.748702, + "altM": 404 + }, + { + "t": 1789766922000, + "lon": -73.991796, + "lat": 40.748386, + "altM": 404 + }, + { + "t": 1789766923000, + "lon": -73.991714, + "lat": 40.748065, + "altM": 404 + }, + { + "t": 1789766924000, + "lon": -73.991759, + "lat": 40.747728, + "altM": 404 + }, + { "t": 1789766925000, "lon": -73.991723, "lat": 40.74739, "altM": 404 }, + { + "t": 1789766926000, + "lon": -73.991719, + "lat": 40.747081, + "altM": 404 + }, + { "t": 1789766927000, "lon": -73.991695, "lat": 40.74671, "altM": 404 }, + { + "t": 1789766928000, + "lon": -73.991567, + "lat": 40.746397, + "altM": 404 + }, + { + "t": 1789766929000, + "lon": -73.991456, + "lat": 40.746083, + "altM": 404 + }, + { + "t": 1789766930000, + "lon": -73.991319, + "lat": 40.745764, + "altM": 404 + }, + { + "t": 1789766931000, + "lon": -73.991084, + "lat": 40.745436, + "altM": 404 + }, + { + "t": 1789766932000, + "lon": -73.990831, + "lat": 40.745079, + "altM": 404 + }, + { + "t": 1789766933000, + "lon": -73.990607, + "lat": 40.744803, + "altM": 404 + }, + { + "t": 1789766934000, + "lon": -73.990367, + "lat": 40.744428, + "altM": 404 + }, + { + "t": 1789766935000, + "lon": -73.990033, + "lat": 40.744134, + "altM": 404 + }, + { "t": 1789766936000, "lon": -73.989735, "lat": 40.7439, "altM": 404 }, + { + "t": 1789766937000, + "lon": -73.989378, + "lat": 40.743585, + "altM": 404 + }, + { + "t": 1789766938000, + "lon": -73.989006, + "lat": 40.743368, + "altM": 404 + }, + { + "t": 1789766939000, + "lon": -73.988598, + "lat": 40.743167, + "altM": 404 + }, + { + "t": 1789766940000, + "lon": -73.988148, + "lat": 40.742924, + "altM": 404 + }, + { + "t": 1789766941000, + "lon": -73.987682, + "lat": 40.742784, + "altM": 404 + }, + { + "t": 1789766942000, + "lon": -73.987253, + "lat": 40.742671, + "altM": 404 + }, + { + "t": 1789766943000, + "lon": -73.986901, + "lat": 40.742509, + "altM": 404 + }, + { + "t": 1789766944000, + "lon": -73.986295, + "lat": 40.742353, + "altM": 404 + }, + { + "t": 1789766945000, + "lon": -73.985843, + "lat": 40.742324, + "altM": 404 + }, + { + "t": 1789766946000, + "lon": -73.985405, + "lat": 40.742303, + "altM": 404 + }, + { + "t": 1789766947000, + "lon": -73.984873, + "lat": 40.742219, + "altM": 404 + }, + { + "t": 1789766948000, + "lon": -73.984389, + "lat": 40.742254, + "altM": 404 + }, + { + "t": 1789766949000, + "lon": -73.983895, + "lat": 40.742234, + "altM": 404 + }, + { + "t": 1789766950000, + "lon": -73.983458, + "lat": 40.742341, + "altM": 404 + }, + { + "t": 1789766951000, + "lon": -73.982945, + "lat": 40.742416, + "altM": 404 + }, + { + "t": 1789766952000, + "lon": -73.982485, + "lat": 40.742464, + "altM": 404 + }, + { "t": 1789766953000, "lon": -73.98198, "lat": 40.742662, "altM": 404 }, + { + "t": 1789766954000, + "lon": -73.981616, + "lat": 40.742822, + "altM": 404 + }, + { + "t": 1789766955000, + "lon": -73.981216, + "lat": 40.742948, + "altM": 404 + }, + { + "t": 1789766956000, + "lon": -73.980767, + "lat": 40.743175, + "altM": 404 + }, + { + "t": 1789766957000, + "lon": -73.980477, + "lat": 40.743403, + "altM": 404 + }, + { "t": 1789766958000, "lon": -73.9801, "lat": 40.743565, "altM": 404 }, + { + "t": 1789766959000, + "lon": -73.979719, + "lat": 40.743837, + "altM": 404 + }, + { "t": 1789766960000, "lon": -73.979516, "lat": 40.74403, "altM": 404 }, + { + "t": 1789766961000, + "lon": -73.979082, + "lat": 40.744346, + "altM": 404 + }, + { + "t": 1789766962000, + "lon": -73.978943, + "lat": 40.744545, + "altM": 404 + }, + { + "t": 1789766963000, + "lon": -73.978792, + "lat": 40.744807, + "altM": 404 + }, + { + "t": 1789766964000, + "lon": -73.978453, + "lat": 40.745171, + "altM": 404 + }, + { + "t": 1789766965000, + "lon": -73.978357, + "lat": 40.745459, + "altM": 404 + }, + { + "t": 1789766966000, + "lon": -73.978166, + "lat": 40.745702, + "altM": 404 + }, + { + "t": 1789766967000, + "lon": -73.978035, + "lat": 40.745988, + "altM": 404 + }, + { "t": 1789766968000, "lon": -73.977934, "lat": 40.74628, "altM": 404 }, + { + "t": 1789766969000, + "lon": -73.977929, + "lat": 40.746618, + "altM": 404 + }, + { + "t": 1789766970000, + "lon": -73.977819, + "lat": 40.746848, + "altM": 404 + }, + { + "t": 1789766971000, + "lon": -73.977782, + "lat": 40.747163, + "altM": 404 + }, + { + "t": 1789766972000, + "lon": -73.977849, + "lat": 40.747471, + "altM": 404 + }, + { + "t": 1789766973000, + "lon": -73.977734, + "lat": 40.747755, + "altM": 404 + }, + { + "t": 1789766974000, + "lon": -73.977897, + "lat": 40.748058, + "altM": 404 + }, + { + "t": 1789766975000, + "lon": -73.977887, + "lat": 40.748277, + "altM": 404 + }, + { + "t": 1789766976000, + "lon": -73.977947, + "lat": 40.748579, + "altM": 404 + }, + { + "t": 1789766977000, + "lon": -73.978026, + "lat": 40.748898, + "altM": 404 + }, + { + "t": 1789766978000, + "lon": -73.978085, + "lat": 40.749155, + "altM": 404 + }, + { + "t": 1789766979000, + "lon": -73.978338, + "lat": 40.749342, + "altM": 404 + }, + { + "t": 1789766980000, + "lon": -73.978432, + "lat": 40.749615, + "altM": 404 + }, + { + "t": 1789766981000, + "lon": -73.978492, + "lat": 40.749886, + "altM": 404 + }, + { + "t": 1789766982000, + "lon": -73.978728, + "lat": 40.750118, + "altM": 404 + }, + { + "t": 1789766983000, + "lon": -73.978897, + "lat": 40.750305, + "altM": 404 + }, + { + "t": 1789766984000, + "lon": -73.978988, + "lat": 40.750513, + "altM": 404 + }, + { + "t": 1789766985000, + "lon": -73.979269, + "lat": 40.750653, + "altM": 404 + }, + { + "t": 1789766986000, + "lon": -73.979608, + "lat": 40.750901, + "altM": 404 + }, + { + "t": 1789766987000, + "lon": -73.979721, + "lat": 40.751131, + "altM": 404 + }, + { + "t": 1789766988000, + "lon": -73.979972, + "lat": 40.751332, + "altM": 404 + }, + { + "t": 1789766989000, + "lon": -73.980253, + "lat": 40.751469, + "altM": 404 + }, + { + "t": 1789766990000, + "lon": -73.980497, + "lat": 40.751695, + "altM": 404 + }, + { "t": 1789766991000, "lon": -73.98076, "lat": 40.751839, "altM": 404 }, + { + "t": 1789766992000, + "lon": -73.981038, + "lat": 40.751893, + "altM": 404 + }, + { "t": 1789766993000, "lon": -73.981379, "lat": 40.752, "altM": 404 }, + { + "t": 1789766994000, + "lon": -73.981672, + "lat": 40.752209, + "altM": 404 + }, + { + "t": 1789766995000, + "lon": -73.981862, + "lat": 40.752297, + "altM": 404 + }, + { + "t": 1789766996000, + "lon": -73.982143, + "lat": 40.752361, + "altM": 404 + }, + { + "t": 1789766997000, + "lon": -73.982517, + "lat": 40.752512, + "altM": 396 + }, + { + "t": 1789766998000, + "lon": -73.982825, + "lat": 40.752568, + "altM": 396 + }, + { + "t": 1789766999000, + "lon": -73.983109, + "lat": 40.752623, + "altM": 396 + }, + { + "t": 1789767000000, + "lon": -73.983413, + "lat": 40.752668, + "altM": 396 + }, + { + "t": 1789767001000, + "lon": -73.983827, + "lat": 40.752681, + "altM": 396 + }, + { + "t": 1789767002000, + "lon": -73.984059, + "lat": 40.752796, + "altM": 396 + }, + { + "t": 1789767003000, + "lon": -73.984381, + "lat": 40.752793, + "altM": 396 + }, + { + "t": 1789767004000, + "lon": -73.984782, + "lat": 40.752727, + "altM": 396 + }, + { + "t": 1789767005000, + "lon": -73.985103, + "lat": 40.752709, + "altM": 396 + }, + { + "t": 1789767006000, + "lon": -73.985439, + "lat": 40.752777, + "altM": 396 + }, + { + "t": 1789767007000, + "lon": -73.985714, + "lat": 40.752703, + "altM": 396 + }, + { + "t": 1789767008000, + "lon": -73.986206, + "lat": 40.752668, + "altM": 396 + }, + { + "t": 1789767009000, + "lon": -73.986464, + "lat": 40.752653, + "altM": 396 + }, + { + "t": 1789767010000, + "lon": -73.986709, + "lat": 40.752502, + "altM": 396 + }, + { + "t": 1789767011000, + "lon": -73.987144, + "lat": 40.752409, + "altM": 396 + }, + { + "t": 1789767012000, + "lon": -73.987459, + "lat": 40.752336, + "altM": 396 + }, + { + "t": 1789767013000, + "lon": -73.987769, + "lat": 40.752278, + "altM": 396 + }, + { + "t": 1789767014000, + "lon": -73.987981, + "lat": 40.752132, + "altM": 396 + }, + { + "t": 1789767015000, + "lon": -73.988326, + "lat": 40.752033, + "altM": 396 + }, + { + "t": 1789767016000, + "lon": -73.988597, + "lat": 40.751764, + "altM": 396 + }, + { + "t": 1789767017000, + "lon": -73.988948, + "lat": 40.751606, + "altM": 396 + }, + { + "t": 1789767018000, + "lon": -73.989208, + "lat": 40.751483, + "altM": 396 + }, + { + "t": 1789767019000, + "lon": -73.989496, + "lat": 40.751273, + "altM": 396 + }, + { + "t": 1789767020000, + "lon": -73.989654, + "lat": 40.750976, + "altM": 396 + }, + { + "t": 1789767021000, + "lon": -73.990018, + "lat": 40.750766, + "altM": 396 + }, + { + "t": 1789767022000, + "lon": -73.990202, + "lat": 40.750627, + "altM": 396 + }, + { + "t": 1789767023000, + "lon": -73.990386, + "lat": 40.750299, + "altM": 396 + }, + { + "t": 1789767024000, + "lon": -73.990615, + "lat": 40.749999, + "altM": 396 + }, + { + "t": 1789767025000, + "lon": -73.990785, + "lat": 40.749823, + "altM": 396 + }, + { "t": 1789767026000, "lon": -73.99091, "lat": 40.7495, "altM": 396 }, + { "t": 1789767027000, "lon": -73.990947, "lat": 40.74921, "altM": 396 }, + { + "t": 1789767028000, + "lon": -73.991055, + "lat": 40.748862, + "altM": 396 + }, + { + "t": 1789767029000, + "lon": -73.991182, + "lat": 40.748552, + "altM": 396 + }, + { "t": 1789767030000, "lon": -73.991253, "lat": 40.74823, "altM": 396 }, + { + "t": 1789767031000, + "lon": -73.991321, + "lat": 40.747978, + "altM": 396 + }, + { + "t": 1789767032000, + "lon": -73.991253, + "lat": 40.747574, + "altM": 396 + }, + { + "t": 1789767033000, + "lon": -73.991233, + "lat": 40.747298, + "altM": 389 + }, + { + "t": 1789767034000, + "lon": -73.991159, + "lat": 40.746873, + "altM": 389 + }, + { "t": 1789767035000, "lon": -73.991153, "lat": 40.74655, "altM": 389 }, + { + "t": 1789767036000, + "lon": -73.990967, + "lat": 40.746278, + "altM": 389 + }, + { + "t": 1789767037000, + "lon": -73.990805, + "lat": 40.745937, + "altM": 389 + }, + { "t": 1789767038000, "lon": -73.990615, "lat": 40.74562, "altM": 389 }, + { + "t": 1789767039000, + "lon": -73.990354, + "lat": 40.745207, + "altM": 389 + }, + { "t": 1789767040000, "lon": -73.9901, "lat": 40.744993, "altM": 389 }, + { + "t": 1789767041000, + "lon": -73.989893, + "lat": 40.744631, + "altM": 389 + }, + { "t": 1789767042000, "lon": -73.98942, "lat": 40.744413, "altM": 389 }, + { + "t": 1789767043000, + "lon": -73.989259, + "lat": 40.744119, + "altM": 389 + }, + { "t": 1789767044000, "lon": -73.98884, "lat": 40.743814, "altM": 389 }, + { + "t": 1789767045000, + "lon": -73.988425, + "lat": 40.743622, + "altM": 389 + }, + { + "t": 1789767046000, + "lon": -73.987995, + "lat": 40.743468, + "altM": 389 + }, + { + "t": 1789767047000, + "lon": -73.987528, + "lat": 40.743239, + "altM": 389 + }, + { + "t": 1789767048000, + "lon": -73.987075, + "lat": 40.743055, + "altM": 389 + }, + { + "t": 1789767049000, + "lon": -73.986696, + "lat": 40.742912, + "altM": 389 + }, + { + "t": 1789767050000, + "lon": -73.986166, + "lat": 40.742921, + "altM": 389 + }, + { + "t": 1789767051000, + "lon": -73.985708, + "lat": 40.742791, + "altM": 389 + }, + { "t": 1789767052000, "lon": -73.985274, "lat": 40.74275, "altM": 389 }, + { + "t": 1789767053000, + "lon": -73.984629, + "lat": 40.742746, + "altM": 389 + }, + { + "t": 1789767054000, + "lon": -73.984214, + "lat": 40.742745, + "altM": 389 + }, + { + "t": 1789767055000, + "lon": -73.983775, + "lat": 40.742773, + "altM": 389 + }, + { "t": 1789767056000, "lon": -73.98319, "lat": 40.742899, "altM": 389 }, + { + "t": 1789767057000, + "lon": -73.982695, + "lat": 40.742975, + "altM": 389 + }, + { + "t": 1789767058000, + "lon": -73.982345, + "lat": 40.743155, + "altM": 389 + }, + { + "t": 1789767059000, + "lon": -73.981924, + "lat": 40.743262, + "altM": 389 + }, + { + "t": 1789767060000, + "lon": -73.981468, + "lat": 40.743459, + "altM": 389 + }, + { + "t": 1789767061000, + "lon": -73.981123, + "lat": 40.743604, + "altM": 389 + }, + { + "t": 1789767062000, + "lon": -73.980816, + "lat": 40.743801, + "altM": 389 + }, + { + "t": 1789767063000, + "lon": -73.980487, + "lat": 40.744072, + "altM": 389 + }, + { + "t": 1789767064000, + "lon": -73.980164, + "lat": 40.744344, + "altM": 389 + }, + { + "t": 1789767065000, + "lon": -73.979862, + "lat": 40.744622, + "altM": 389 + }, + { + "t": 1789767066000, + "lon": -73.979592, + "lat": 40.744862, + "altM": 389 + }, + { + "t": 1789767067000, + "lon": -73.979328, + "lat": 40.745241, + "altM": 389 + }, + { "t": 1789767068000, "lon": -73.97914, "lat": 40.745349, "altM": 389 }, + { "t": 1789767069000, "lon": -73.978825, "lat": 40.74568, "altM": 389 }, + { + "t": 1789767070000, + "lon": -73.978824, + "lat": 40.745973, + "altM": 389 + }, + { + "t": 1789767071000, + "lon": -73.978742, + "lat": 40.746303, + "altM": 389 + }, + { + "t": 1789767072000, + "lon": -73.978708, + "lat": 40.746554, + "altM": 389 + }, + { + "t": 1789767073000, + "lon": -73.978527, + "lat": 40.746825, + "altM": 389 + }, + { + "t": 1789767074000, + "lon": -73.978478, + "lat": 40.747159, + "altM": 389 + }, + { + "t": 1789767075000, + "lon": -73.978496, + "lat": 40.747465, + "altM": 389 + }, + { "t": 1789767076000, "lon": -73.978465, "lat": 40.74772, "altM": 389 }, + { "t": 1789767077000, "lon": -73.97859, "lat": 40.748044, "altM": 389 }, + { "t": 1789767078000, "lon": -73.97855, "lat": 40.748219, "altM": 389 }, + { + "t": 1789767079000, + "lon": -73.978612, + "lat": 40.748498, + "altM": 389 + }, + { + "t": 1789767080000, + "lon": -73.978722, + "lat": 40.748816, + "altM": 389 + }, + { + "t": 1789767081000, + "lon": -73.978916, + "lat": 40.749086, + "altM": 389 + }, + { + "t": 1789767082000, + "lon": -73.979013, + "lat": 40.749273, + "altM": 389 + }, + { "t": 1789767083000, "lon": -73.97913, "lat": 40.749607, "altM": 389 }, + { "t": 1789767084000, "lon": -73.979293, "lat": 40.74979, "altM": 389 }, + { + "t": 1789767085000, + "lon": -73.979381, + "lat": 40.750037, + "altM": 389 + }, + { + "t": 1789767086000, + "lon": -73.979622, + "lat": 40.750282, + "altM": 389 + }, + { + "t": 1789767087000, + "lon": -73.979874, + "lat": 40.750461, + "altM": 389 + }, + { + "t": 1789767088000, + "lon": -73.980009, + "lat": 40.750774, + "altM": 389 + }, + { + "t": 1789767089000, + "lon": -73.980271, + "lat": 40.750847, + "altM": 389 + }, + { + "t": 1789767090000, + "lon": -73.980494, + "lat": 40.751071, + "altM": 389 + }, + { + "t": 1789767091000, + "lon": -73.980738, + "lat": 40.751224, + "altM": 389 + }, + { + "t": 1789767092000, + "lon": -73.980954, + "lat": 40.751399, + "altM": 389 + }, + { + "t": 1789767093000, + "lon": -73.981388, + "lat": 40.751522, + "altM": 389 + }, + { + "t": 1789767094000, + "lon": -73.981578, + "lat": 40.751662, + "altM": 389 + }, + { + "t": 1789767095000, + "lon": -73.981819, + "lat": 40.751778, + "altM": 389 + }, + { + "t": 1789767096000, + "lon": -73.982134, + "lat": 40.751854, + "altM": 389 + }, + { + "t": 1789767097000, + "lon": -73.982396, + "lat": 40.751964, + "altM": 389 + }, + { + "t": 1789767098000, + "lon": -73.982675, + "lat": 40.752069, + "altM": 389 + }, + { + "t": 1789767099000, + "lon": -73.983041, + "lat": 40.752168, + "altM": 389 + }, + { "t": 1789767100000, "lon": -73.983391, "lat": 40.75225, "altM": 389 }, + { + "t": 1789767101000, + "lon": -73.983697, + "lat": 40.752302, + "altM": 389 + }, + { "t": 1789767102000, "lon": -73.98397, "lat": 40.752361, "altM": 389 }, + { + "t": 1789767103000, + "lon": -73.984392, + "lat": 40.752365, + "altM": 389 + }, + { "t": 1789767104000, "lon": -73.984652, "lat": 40.75241, "altM": 389 }, + { "t": 1789767105000, "lon": -73.985024, "lat": 40.75239, "altM": 389 }, + { + "t": 1789767106000, + "lon": -73.985366, + "lat": 40.752398, + "altM": 389 + }, + { + "t": 1789767107000, + "lon": -73.985694, + "lat": 40.752324, + "altM": 389 + }, + { + "t": 1789767108000, + "lon": -73.985987, + "lat": 40.752273, + "altM": 389 + }, + { "t": 1789767109000, "lon": -73.98631, "lat": 40.752224, "altM": 389 }, + { + "t": 1789767110000, + "lon": -73.986629, + "lat": 40.752188, + "altM": 389 + }, + { + "t": 1789767111000, + "lon": -73.987024, + "lat": 40.752089, + "altM": 389 + }, + { + "t": 1789767112000, + "lon": -73.987396, + "lat": 40.752095, + "altM": 389 + }, + { + "t": 1789767113000, + "lon": -73.987633, + "lat": 40.751949, + "altM": 389 + }, + { + "t": 1789767114000, + "lon": -73.987946, + "lat": 40.751758, + "altM": 389 + }, + { + "t": 1789767115000, + "lon": -73.988216, + "lat": 40.751677, + "altM": 389 + }, + { + "t": 1789767116000, + "lon": -73.988699, + "lat": 40.751464, + "altM": 389 + }, + { + "t": 1789767117000, + "lon": -73.988772, + "lat": 40.751292, + "altM": 396 + }, + { "t": 1789767118000, "lon": -73.989121, "lat": 40.7511, "altM": 396 }, + { "t": 1789767119000, "lon": -73.98948, "lat": 40.750946, "altM": 396 }, + { + "t": 1789767120000, + "lon": -73.989679, + "lat": 40.750715, + "altM": 396 + }, + { + "t": 1789767121000, + "lon": -73.989855, + "lat": 40.750526, + "altM": 396 + }, + { + "t": 1789767122000, + "lon": -73.990037, + "lat": 40.750296, + "altM": 396 + }, + { "t": 1789767123000, "lon": -73.990277, "lat": 40.74999, "altM": 396 }, + { + "t": 1789767124000, + "lon": -73.990574, + "lat": 40.749746, + "altM": 396 + }, + { "t": 1789767125000, "lon": -73.990646, "lat": 40.74951, "altM": 396 }, + { + "t": 1789767126000, + "lon": -73.990807, + "lat": 40.749142, + "altM": 396 + }, + { + "t": 1789767127000, + "lon": -73.990857, + "lat": 40.748858, + "altM": 396 + }, + { "t": 1789767128000, "lon": -73.990967, "lat": 40.74852, "altM": 396 }, + { + "t": 1789767129000, + "lon": -73.991034, + "lat": 40.748287, + "altM": 396 + }, + { + "t": 1789767130000, + "lon": -73.991101, + "lat": 40.747952, + "altM": 396 + }, + { + "t": 1789767131000, + "lon": -73.991177, + "lat": 40.747571, + "altM": 396 + }, + { "t": 1789767132000, "lon": -73.991, "lat": 40.747291, "altM": 396 }, + { + "t": 1789767133000, + "lon": -73.991085, + "lat": 40.746903, + "altM": 396 + }, + { + "t": 1789767134000, + "lon": -73.990939, + "lat": 40.746621, + "altM": 396 + }, + { "t": 1789767135000, "lon": -73.990936, "lat": 40.74626, "altM": 396 }, + { + "t": 1789767136000, + "lon": -73.990688, + "lat": 40.745862, + "altM": 396 + }, + { + "t": 1789767137000, + "lon": -73.990606, + "lat": 40.745631, + "altM": 396 + }, + { + "t": 1789767138000, + "lon": -73.990339, + "lat": 40.745237, + "altM": 396 + }, + { + "t": 1789767139000, + "lon": -73.990132, + "lat": 40.744978, + "altM": 396 + }, + { + "t": 1789767140000, + "lon": -73.989835, + "lat": 40.744643, + "altM": 396 + }, + { + "t": 1789767141000, + "lon": -73.989538, + "lat": 40.744387, + "altM": 396 + }, + { "t": 1789767142000, "lon": -73.989169, "lat": 40.74409, "altM": 396 }, + { + "t": 1789767143000, + "lon": -73.988799, + "lat": 40.743834, + "altM": 396 + }, + { + "t": 1789767144000, + "lon": -73.988396, + "lat": 40.743587, + "altM": 396 + }, + { + "t": 1789767145000, + "lon": -73.988022, + "lat": 40.743478, + "altM": 396 + }, + { + "t": 1789767146000, + "lon": -73.987553, + "lat": 40.743233, + "altM": 396 + }, + { + "t": 1789767147000, + "lon": -73.987113, + "lat": 40.743055, + "altM": 396 + }, + { "t": 1789767148000, "lon": -73.986627, "lat": 40.74296, "altM": 396 }, + { + "t": 1789767149000, + "lon": -73.986186, + "lat": 40.742781, + "altM": 396 + }, + { + "t": 1789767150000, + "lon": -73.985655, + "lat": 40.742675, + "altM": 396 + }, + { + "t": 1789767151000, + "lon": -73.985184, + "lat": 40.742642, + "altM": 396 + }, + { "t": 1789767152000, "lon": -73.984699, "lat": 40.74263, "altM": 404 }, + { + "t": 1789767153000, + "lon": -73.984202, + "lat": 40.742647, + "altM": 404 + }, + { + "t": 1789767154000, + "lon": -73.983711, + "lat": 40.742644, + "altM": 404 + }, + { + "t": 1789767155000, + "lon": -73.983238, + "lat": 40.742742, + "altM": 404 + }, + { + "t": 1789767156000, + "lon": -73.982837, + "lat": 40.742856, + "altM": 404 + }, + { + "t": 1789767157000, + "lon": -73.982304, + "lat": 40.742973, + "altM": 404 + }, + { + "t": 1789767158000, + "lon": -73.981808, + "lat": 40.743077, + "altM": 404 + }, + { + "t": 1789767159000, + "lon": -73.981501, + "lat": 40.743234, + "altM": 404 + }, + { + "t": 1789767160000, + "lon": -73.981087, + "lat": 40.743523, + "altM": 404 + }, + { + "t": 1789767161000, + "lon": -73.980585, + "lat": 40.743689, + "altM": 404 + }, + { + "t": 1789767162000, + "lon": -73.980359, + "lat": 40.743862, + "altM": 404 + }, + { "t": 1789767163000, "lon": -73.97995, "lat": 40.744064, "altM": 404 }, + { + "t": 1789767164000, + "lon": -73.979656, + "lat": 40.744295, + "altM": 404 + }, + { + "t": 1789767165000, + "lon": -73.979327, + "lat": 40.744544, + "altM": 404 + }, + { + "t": 1789767166000, + "lon": -73.979188, + "lat": 40.744845, + "altM": 404 + }, + { "t": 1789767167000, "lon": -73.978947, "lat": 40.74518, "altM": 404 }, + { + "t": 1789767168000, + "lon": -73.978799, + "lat": 40.745396, + "altM": 404 + }, + { + "t": 1789767169000, + "lon": -73.978637, + "lat": 40.745664, + "altM": 404 + }, + { "t": 1789767170000, "lon": -73.97838, "lat": 40.745987, "altM": 404 }, + { + "t": 1789767171000, + "lon": -73.978302, + "lat": 40.746271, + "altM": 404 + }, + { + "t": 1789767172000, + "lon": -73.978234, + "lat": 40.746579, + "altM": 404 + }, + { + "t": 1789767173000, + "lon": -73.978075, + "lat": 40.746885, + "altM": 404 + }, + { + "t": 1789767174000, + "lon": -73.978166, + "lat": 40.747118, + "altM": 404 + }, + { + "t": 1789767175000, + "lon": -73.978085, + "lat": 40.747427, + "altM": 404 + }, + { + "t": 1789767176000, + "lon": -73.978106, + "lat": 40.747743, + "altM": 404 + }, + { + "t": 1789767177000, + "lon": -73.978106, + "lat": 40.747964, + "altM": 404 + }, + { + "t": 1789767178000, + "lon": -73.978105, + "lat": 40.748335, + "altM": 404 + }, + { + "t": 1789767179000, + "lon": -73.978133, + "lat": 40.748583, + "altM": 404 + }, + { + "t": 1789767180000, + "lon": -73.978267, + "lat": 40.748806, + "altM": 404 + }, + { "t": 1789767181000, "lon": -73.978319, "lat": 40.74914, "altM": 404 }, + { + "t": 1789767182000, + "lon": -73.978505, + "lat": 40.749296, + "altM": 404 + }, + { + "t": 1789767183000, + "lon": -73.978599, + "lat": 40.749617, + "altM": 404 + }, + { + "t": 1789767184000, + "lon": -73.978675, + "lat": 40.749818, + "altM": 404 + }, + { + "t": 1789767185000, + "lon": -73.978906, + "lat": 40.750125, + "altM": 404 + }, + { "t": 1789767186000, "lon": -73.97907, "lat": 40.750291, "altM": 404 }, + { "t": 1789767187000, "lon": -73.979203, "lat": 40.75058, "altM": 404 }, + { + "t": 1789767188000, + "lon": -73.979497, + "lat": 40.750803, + "altM": 404 + }, + { + "t": 1789767189000, + "lon": -73.979642, + "lat": 40.750998, + "altM": 404 + }, + { + "t": 1789767190000, + "lon": -73.979828, + "lat": 40.751157, + "altM": 404 + }, + { "t": 1789767191000, "lon": -73.98007, "lat": 40.751313, "altM": 404 }, + { "t": 1789767192000, "lon": -73.980277, "lat": 40.75147, "altM": 404 }, + { + "t": 1789767193000, + "lon": -73.980588, + "lat": 40.751661, + "altM": 404 + }, + { + "t": 1789767194000, + "lon": -73.980875, + "lat": 40.751855, + "altM": 404 + }, + { + "t": 1789767195000, + "lon": -73.981107, + "lat": 40.752044, + "altM": 404 + }, + { + "t": 1789767196000, + "lon": -73.981355, + "lat": 40.752184, + "altM": 404 + }, + { + "t": 1789767197000, + "lon": -73.981583, + "lat": 40.752307, + "altM": 404 + }, + { + "t": 1789767198000, + "lon": -73.981996, + "lat": 40.752386, + "altM": 404 + }, + { + "t": 1789767199000, + "lon": -73.982304, + "lat": 40.752478, + "altM": 404 + }, + { + "t": 1789767200000, + "lon": -73.982564, + "lat": 40.752581, + "altM": 404 + }, + { + "t": 1789767201000, + "lon": -73.982856, + "lat": 40.752681, + "altM": 404 + }, + { + "t": 1789767202000, + "lon": -73.983179, + "lat": 40.752729, + "altM": 404 + }, + { + "t": 1789767203000, + "lon": -73.983447, + "lat": 40.752752, + "altM": 404 + }, + { + "t": 1789767204000, + "lon": -73.983847, + "lat": 40.752881, + "altM": 404 + }, + { + "t": 1789767205000, + "lon": -73.984126, + "lat": 40.752904, + "altM": 404 + }, + { + "t": 1789767206000, + "lon": -73.984414, + "lat": 40.752818, + "altM": 404 + }, + { + "t": 1789767207000, + "lon": -73.984816, + "lat": 40.752975, + "altM": 404 + }, + { + "t": 1789767208000, + "lon": -73.985209, + "lat": 40.752968, + "altM": 404 + }, + { + "t": 1789767209000, + "lon": -73.985443, + "lat": 40.752881, + "altM": 404 + }, + { + "t": 1789767210000, + "lon": -73.985809, + "lat": 40.752892, + "altM": 404 + }, + { "t": 1789767211000, "lon": -73.98615, "lat": 40.75287, "altM": 404 }, + { + "t": 1789767212000, + "lon": -73.986534, + "lat": 40.752801, + "altM": 404 + }, + { + "t": 1789767213000, + "lon": -73.986808, + "lat": 40.752712, + "altM": 404 + }, + { + "t": 1789767214000, + "lon": -73.987083, + "lat": 40.752645, + "altM": 404 + }, + { + "t": 1789767215000, + "lon": -73.987407, + "lat": 40.752554, + "altM": 404 + }, + { + "t": 1789767216000, + "lon": -73.987709, + "lat": 40.752406, + "altM": 404 + }, + { + "t": 1789767217000, + "lon": -73.988095, + "lat": 40.752417, + "altM": 404 + }, + { + "t": 1789767218000, + "lon": -73.988383, + "lat": 40.752219, + "altM": 404 + }, + { + "t": 1789767219000, + "lon": -73.988786, + "lat": 40.752052, + "altM": 404 + }, + { "t": 1789767220000, "lon": -73.98901, "lat": 40.751872, "altM": 404 }, + { "t": 1789767221000, "lon": -73.98928, "lat": 40.751703, "altM": 404 }, + { + "t": 1789767222000, + "lon": -73.989542, + "lat": 40.751517, + "altM": 404 + }, + { + "t": 1789767223000, + "lon": -73.989929, + "lat": 40.751425, + "altM": 404 + }, + { + "t": 1789767224000, + "lon": -73.990096, + "lat": 40.751136, + "altM": 404 + }, + { + "t": 1789767225000, + "lon": -73.990262, + "lat": 40.750907, + "altM": 404 + }, + { + "t": 1789767226000, + "lon": -73.990613, + "lat": 40.750786, + "altM": 404 + }, + { "t": 1789767227000, "lon": -73.9908, "lat": 40.750447, "altM": 404 }, + { + "t": 1789767228000, + "lon": -73.991023, + "lat": 40.750202, + "altM": 404 + }, + { + "t": 1789767229000, + "lon": -73.991111, + "lat": 40.749939, + "altM": 404 + }, + { + "t": 1789767230000, + "lon": -73.991286, + "lat": 40.749601, + "altM": 396 + }, + { + "t": 1789767231000, + "lon": -73.991519, + "lat": 40.749348, + "altM": 396 + }, + { + "t": 1789767232000, + "lon": -73.991674, + "lat": 40.749068, + "altM": 396 + }, + { + "t": 1789767233000, + "lon": -73.991685, + "lat": 40.748719, + "altM": 396 + }, + { "t": 1789767234000, "lon": -73.991775, "lat": 40.74833, "altM": 396 }, + { + "t": 1789767235000, + "lon": -73.991851, + "lat": 40.748069, + "altM": 396 + }, + { + "t": 1789767236000, + "lon": -73.991766, + "lat": 40.747711, + "altM": 396 + }, + { + "t": 1789767237000, + "lon": -73.991811, + "lat": 40.747427, + "altM": 396 + }, + { + "t": 1789767238000, + "lon": -73.991796, + "lat": 40.747111, + "altM": 396 + }, + { + "t": 1789767239000, + "lon": -73.991675, + "lat": 40.746758, + "altM": 396 + }, + { + "t": 1789767240000, + "lon": -73.991662, + "lat": 40.746458, + "altM": 396 + }, + { + "t": 1789767241000, + "lon": -73.991465, + "lat": 40.746074, + "altM": 396 + }, + { + "t": 1789767242000, + "lon": -73.991282, + "lat": 40.745729, + "altM": 396 + }, + { + "t": 1789767243000, + "lon": -73.991035, + "lat": 40.745414, + "altM": 396 + }, + { + "t": 1789767244000, + "lon": -73.990953, + "lat": 40.745067, + "altM": 396 + }, + { + "t": 1789767245000, + "lon": -73.990819, + "lat": 40.744777, + "altM": 396 + }, + { + "t": 1789767246000, + "lon": -73.990378, + "lat": 40.744433, + "altM": 396 + }, + { + "t": 1789767247000, + "lon": -73.990101, + "lat": 40.744178, + "altM": 396 + }, + { "t": 1789767248000, "lon": -73.98974, "lat": 40.743921, "altM": 396 }, + { + "t": 1789767249000, + "lon": -73.989508, + "lat": 40.743602, + "altM": 396 + }, + { "t": 1789767250000, "lon": -73.98907, "lat": 40.743376, "altM": 396 }, + { + "t": 1789767251000, + "lon": -73.988559, + "lat": 40.743123, + "altM": 396 + }, + { + "t": 1789767252000, + "lon": -73.988199, + "lat": 40.742951, + "altM": 396 + }, + { + "t": 1789767253000, + "lon": -73.987753, + "lat": 40.742778, + "altM": 396 + }, + { "t": 1789767254000, "lon": -73.987241, "lat": 40.74267, "altM": 396 }, + { "t": 1789767255000, "lon": -73.986828, "lat": 40.74252, "altM": 396 }, + { "t": 1789767256000, "lon": -73.986358, "lat": 40.7425, "altM": 396 }, + { + "t": 1789767257000, + "lon": -73.985915, + "lat": 40.742263, + "altM": 396 + }, + { "t": 1789767258000, "lon": -73.985327, "lat": 40.74231, "altM": 396 }, + { + "t": 1789767259000, + "lon": -73.984816, + "lat": 40.742264, + "altM": 396 + }, + { "t": 1789767260000, "lon": -73.984379, "lat": 40.74224, "altM": 396 }, + { + "t": 1789767261000, + "lon": -73.983882, + "lat": 40.742272, + "altM": 396 + }, + { + "t": 1789767262000, + "lon": -73.983469, + "lat": 40.742414, + "altM": 396 + }, + { + "t": 1789767263000, + "lon": -73.982917, + "lat": 40.742455, + "altM": 396 + }, + { "t": 1789767264000, "lon": -73.98247, "lat": 40.742474, "altM": 396 }, + { "t": 1789767265000, "lon": -73.982026, "lat": 40.7427, "altM": 396 }, + { + "t": 1789767266000, + "lon": -73.981596, + "lat": 40.742862, + "altM": 396 + }, + { + "t": 1789767267000, + "lon": -73.981195, + "lat": 40.742957, + "altM": 396 + }, + { + "t": 1789767268000, + "lon": -73.980801, + "lat": 40.743243, + "altM": 389 + }, + { + "t": 1789767269000, + "lon": -73.980455, + "lat": 40.743324, + "altM": 389 + }, + { + "t": 1789767270000, + "lon": -73.980125, + "lat": 40.743505, + "altM": 389 + }, + { + "t": 1789767271000, + "lon": -73.979798, + "lat": 40.743826, + "altM": 389 + }, + { + "t": 1789767272000, + "lon": -73.979451, + "lat": 40.744124, + "altM": 389 + }, + { + "t": 1789767273000, + "lon": -73.979231, + "lat": 40.744383, + "altM": 389 + }, + { "t": 1789767274000, "lon": -73.97891, "lat": 40.744583, "altM": 389 }, + { + "t": 1789767275000, + "lon": -73.978758, + "lat": 40.744843, + "altM": 389 + }, + { + "t": 1789767276000, + "lon": -73.978525, + "lat": 40.745167, + "altM": 389 + }, + { + "t": 1789767277000, + "lon": -73.978344, + "lat": 40.745486, + "altM": 389 + }, + { + "t": 1789767278000, + "lon": -73.978297, + "lat": 40.745731, + "altM": 389 + }, + { + "t": 1789767279000, + "lon": -73.978215, + "lat": 40.746045, + "altM": 389 + }, + { + "t": 1789767280000, + "lon": -73.978071, + "lat": 40.746363, + "altM": 389 + }, + { + "t": 1789767281000, + "lon": -73.977891, + "lat": 40.746638, + "altM": 389 + }, + { + "t": 1789767282000, + "lon": -73.978008, + "lat": 40.746951, + "altM": 389 + }, + { "t": 1789767283000, "lon": -73.977877, "lat": 40.74724, "altM": 389 }, + { + "t": 1789767284000, + "lon": -73.977933, + "lat": 40.747507, + "altM": 389 + }, + { + "t": 1789767285000, + "lon": -73.977839, + "lat": 40.747796, + "altM": 389 + }, + { + "t": 1789767286000, + "lon": -73.977947, + "lat": 40.748054, + "altM": 389 + }, + { + "t": 1789767287000, + "lon": -73.978047, + "lat": 40.748316, + "altM": 389 + }, + { + "t": 1789767288000, + "lon": -73.978046, + "lat": 40.748612, + "altM": 389 + }, + { + "t": 1789767289000, + "lon": -73.978109, + "lat": 40.748885, + "altM": 389 + }, + { + "t": 1789767290000, + "lon": -73.978246, + "lat": 40.749097, + "altM": 389 + }, + { "t": 1789767291000, "lon": -73.97834, "lat": 40.749487, "altM": 389 }, + { + "t": 1789767292000, + "lon": -73.978564, + "lat": 40.749706, + "altM": 389 + }, + { + "t": 1789767293000, + "lon": -73.978699, + "lat": 40.749901, + "altM": 389 + }, + { + "t": 1789767294000, + "lon": -73.978941, + "lat": 40.750158, + "altM": 389 + }, + { + "t": 1789767295000, + "lon": -73.979001, + "lat": 40.750376, + "altM": 389 + }, + { + "t": 1789767296000, + "lon": -73.979101, + "lat": 40.750544, + "altM": 389 + }, + { "t": 1789767297000, "lon": -73.97942, "lat": 40.750748, "altM": 389 }, + { + "t": 1789767298000, + "lon": -73.979739, + "lat": 40.751072, + "altM": 389 + }, + { + "t": 1789767299000, + "lon": -73.979892, + "lat": 40.751152, + "altM": 389 + }, + { + "t": 1789767300000, + "lon": -73.980136, + "lat": 40.751287, + "altM": 389 + }, + { + "t": 1789767301000, + "lon": -73.980342, + "lat": 40.751445, + "altM": 389 + }, + { + "t": 1789767302000, + "lon": -73.980561, + "lat": 40.751639, + "altM": 389 + }, + { + "t": 1789767303000, + "lon": -73.980982, + "lat": 40.751791, + "altM": 389 + }, + { + "t": 1789767304000, + "lon": -73.981261, + "lat": 40.751918, + "altM": 389 + }, + { + "t": 1789767305000, + "lon": -73.981482, + "lat": 40.752019, + "altM": 389 + }, + { + "t": 1789767306000, + "lon": -73.981808, + "lat": 40.752142, + "altM": 389 + }, + { "t": 1789767307000, "lon": -73.982154, "lat": 40.75234, "altM": 389 }, + { "t": 1789767308000, "lon": -73.98241, "lat": 40.752394, "altM": 389 }, + { + "t": 1789767309000, + "lon": -73.982668, + "lat": 40.752408, + "altM": 389 + }, + { + "t": 1789767310000, + "lon": -73.982938, + "lat": 40.752499, + "altM": 389 + }, + { + "t": 1789767311000, + "lon": -73.983398, + "lat": 40.752552, + "altM": 389 + }, + { + "t": 1789767312000, + "lon": -73.983632, + "lat": 40.752517, + "altM": 389 + }, + { + "t": 1789767313000, + "lon": -73.983978, + "lat": 40.752576, + "altM": 389 + }, + { + "t": 1789767314000, + "lon": -73.984288, + "lat": 40.752689, + "altM": 389 + }, + { + "t": 1789767315000, + "lon": -73.984665, + "lat": 40.752689, + "altM": 389 + }, + { + "t": 1789767316000, + "lon": -73.985045, + "lat": 40.752669, + "altM": 389 + }, + { + "t": 1789767317000, + "lon": -73.985364, + "lat": 40.752613, + "altM": 389 + }, + { "t": 1789767318000, "lon": -73.985598, "lat": 40.75259, "altM": 389 }, + { + "t": 1789767319000, + "lon": -73.985999, + "lat": 40.752561, + "altM": 389 + }, + { + "t": 1789767320000, + "lon": -73.986302, + "lat": 40.752487, + "altM": 389 + }, + { + "t": 1789767321000, + "lon": -73.986739, + "lat": 40.752437, + "altM": 389 + }, + { + "t": 1789767322000, + "lon": -73.987027, + "lat": 40.752357, + "altM": 389 + }, + { "t": 1789767323000, "lon": -73.987242, "lat": 40.75227, "altM": 389 }, + { + "t": 1789767324000, + "lon": -73.987608, + "lat": 40.752149, + "altM": 389 + }, + { "t": 1789767325000, "lon": -73.987899, "lat": 40.75203, "altM": 389 }, + { + "t": 1789767326000, + "lon": -73.988253, + "lat": 40.751856, + "altM": 389 + }, + { + "t": 1789767327000, + "lon": -73.988593, + "lat": 40.751656, + "altM": 389 + }, + { + "t": 1789767328000, + "lon": -73.988859, + "lat": 40.751534, + "altM": 389 + }, + { + "t": 1789767329000, + "lon": -73.989051, + "lat": 40.751398, + "altM": 389 + }, + { "t": 1789767330000, "lon": -73.989396, "lat": 40.75113, "altM": 389 }, + { + "t": 1789767331000, + "lon": -73.989603, + "lat": 40.751009, + "altM": 389 + }, + { "t": 1789767332000, "lon": -73.98987, "lat": 40.750715, "altM": 389 }, + { + "t": 1789767333000, + "lon": -73.990097, + "lat": 40.750473, + "altM": 389 + }, + { "t": 1789767334000, "lon": -73.99032, "lat": 40.750313, "altM": 389 }, + { + "t": 1789767335000, + "lon": -73.990504, + "lat": 40.749962, + "altM": 389 + }, + { + "t": 1789767336000, + "lon": -73.990611, + "lat": 40.749729, + "altM": 389 + }, + { + "t": 1789767337000, + "lon": -73.990763, + "lat": 40.749373, + "altM": 389 + }, + { + "t": 1789767338000, + "lon": -73.990962, + "lat": 40.749088, + "altM": 389 + }, + { + "t": 1789767339000, + "lon": -73.991044, + "lat": 40.748825, + "altM": 389 + }, + { + "t": 1789767340000, + "lon": -73.991056, + "lat": 40.748502, + "altM": 389 + }, + { + "t": 1789767341000, + "lon": -73.991197, + "lat": 40.748179, + "altM": 389 + }, + { "t": 1789767342000, "lon": -73.9911, "lat": 40.747802, "altM": 389 }, + { + "t": 1789767343000, + "lon": -73.991134, + "lat": 40.747545, + "altM": 389 + }, + { "t": 1789767344000, "lon": -73.99109, "lat": 40.747196, "altM": 389 }, + { + "t": 1789767345000, + "lon": -73.991074, + "lat": 40.746861, + "altM": 389 + }, + { + "t": 1789767346000, + "lon": -73.990925, + "lat": 40.746435, + "altM": 389 + }, + { + "t": 1789767347000, + "lon": -73.990766, + "lat": 40.746104, + "altM": 389 + }, + { + "t": 1789767348000, + "lon": -73.990602, + "lat": 40.745878, + "altM": 389 + }, + { + "t": 1789767349000, + "lon": -73.990389, + "lat": 40.745443, + "altM": 389 + }, + { + "t": 1789767350000, + "lon": -73.990233, + "lat": 40.745194, + "altM": 389 + }, + { "t": 1789767351000, "lon": -73.990014, "lat": 40.74488, "altM": 389 }, + { + "t": 1789767352000, + "lon": -73.989703, + "lat": 40.744586, + "altM": 389 + }, + { "t": 1789767353000, "lon": -73.98934, "lat": 40.744356, "altM": 389 }, + { + "t": 1789767354000, + "lon": -73.988942, + "lat": 40.744096, + "altM": 396 + }, + { "t": 1789767355000, "lon": -73.988643, "lat": 40.74389, "altM": 396 }, + { + "t": 1789767356000, + "lon": -73.988257, + "lat": 40.743608, + "altM": 396 + }, + { + "t": 1789767357000, + "lon": -73.987751, + "lat": 40.743371, + "altM": 396 + }, + { + "t": 1789767358000, + "lon": -73.987304, + "lat": 40.743177, + "altM": 396 + }, + { + "t": 1789767359000, + "lon": -73.986843, + "lat": 40.743107, + "altM": 396 + }, + { + "t": 1789767360000, + "lon": -73.986327, + "lat": 40.743043, + "altM": 396 + }, + { + "t": 1789767361000, + "lon": -73.985909, + "lat": 40.742916, + "altM": 396 + }, + { + "t": 1789767362000, + "lon": -73.985371, + "lat": 40.742831, + "altM": 396 + }, + { + "t": 1789767363000, + "lon": -73.984885, + "lat": 40.742839, + "altM": 396 + }, + { + "t": 1789767364000, + "lon": -73.984417, + "lat": 40.742784, + "altM": 396 + }, + { "t": 1789767365000, "lon": -73.98387, "lat": 40.74282, "altM": 396 }, + { + "t": 1789767366000, + "lon": -73.983434, + "lat": 40.742919, + "altM": 396 + }, + { + "t": 1789767367000, + "lon": -73.982986, + "lat": 40.742966, + "altM": 396 + }, + { + "t": 1789767368000, + "lon": -73.982523, + "lat": 40.743088, + "altM": 396 + }, + { + "t": 1789767369000, + "lon": -73.982153, + "lat": 40.743232, + "altM": 396 + }, + { + "t": 1789767370000, + "lon": -73.981704, + "lat": 40.743427, + "altM": 396 + }, + { + "t": 1789767371000, + "lon": -73.981287, + "lat": 40.743591, + "altM": 396 + }, + { + "t": 1789767372000, + "lon": -73.980967, + "lat": 40.743817, + "altM": 396 + }, + { + "t": 1789767373000, + "lon": -73.980496, + "lat": 40.744016, + "altM": 396 + }, + { + "t": 1789767374000, + "lon": -73.980208, + "lat": 40.744283, + "altM": 396 + }, + { "t": 1789767375000, "lon": -73.979996, "lat": 40.74448, "altM": 396 }, + { + "t": 1789767376000, + "lon": -73.979683, + "lat": 40.744763, + "altM": 396 + }, + { + "t": 1789767377000, + "lon": -73.979391, + "lat": 40.745095, + "altM": 396 + }, + { + "t": 1789767378000, + "lon": -73.979228, + "lat": 40.745339, + "altM": 396 + }, + { + "t": 1789767379000, + "lon": -73.979042, + "lat": 40.745571, + "altM": 396 + }, + { + "t": 1789767380000, + "lon": -73.978875, + "lat": 40.745901, + "altM": 396 + }, + { + "t": 1789767381000, + "lon": -73.978676, + "lat": 40.746231, + "altM": 396 + }, + { + "t": 1789767382000, + "lon": -73.978733, + "lat": 40.746466, + "altM": 396 + }, + { + "t": 1789767383000, + "lon": -73.978597, + "lat": 40.746769, + "altM": 396 + }, + { + "t": 1789767384000, + "lon": -73.978496, + "lat": 40.747083, + "altM": 396 + }, + { "t": 1789767385000, "lon": -73.978507, "lat": 40.74733, "altM": 396 }, + { + "t": 1789767386000, + "lon": -73.978578, + "lat": 40.747677, + "altM": 404 + }, + { + "t": 1789767387000, + "lon": -73.978614, + "lat": 40.747993, + "altM": 404 + }, + { "t": 1789767388000, "lon": -73.978621, "lat": 40.74821, "altM": 404 }, + { + "t": 1789767389000, + "lon": -73.978732, + "lat": 40.748496, + "altM": 404 + }, + { "t": 1789767390000, "lon": -73.978678, "lat": 40.74881, "altM": 404 }, + { + "t": 1789767391000, + "lon": -73.978819, + "lat": 40.748955, + "altM": 404 + }, + { + "t": 1789767392000, + "lon": -73.978966, + "lat": 40.749285, + "altM": 404 + }, + { + "t": 1789767393000, + "lon": -73.979016, + "lat": 40.749554, + "altM": 404 + }, + { + "t": 1789767394000, + "lon": -73.979176, + "lat": 40.749746, + "altM": 404 + }, + { "t": 1789767395000, "lon": -73.97949, "lat": 40.750027, "altM": 404 }, + { + "t": 1789767396000, + "lon": -73.979603, + "lat": 40.750176, + "altM": 404 + }, + { + "t": 1789767397000, + "lon": -73.979853, + "lat": 40.750485, + "altM": 404 + }, + { + "t": 1789767398000, + "lon": -73.980044, + "lat": 40.750629, + "altM": 404 + }, + { + "t": 1789767399000, + "lon": -73.980254, + "lat": 40.750803, + "altM": 404 + }, + { + "t": 1789767400000, + "lon": -73.980352, + "lat": 40.751034, + "altM": 404 + }, + { + "t": 1789767401000, + "lon": -73.980705, + "lat": 40.751209, + "altM": 404 + }, + { "t": 1789767402000, "lon": -73.98103, "lat": 40.751308, "altM": 404 }, + { + "t": 1789767403000, + "lon": -73.981244, + "lat": 40.751513, + "altM": 404 + }, + { "t": 1789767404000, "lon": -73.981394, "lat": 40.75169, "altM": 404 }, + { "t": 1789767405000, "lon": -73.98179, "lat": 40.751747, "altM": 404 }, + { + "t": 1789767406000, + "lon": -73.982133, + "lat": 40.751857, + "altM": 404 + }, + { + "t": 1789767407000, + "lon": -73.982307, + "lat": 40.752019, + "altM": 404 + }, + { + "t": 1789767408000, + "lon": -73.982654, + "lat": 40.752132, + "altM": 404 + }, + { + "t": 1789767409000, + "lon": -73.982936, + "lat": 40.752202, + "altM": 404 + }, + { + "t": 1789767410000, + "lon": -73.983281, + "lat": 40.752286, + "altM": 404 + }, + { "t": 1789767411000, "lon": -73.98364, "lat": 40.752342, "altM": 404 }, + { + "t": 1789767412000, + "lon": -73.983944, + "lat": 40.752358, + "altM": 404 + }, + { "t": 1789767413000, "lon": -73.9842, "lat": 40.752394, "altM": 404 }, + { "t": 1789767414000, "lon": -73.984671, "lat": 40.75244, "altM": 404 }, + { + "t": 1789767415000, + "lon": -73.984979, + "lat": 40.752507, + "altM": 404 + }, + { + "t": 1789767416000, + "lon": -73.985265, + "lat": 40.752402, + "altM": 404 + }, + { "t": 1789767417000, "lon": -73.9856, "lat": 40.752411, "altM": 404 }, + { + "t": 1789767418000, + "lon": -73.985981, + "lat": 40.752333, + "altM": 404 + }, + { "t": 1789767419000, "lon": -73.986299, "lat": 40.75232, "altM": 404 }, + { + "t": 1789767420000, + "lon": -73.986579, + "lat": 40.752295, + "altM": 404 + }, + { + "t": 1789767421000, + "lon": -73.986952, + "lat": 40.752145, + "altM": 404 + }, + { + "t": 1789767422000, + "lon": -73.987223, + "lat": 40.752148, + "altM": 404 + }, + { "t": 1789767423000, "lon": -73.98765, "lat": 40.751978, "altM": 404 }, + { "t": 1789767424000, "lon": -73.987905, "lat": 40.75185, "altM": 404 }, + { + "t": 1789767425000, + "lon": -73.988225, + "lat": 40.751721, + "altM": 404 + }, + { + "t": 1789767426000, + "lon": -73.988538, + "lat": 40.751565, + "altM": 404 + }, + { + "t": 1789767427000, + "lon": -73.988779, + "lat": 40.751435, + "altM": 404 + }, + { + "t": 1789767428000, + "lon": -73.989074, + "lat": 40.751247, + "altM": 404 + }, + { + "t": 1789767429000, + "lon": -73.989312, + "lat": 40.751127, + "altM": 404 + }, + { + "t": 1789767430000, + "lon": -73.989486, + "lat": 40.750882, + "altM": 404 + }, + { + "t": 1789767431000, + "lon": -73.989856, + "lat": 40.750622, + "altM": 404 + }, + { "t": 1789767432000, "lon": -73.99003, "lat": 40.750357, "altM": 404 }, + { + "t": 1789767433000, + "lon": -73.990358, + "lat": 40.750224, + "altM": 404 + }, + { "t": 1789767434000, "lon": -73.9905, "lat": 40.749904, "altM": 404 }, + { + "t": 1789767435000, + "lon": -73.990661, + "lat": 40.749663, + "altM": 404 + }, + { + "t": 1789767436000, + "lon": -73.990766, + "lat": 40.749348, + "altM": 404 + }, + { + "t": 1789767437000, + "lon": -73.990999, + "lat": 40.749019, + "altM": 404 + }, + { "t": 1789767438000, "lon": -73.99102, "lat": 40.748792, "altM": 404 }, + { + "t": 1789767439000, + "lon": -73.991146, + "lat": 40.748467, + "altM": 404 + }, + { + "t": 1789767440000, + "lon": -73.991254, + "lat": 40.748156, + "altM": 404 + }, + { + "t": 1789767441000, + "lon": -73.991103, + "lat": 40.747789, + "altM": 404 + }, + { + "t": 1789767442000, + "lon": -73.991211, + "lat": 40.747451, + "altM": 404 + }, + { + "t": 1789767443000, + "lon": -73.991164, + "lat": 40.747167, + "altM": 404 + }, + { + "t": 1789767444000, + "lon": -73.991153, + "lat": 40.746787, + "altM": 404 + }, + { + "t": 1789767445000, + "lon": -73.991075, + "lat": 40.746502, + "altM": 404 + }, + { + "t": 1789767446000, + "lon": -73.990993, + "lat": 40.746079, + "altM": 404 + }, + { + "t": 1789767447000, + "lon": -73.990766, + "lat": 40.745807, + "altM": 404 + }, + { "t": 1789767448000, "lon": -73.99061, "lat": 40.745475, "altM": 404 }, + { + "t": 1789767449000, + "lon": -73.990379, + "lat": 40.745104, + "altM": 404 + }, + { + "t": 1789767450000, + "lon": -73.990185, + "lat": 40.744863, + "altM": 404 + }, + { + "t": 1789767451000, + "lon": -73.989937, + "lat": 40.744566, + "altM": 404 + }, + { + "t": 1789767452000, + "lon": -73.989515, + "lat": 40.744254, + "altM": 404 + }, + { "t": 1789767453000, "lon": -73.98908, "lat": 40.743959, "altM": 404 }, + { + "t": 1789767454000, + "lon": -73.988882, + "lat": 40.743752, + "altM": 404 + }, + { + "t": 1789767455000, + "lon": -73.988508, + "lat": 40.743481, + "altM": 404 + }, + { + "t": 1789767456000, + "lon": -73.987942, + "lat": 40.743287, + "altM": 404 + }, + { + "t": 1789767457000, + "lon": -73.987564, + "lat": 40.743102, + "altM": 404 + }, + { + "t": 1789767458000, + "lon": -73.987137, + "lat": 40.742948, + "altM": 404 + }, + { "t": 1789767459000, "lon": -73.986567, "lat": 40.74287, "altM": 404 }, + { + "t": 1789767460000, + "lon": -73.986182, + "lat": 40.742674, + "altM": 404 + }, + { + "t": 1789767461000, + "lon": -73.985671, + "lat": 40.742611, + "altM": 404 + }, + { + "t": 1789767462000, + "lon": -73.985182, + "lat": 40.742651, + "altM": 396 + }, + { "t": 1789767463000, "lon": -73.984715, "lat": 40.74252, "altM": 396 }, + { "t": 1789767464000, "lon": -73.98424, "lat": 40.742526, "altM": 396 }, + { + "t": 1789767465000, + "lon": -73.983743, + "lat": 40.742606, + "altM": 396 + }, + { + "t": 1789767466000, + "lon": -73.983182, + "lat": 40.742651, + "altM": 396 + }, + { + "t": 1789767467000, + "lon": -73.982764, + "lat": 40.742768, + "altM": 396 + }, + { + "t": 1789767468000, + "lon": -73.982341, + "lat": 40.742848, + "altM": 396 + }, + { + "t": 1789767469000, + "lon": -73.981913, + "lat": 40.743001, + "altM": 396 + }, + { + "t": 1789767470000, + "lon": -73.981449, + "lat": 40.743121, + "altM": 396 + }, + { + "t": 1789767471000, + "lon": -73.981145, + "lat": 40.743377, + "altM": 396 + }, + { + "t": 1789767472000, + "lon": -73.980547, + "lat": 40.743482, + "altM": 396 + }, + { + "t": 1789767473000, + "lon": -73.980329, + "lat": 40.743733, + "altM": 396 + }, + { "t": 1789767474000, "lon": -73.97998, "lat": 40.743957, "altM": 396 }, + { + "t": 1789767475000, + "lon": -73.979645, + "lat": 40.744192, + "altM": 396 + }, + { + "t": 1789767476000, + "lon": -73.979303, + "lat": 40.744457, + "altM": 396 + }, + { + "t": 1789767477000, + "lon": -73.979162, + "lat": 40.744724, + "altM": 396 + }, + { + "t": 1789767478000, + "lon": -73.978939, + "lat": 40.744938, + "altM": 396 + }, + { "t": 1789767479000, "lon": -73.978679, "lat": 40.74525, "altM": 396 }, + { + "t": 1789767480000, + "lon": -73.978433, + "lat": 40.745507, + "altM": 396 + }, + { + "t": 1789767481000, + "lon": -73.978329, + "lat": 40.745863, + "altM": 396 + }, + { + "t": 1789767482000, + "lon": -73.978262, + "lat": 40.746147, + "altM": 396 + }, + { + "t": 1789767483000, + "lon": -73.978098, + "lat": 40.746429, + "altM": 396 + }, + { + "t": 1789767484000, + "lon": -73.978053, + "lat": 40.746647, + "altM": 396 + }, + { + "t": 1789767485000, + "lon": -73.977964, + "lat": 40.746975, + "altM": 396 + }, + { + "t": 1789767486000, + "lon": -73.978008, + "lat": 40.747355, + "altM": 396 + }, + { + "t": 1789767487000, + "lon": -73.977812, + "lat": 40.747607, + "altM": 396 + }, + { + "t": 1789767488000, + "lon": -73.977914, + "lat": 40.747911, + "altM": 396 + }, + { + "t": 1789767489000, + "lon": -73.977964, + "lat": 40.748106, + "altM": 396 + }, + { + "t": 1789767490000, + "lon": -73.978001, + "lat": 40.748457, + "altM": 396 + }, + { + "t": 1789767491000, + "lon": -73.978081, + "lat": 40.748706, + "altM": 396 + }, + { + "t": 1789767492000, + "lon": -73.978094, + "lat": 40.748984, + "altM": 396 + }, + { + "t": 1789767493000, + "lon": -73.978259, + "lat": 40.749256, + "altM": 396 + }, + { + "t": 1789767494000, + "lon": -73.978348, + "lat": 40.749463, + "altM": 396 + }, + { + "t": 1789767495000, + "lon": -73.978532, + "lat": 40.749676, + "altM": 396 + }, + { "t": 1789767496000, "lon": -73.978612, "lat": 40.75003, "altM": 396 }, + { + "t": 1789767497000, + "lon": -73.978816, + "lat": 40.750168, + "altM": 396 + }, + { + "t": 1789767498000, + "lon": -73.978911, + "lat": 40.750416, + "altM": 396 + }, + { + "t": 1789767499000, + "lon": -73.979198, + "lat": 40.750643, + "altM": 396 + }, + { + "t": 1789767500000, + "lon": -73.979445, + "lat": 40.750956, + "altM": 389 + }, + { "t": 1789767501000, "lon": -73.979631, "lat": 40.75108, "altM": 389 }, + { + "t": 1789767502000, + "lon": -73.979789, + "lat": 40.751295, + "altM": 389 + }, + { "t": 1789767503000, "lon": -73.980072, "lat": 40.75141, "altM": 389 }, + { "t": 1789767504000, "lon": -73.980265, "lat": 40.75164, "altM": 389 }, + { + "t": 1789767505000, + "lon": -73.980545, + "lat": 40.751801, + "altM": 389 + }, + { + "t": 1789767506000, + "lon": -73.980768, + "lat": 40.751967, + "altM": 389 + }, + { + "t": 1789767507000, + "lon": -73.981029, + "lat": 40.752083, + "altM": 389 + }, + { + "t": 1789767508000, + "lon": -73.981437, + "lat": 40.752262, + "altM": 389 + }, + { "t": 1789767509000, "lon": -73.981655, "lat": 40.75232, "altM": 389 }, + { + "t": 1789767510000, + "lon": -73.981859, + "lat": 40.752459, + "altM": 389 + }, + { + "t": 1789767511000, + "lon": -73.982246, + "lat": 40.752547, + "altM": 389 + }, + { + "t": 1789767512000, + "lon": -73.982574, + "lat": 40.752633, + "altM": 389 + }, + { + "t": 1789767513000, + "lon": -73.982856, + "lat": 40.752706, + "altM": 389 + }, + { + "t": 1789767514000, + "lon": -73.983287, + "lat": 40.752761, + "altM": 389 + }, + { "t": 1789767515000, "lon": -73.98345, "lat": 40.752872, "altM": 389 }, + { "t": 1789767516000, "lon": -73.9838, "lat": 40.752867, "altM": 389 }, + { + "t": 1789767517000, + "lon": -73.984221, + "lat": 40.752963, + "altM": 389 + }, + { + "t": 1789767518000, + "lon": -73.984413, + "lat": 40.752882, + "altM": 389 + }, + { + "t": 1789767519000, + "lon": -73.984883, + "lat": 40.752992, + "altM": 389 + }, + { + "t": 1789767520000, + "lon": -73.985099, + "lat": 40.752977, + "altM": 389 + }, + { + "t": 1789767521000, + "lon": -73.985455, + "lat": 40.752954, + "altM": 389 + }, + { + "t": 1789767522000, + "lon": -73.985861, + "lat": 40.752923, + "altM": 389 + }, + { "t": 1789767523000, "lon": -73.98617, "lat": 40.752948, "altM": 389 }, + { + "t": 1789767524000, + "lon": -73.986546, + "lat": 40.752781, + "altM": 389 + }, + { + "t": 1789767525000, + "lon": -73.986824, + "lat": 40.752787, + "altM": 389 + }, + { + "t": 1789767526000, + "lon": -73.987144, + "lat": 40.752705, + "altM": 389 + }, + { + "t": 1789767527000, + "lon": -73.987363, + "lat": 40.752543, + "altM": 389 + }, + { + "t": 1789767528000, + "lon": -73.987819, + "lat": 40.752443, + "altM": 389 + }, + { + "t": 1789767529000, + "lon": -73.988152, + "lat": 40.752384, + "altM": 389 + }, + { + "t": 1789767530000, + "lon": -73.988387, + "lat": 40.752218, + "altM": 389 + }, + { "t": 1789767531000, "lon": -73.98871, "lat": 40.752087, "altM": 389 }, + { + "t": 1789767532000, + "lon": -73.988962, + "lat": 40.751889, + "altM": 389 + }, + { "t": 1789767533000, "lon": -73.989206, "lat": 40.75174, "altM": 389 }, + { "t": 1789767534000, "lon": -73.98965, "lat": 40.751521, "altM": 389 }, + { + "t": 1789767535000, + "lon": -73.989834, + "lat": 40.751384, + "altM": 389 + }, + { + "t": 1789767536000, + "lon": -73.990098, + "lat": 40.751142, + "altM": 389 + }, + { + "t": 1789767537000, + "lon": -73.990304, + "lat": 40.750953, + "altM": 389 + }, + { + "t": 1789767538000, + "lon": -73.990611, + "lat": 40.750662, + "altM": 389 + }, + { + "t": 1789767539000, + "lon": -73.990709, + "lat": 40.750484, + "altM": 389 + }, + { "t": 1789767540000, "lon": -73.990988, "lat": 40.75018, "altM": 389 }, + { "t": 1789767541000, "lon": -73.99123, "lat": 40.749898, "altM": 389 }, + { + "t": 1789767542000, + "lon": -73.991364, + "lat": 40.749578, + "altM": 396 + }, + { + "t": 1789767543000, + "lon": -73.991496, + "lat": 40.749131, + "altM": 396 + }, + { + "t": 1789767544000, + "lon": -73.991564, + "lat": 40.748762, + "altM": 396 + }, + { + "t": 1789767545000, + "lon": -73.991615, + "lat": 40.748379, + "altM": 396 + }, + { "t": 1789767546000, "lon": -73.991658, "lat": 40.74794, "altM": 396 }, + { + "t": 1789767547000, + "lon": -73.991622, + "lat": 40.747398, + "altM": 404 + }, + { + "t": 1789767548000, + "lon": -73.991474, + "lat": 40.746955, + "altM": 404 + }, + { + "t": 1789767549000, + "lon": -73.991338, + "lat": 40.746422, + "altM": 404 + }, + { "t": 1789767550000, "lon": -73.99106, "lat": 40.746008, "altM": 404 }, + { + "t": 1789767551000, + "lon": -73.990773, + "lat": 40.745439, + "altM": 404 + }, + { + "t": 1789767552000, + "lon": -73.990498, + "lat": 40.745033, + "altM": 404 + }, + { + "t": 1789767553000, + "lon": -73.990022, + "lat": 40.744546, + "altM": 404 + }, + { "t": 1789767554000, "lon": -73.98962, "lat": 40.744108, "altM": 404 }, + { + "t": 1789767555000, + "lon": -73.989058, + "lat": 40.743776, + "altM": 404 + }, + { + "t": 1789767556000, + "lon": -73.988514, + "lat": 40.743397, + "altM": 404 + }, + { + "t": 1789767557000, + "lon": -73.988024, + "lat": 40.743071, + "altM": 411 + }, + { + "t": 1789767558000, + "lon": -73.987432, + "lat": 40.742723, + "altM": 411 + }, + { + "t": 1789767559000, + "lon": -73.986775, + "lat": 40.742443, + "altM": 411 + }, + { + "t": 1789767560000, + "lon": -73.986181, + "lat": 40.742087, + "altM": 411 + }, + { + "t": 1789767561000, + "lon": -73.985528, + "lat": 40.741763, + "altM": 411 + }, + { + "t": 1789767562000, + "lon": -73.984908, + "lat": 40.741422, + "altM": 411 + }, + { + "t": 1789767563000, + "lon": -73.984383, + "lat": 40.741116, + "altM": 411 + }, + { + "t": 1789767564000, + "lon": -73.983756, + "lat": 40.740715, + "altM": 411 + }, + { + "t": 1789767565000, + "lon": -73.983056, + "lat": 40.740425, + "altM": 411 + }, + { + "t": 1789767566000, + "lon": -73.982497, + "lat": 40.740085, + "altM": 411 + }, + { "t": 1789767567000, "lon": -73.98196, "lat": 40.739736, "altM": 411 }, + { + "t": 1789767568000, + "lon": -73.981279, + "lat": 40.739462, + "altM": 411 + }, + { + "t": 1789767569000, + "lon": -73.980668, + "lat": 40.739087, + "altM": 411 + }, + { + "t": 1789767570000, + "lon": -73.980101, + "lat": 40.738751, + "altM": 411 + }, + { + "t": 1789767571000, + "lon": -73.979441, + "lat": 40.738449, + "altM": 411 + }, + { "t": 1789767572000, "lon": -73.978869, "lat": 40.73813, "altM": 411 }, + { "t": 1789767573000, "lon": -73.97817, "lat": 40.7377, "altM": 411 }, + { + "t": 1789767574000, + "lon": -73.977653, + "lat": 40.737431, + "altM": 411 + }, + { + "t": 1789767575000, + "lon": -73.977054, + "lat": 40.737068, + "altM": 411 + }, + { + "t": 1789767576000, + "lon": -73.976425, + "lat": 40.736685, + "altM": 411 + }, + { "t": 1789767577000, "lon": -73.97587, "lat": 40.736366, "altM": 411 }, + { + "t": 1789767578000, + "lon": -73.975182, + "lat": 40.736009, + "altM": 411 + }, + { + "t": 1789767579000, + "lon": -73.974611, + "lat": 40.735732, + "altM": 411 + }, + { + "t": 1789767580000, + "lon": -73.974059, + "lat": 40.735407, + "altM": 411 + }, + { + "t": 1789767581000, + "lon": -73.973416, + "lat": 40.735043, + "altM": 411 + }, + { + "t": 1789767582000, + "lon": -73.972786, + "lat": 40.734681, + "altM": 411 + }, + { + "t": 1789767583000, + "lon": -73.972165, + "lat": 40.734316, + "altM": 411 + }, + { + "t": 1789767584000, + "lon": -73.971666, + "lat": 40.733925, + "altM": 411 + }, + { + "t": 1789767585000, + "lon": -73.971084, + "lat": 40.733677, + "altM": 411 + }, + { "t": 1789767586000, "lon": -73.9704, "lat": 40.733306, "altM": 411 }, + { + "t": 1789767587000, + "lon": -73.969783, + "lat": 40.732926, + "altM": 411 + }, + { + "t": 1789767588000, + "lon": -73.969223, + "lat": 40.732518, + "altM": 411 + }, + { "t": 1789767589000, "lon": -73.968581, "lat": 40.73214, "altM": 411 }, + { + "t": 1789767590000, + "lon": -73.968008, + "lat": 40.731859, + "altM": 411 + }, + { + "t": 1789767591000, + "lon": -73.967394, + "lat": 40.731537, + "altM": 411 + }, + { "t": 1789767592000, "lon": -73.966805, "lat": 40.73121, "altM": 411 }, + { + "t": 1789767593000, + "lon": -73.966298, + "lat": 40.730774, + "altM": 411 + }, + { "t": 1789767594000, "lon": -73.965743, "lat": 40.73038, "altM": 411 }, + { "t": 1789767595000, "lon": -73.965083, "lat": 40.73016, "altM": 411 }, + { + "t": 1789767596000, + "lon": -73.964474, + "lat": 40.729761, + "altM": 411 + }, + { "t": 1789767597000, "lon": -73.96393, "lat": 40.729405, "altM": 411 }, + { + "t": 1789767598000, + "lon": -73.963335, + "lat": 40.729013, + "altM": 411 + }, + { + "t": 1789767599000, + "lon": -73.962789, + "lat": 40.728608, + "altM": 411 + }, + { + "t": 1789767600000, + "lon": -73.962303, + "lat": 40.728234, + "altM": 411 + }, + { + "t": 1789767601000, + "lon": -73.961768, + "lat": 40.727815, + "altM": 411 + }, + { + "t": 1789767602000, + "lon": -73.961363, + "lat": 40.727316, + "altM": 411 + }, + { + "t": 1789767603000, + "lon": -73.960923, + "lat": 40.726873, + "altM": 411 + }, + { + "t": 1789767604000, + "lon": -73.960497, + "lat": 40.726372, + "altM": 411 + }, + { + "t": 1789767605000, + "lon": -73.960222, + "lat": 40.725914, + "altM": 411 + }, + { + "t": 1789767606000, + "lon": -73.960041, + "lat": 40.725366, + "altM": 411 + }, + { "t": 1789767607000, "lon": -73.95994, "lat": 40.724797, "altM": 411 }, + { + "t": 1789767608000, + "lon": -73.959864, + "lat": 40.724258, + "altM": 411 + }, + { + "t": 1789767609000, + "lon": -73.959785, + "lat": 40.723761, + "altM": 411 + }, + { + "t": 1789767610000, + "lon": -73.959827, + "lat": 40.723288, + "altM": 411 + }, + { "t": 1789767611000, "lon": -73.959934, "lat": 40.72269, "altM": 411 }, + { + "t": 1789767612000, + "lon": -73.960145, + "lat": 40.722223, + "altM": 411 + }, + { + "t": 1789767613000, + "lon": -73.960359, + "lat": 40.721748, + "altM": 411 + }, + { + "t": 1789767614000, + "lon": -73.960557, + "lat": 40.721322, + "altM": 411 + }, + { + "t": 1789767615000, + "lon": -73.960974, + "lat": 40.720869, + "altM": 411 + }, + { + "t": 1789767616000, + "lon": -73.961289, + "lat": 40.720468, + "altM": 411 + }, + { + "t": 1789767617000, + "lon": -73.961778, + "lat": 40.720088, + "altM": 411 + }, + { + "t": 1789767618000, + "lon": -73.962259, + "lat": 40.719789, + "altM": 411 + }, + { + "t": 1789767619000, + "lon": -73.962794, + "lat": 40.719503, + "altM": 411 + }, + { + "t": 1789767620000, + "lon": -73.963335, + "lat": 40.719271, + "altM": 411 + }, + { + "t": 1789767621000, + "lon": -73.963798, + "lat": 40.718998, + "altM": 411 + }, + { "t": 1789767622000, "lon": -73.96442, "lat": 40.718948, "altM": 411 }, + { "t": 1789767623000, "lon": -73.964951, "lat": 40.71882, "altM": 411 }, + { "t": 1789767624000, "lon": -73.965583, "lat": 40.71884, "altM": 411 }, + { "t": 1789767625000, "lon": -73.96605, "lat": 40.718815, "altM": 411 }, + { "t": 1789767626000, "lon": -73.966745, "lat": 40.71879, "altM": 411 }, + { "t": 1789767627000, "lon": -73.96729, "lat": 40.718998, "altM": 411 }, + { + "t": 1789767628000, + "lon": -73.967887, + "lat": 40.719015, + "altM": 411 + }, + { + "t": 1789767629000, + "lon": -73.968332, + "lat": 40.719328, + "altM": 411 + }, + { + "t": 1789767630000, + "lon": -73.968907, + "lat": 40.719555, + "altM": 411 + }, + { + "t": 1789767631000, + "lon": -73.969405, + "lat": 40.719782, + "altM": 411 + }, + { + "t": 1789767632000, + "lon": -73.969952, + "lat": 40.719951, + "altM": 411 + }, + { "t": 1789767633000, "lon": -73.970537, "lat": 40.72002, "altM": 411 }, + { + "t": 1789767634000, + "lon": -73.971164, + "lat": 40.720075, + "altM": 411 + }, + { + "t": 1789767635000, + "lon": -73.971759, + "lat": 40.720176, + "altM": 411 + }, + { "t": 1789767636000, "lon": -73.972408, "lat": 40.72009, "altM": 411 }, + { + "t": 1789767637000, + "lon": -73.973115, + "lat": 40.720026, + "altM": 411 + }, + { "t": 1789767638000, "lon": -73.9737, "lat": 40.719862, "altM": 411 }, + { + "t": 1789767639000, + "lon": -73.974299, + "lat": 40.719719, + "altM": 411 + }, + { + "t": 1789767640000, + "lon": -73.974883, + "lat": 40.719448, + "altM": 411 + }, + { + "t": 1789767641000, + "lon": -73.975402, + "lat": 40.719202, + "altM": 411 + }, + { + "t": 1789767642000, + "lon": -73.975872, + "lat": 40.718961, + "altM": 411 + }, + { + "t": 1789767643000, + "lon": -73.976363, + "lat": 40.718507, + "altM": 411 + }, + { + "t": 1789767644000, + "lon": -73.976884, + "lat": 40.718077, + "altM": 411 + }, + { + "t": 1789767645000, + "lon": -73.977191, + "lat": 40.717612, + "altM": 411 + }, + { + "t": 1789767646000, + "lon": -73.977535, + "lat": 40.717217, + "altM": 411 + }, + { + "t": 1789767647000, + "lon": -73.977896, + "lat": 40.716651, + "altM": 411 + }, + { + "t": 1789767648000, + "lon": -73.978094, + "lat": 40.716114, + "altM": 411 + }, + { + "t": 1789767649000, + "lon": -73.978239, + "lat": 40.715583, + "altM": 411 + }, + { + "t": 1789767650000, + "lon": -73.978332, + "lat": 40.715045, + "altM": 411 + }, + { + "t": 1789767651000, + "lon": -73.978569, + "lat": 40.714485, + "altM": 411 + }, + { + "t": 1789767652000, + "lon": -73.978665, + "lat": 40.713949, + "altM": 411 + }, + { + "t": 1789767653000, + "lon": -73.978892, + "lat": 40.713437, + "altM": 411 + }, + { + "t": 1789767654000, + "lon": -73.979111, + "lat": 40.712869, + "altM": 411 + }, + { + "t": 1789767655000, + "lon": -73.979236, + "lat": 40.712281, + "altM": 411 + }, + { + "t": 1789767656000, + "lon": -73.979357, + "lat": 40.711791, + "altM": 411 + }, + { + "t": 1789767657000, + "lon": -73.979582, + "lat": 40.711208, + "altM": 411 + }, + { + "t": 1789767658000, + "lon": -73.979775, + "lat": 40.710693, + "altM": 411 + }, + { + "t": 1789767659000, + "lon": -73.979948, + "lat": 40.710063, + "altM": 411 + }, + { + "t": 1789767660000, + "lon": -73.980135, + "lat": 40.709544, + "altM": 411 + }, + { + "t": 1789767661000, + "lon": -73.980277, + "lat": 40.709058, + "altM": 411 + }, + { + "t": 1789767662000, + "lon": -73.980536, + "lat": 40.708465, + "altM": 411 + }, + { + "t": 1789767663000, + "lon": -73.980699, + "lat": 40.707941, + "altM": 411 + }, + { + "t": 1789767664000, + "lon": -73.980834, + "lat": 40.707384, + "altM": 411 + }, + { + "t": 1789767665000, + "lon": -73.981071, + "lat": 40.706843, + "altM": 411 + }, + { + "t": 1789767666000, + "lon": -73.981225, + "lat": 40.706366, + "altM": 411 + }, + { "t": 1789767667000, "lon": -73.98137, "lat": 40.705796, "altM": 411 }, + { + "t": 1789767668000, + "lon": -73.981629, + "lat": 40.705268, + "altM": 411 + }, + { "t": 1789767669000, "lon": -73.98182, "lat": 40.70474, "altM": 411 }, + { "t": 1789767670000, "lon": -73.981893, "lat": 40.70412, "altM": 411 }, + { + "t": 1789767671000, + "lon": -73.982244, + "lat": 40.703655, + "altM": 411 + }, + { + "t": 1789767672000, + "lon": -73.982441, + "lat": 40.703102, + "altM": 411 + }, + { + "t": 1789767673000, + "lon": -73.982694, + "lat": 40.702633, + "altM": 411 + }, + { + "t": 1789767674000, + "lon": -73.982895, + "lat": 40.702067, + "altM": 411 + }, + { + "t": 1789767675000, + "lon": -73.983151, + "lat": 40.701494, + "altM": 411 + }, + { + "t": 1789767676000, + "lon": -73.983336, + "lat": 40.701035, + "altM": 411 + }, + { + "t": 1789767677000, + "lon": -73.983526, + "lat": 40.700474, + "altM": 411 + }, + { "t": 1789767678000, "lon": -73.983769, "lat": 40.6999, "altM": 411 }, + { "t": 1789767679000, "lon": -73.984003, "lat": 40.69938, "altM": 411 }, + { + "t": 1789767680000, + "lon": -73.984284, + "lat": 40.698819, + "altM": 411 + }, + { + "t": 1789767681000, + "lon": -73.984603, + "lat": 40.698413, + "altM": 411 + }, + { + "t": 1789767682000, + "lon": -73.984814, + "lat": 40.697895, + "altM": 411 + }, + { + "t": 1789767683000, + "lon": -73.985033, + "lat": 40.697307, + "altM": 411 + }, + { + "t": 1789767684000, + "lon": -73.985245, + "lat": 40.696796, + "altM": 411 + }, + { + "t": 1789767685000, + "lon": -73.985613, + "lat": 40.696236, + "altM": 411 + }, + { + "t": 1789767686000, + "lon": -73.985806, + "lat": 40.695805, + "altM": 411 + }, + { + "t": 1789767687000, + "lon": -73.986198, + "lat": 40.695294, + "altM": 411 + }, + { + "t": 1789767688000, + "lon": -73.986436, + "lat": 40.694818, + "altM": 411 + }, + { + "t": 1789767689000, + "lon": -73.986721, + "lat": 40.694255, + "altM": 411 + }, + { + "t": 1789767690000, + "lon": -73.987051, + "lat": 40.693738, + "altM": 411 + }, + { + "t": 1789767691000, + "lon": -73.987185, + "lat": 40.693234, + "altM": 411 + }, + { "t": 1789767692000, "lon": -73.98758, "lat": 40.692765, "altM": 411 }, + { + "t": 1789767693000, + "lon": -73.988028, + "lat": 40.692332, + "altM": 411 + }, + { + "t": 1789767694000, + "lon": -73.988279, + "lat": 40.691776, + "altM": 411 + }, + { + "t": 1789767695000, + "lon": -73.988559, + "lat": 40.691335, + "altM": 411 + }, + { + "t": 1789767696000, + "lon": -73.989017, + "lat": 40.690891, + "altM": 411 + }, + { + "t": 1789767697000, + "lon": -73.989434, + "lat": 40.690441, + "altM": 411 + }, + { + "t": 1789767698000, + "lon": -73.989951, + "lat": 40.690077, + "altM": 411 + }, + { "t": 1789767699000, "lon": -73.99044, "lat": 40.689658, "altM": 411 }, + { "t": 1789767700000, "lon": -73.99093, "lat": 40.68941, "altM": 411 }, + { + "t": 1789767701000, + "lon": -73.991417, + "lat": 40.689014, + "altM": 411 + }, + { + "t": 1789767702000, + "lon": -73.992129, + "lat": 40.688906, + "altM": 411 + }, + { + "t": 1789767703000, + "lon": -73.992743, + "lat": 40.688631, + "altM": 411 + }, + { + "t": 1789767704000, + "lon": -73.993393, + "lat": 40.688583, + "altM": 411 + }, + { + "t": 1789767705000, + "lon": -73.993978, + "lat": 40.688475, + "altM": 411 + }, + { + "t": 1789767706000, + "lon": -73.994716, + "lat": 40.688505, + "altM": 411 + }, + { + "t": 1789767707000, + "lon": -73.995339, + "lat": 40.688579, + "altM": 411 + }, + { + "t": 1789767708000, + "lon": -73.995907, + "lat": 40.688632, + "altM": 411 + }, + { "t": 1789767709000, "lon": -73.99658, "lat": 40.688784, "altM": 411 }, + { + "t": 1789767710000, + "lon": -73.997136, + "lat": 40.688953, + "altM": 411 + }, + { + "t": 1789767711000, + "lon": -73.997728, + "lat": 40.689137, + "altM": 411 + }, + { + "t": 1789767712000, + "lon": -73.998294, + "lat": 40.689532, + "altM": 411 + }, + { + "t": 1789767713000, + "lon": -73.998664, + "lat": 40.689895, + "altM": 411 + }, + { "t": 1789767714000, "lon": -73.999193, "lat": 40.69017, "altM": 411 }, + { + "t": 1789767715000, + "lon": -73.999581, + "lat": 40.690681, + "altM": 411 + }, + { "t": 1789767716000, "lon": -73.99987, "lat": 40.691097, "altM": 411 }, + { + "t": 1789767717000, + "lon": -74.000177, + "lat": 40.691542, + "altM": 411 + }, + { + "t": 1789767718000, + "lon": -74.000207, + "lat": 40.692026, + "altM": 411 + }, + { + "t": 1789767719000, + "lon": -74.000487, + "lat": 40.692634, + "altM": 411 + }, + { "t": 1789767720000, "lon": -74.00057, "lat": 40.693005, "altM": 411 }, + { + "t": 1789767721000, + "lon": -74.000587, + "lat": 40.693593, + "altM": 411 + }, + { + "t": 1789767722000, + "lon": -74.000454, + "lat": 40.694108, + "altM": 411 + }, + { + "t": 1789767723000, + "lon": -74.000377, + "lat": 40.694619, + "altM": 411 + }, + { + "t": 1789767724000, + "lon": -74.000118, + "lat": 40.695194, + "altM": 411 + }, + { + "t": 1789767725000, + "lon": -73.999802, + "lat": 40.695794, + "altM": 411 + }, + { + "t": 1789767726000, + "lon": -73.999566, + "lat": 40.696217, + "altM": 411 + }, + { + "t": 1789767727000, + "lon": -73.999165, + "lat": 40.696698, + "altM": 411 + }, + { + "t": 1789767728000, + "lon": -73.998697, + "lat": 40.697156, + "altM": 411 + }, + { + "t": 1789767729000, + "lon": -73.998124, + "lat": 40.697549, + "altM": 411 + }, + { + "t": 1789767730000, + "lon": -73.997578, + "lat": 40.697912, + "altM": 411 + }, + { + "t": 1789767731000, + "lon": -73.996939, + "lat": 40.698348, + "altM": 411 + }, + { + "t": 1789767732000, + "lon": -73.996288, + "lat": 40.698655, + "altM": 411 + }, + { + "t": 1789767733000, + "lon": -73.995515, + "lat": 40.698873, + "altM": 411 + }, + { + "t": 1789767734000, + "lon": -73.994784, + "lat": 40.699072, + "altM": 411 + }, + { + "t": 1789767735000, + "lon": -73.993998, + "lat": 40.699228, + "altM": 411 + }, + { + "t": 1789767736000, + "lon": -73.993162, + "lat": 40.699331, + "altM": 411 + }, + { + "t": 1789767737000, + "lon": -73.992454, + "lat": 40.699413, + "altM": 411 + }, + { + "t": 1789767738000, + "lon": -73.991587, + "lat": 40.699486, + "altM": 411 + }, + { + "t": 1789767739000, + "lon": -73.990691, + "lat": 40.699405, + "altM": 411 + }, + { + "t": 1789767740000, + "lon": -73.989989, + "lat": 40.699313, + "altM": 411 + }, + { "t": 1789767741000, "lon": -73.989176, "lat": 40.69913, "altM": 411 }, + { + "t": 1789767742000, + "lon": -73.988345, + "lat": 40.698849, + "altM": 411 + }, + { + "t": 1789767743000, + "lon": -73.987668, + "lat": 40.698652, + "altM": 411 + }, + { + "t": 1789767744000, + "lon": -73.986998, + "lat": 40.698359, + "altM": 411 + }, + { + "t": 1789767745000, + "lon": -73.986262, + "lat": 40.697969, + "altM": 411 + }, + { + "t": 1789767746000, + "lon": -73.985621, + "lat": 40.697613, + "altM": 411 + }, + { + "t": 1789767747000, + "lon": -73.985046, + "lat": 40.697168, + "altM": 411 + }, + { + "t": 1789767748000, + "lon": -73.984563, + "lat": 40.696714, + "altM": 411 + }, + { + "t": 1789767749000, + "lon": -73.983997, + "lat": 40.696218, + "altM": 411 + }, + { "t": 1789767750000, "lon": -73.98374, "lat": 40.695631, "altM": 411 }, + { + "t": 1789767751000, + "lon": -73.983349, + "lat": 40.695155, + "altM": 411 + }, + { + "t": 1789767752000, + "lon": -73.982953, + "lat": 40.694592, + "altM": 411 + }, + { + "t": 1789767753000, + "lon": -73.982863, + "lat": 40.693989, + "altM": 411 + }, + { + "t": 1789767754000, + "lon": -73.982658, + "lat": 40.693552, + "altM": 411 + }, + { + "t": 1789767755000, + "lon": -73.982601, + "lat": 40.692896, + "altM": 411 + }, + { + "t": 1789767756000, + "lon": -73.982593, + "lat": 40.692286, + "altM": 411 + }, + { + "t": 1789767757000, + "lon": -73.982649, + "lat": 40.691778, + "altM": 411 + }, + { + "t": 1789767758000, + "lon": -73.982855, + "lat": 40.691156, + "altM": 411 + }, + { "t": 1789767759000, "lon": -73.983001, "lat": 40.69063, "altM": 411 }, + { + "t": 1789767760000, + "lon": -73.983214, + "lat": 40.690128, + "altM": 411 + }, + { "t": 1789767761000, "lon": -73.983587, "lat": 40.68965, "altM": 411 }, + { + "t": 1789767762000, + "lon": -73.984045, + "lat": 40.689201, + "altM": 411 + }, + { + "t": 1789767763000, + "lon": -73.984415, + "lat": 40.688756, + "altM": 411 + }, + { + "t": 1789767764000, + "lon": -73.984948, + "lat": 40.688406, + "altM": 411 + }, + { "t": 1789767765000, "lon": -73.985315, "lat": 40.68806, "altM": 411 }, + { + "t": 1789767766000, + "lon": -73.985979, + "lat": 40.687728, + "altM": 411 + }, + { + "t": 1789767767000, + "lon": -73.986602, + "lat": 40.687548, + "altM": 411 + }, + { + "t": 1789767768000, + "lon": -73.987133, + "lat": 40.687301, + "altM": 411 + }, + { + "t": 1789767769000, + "lon": -73.987739, + "lat": 40.687155, + "altM": 411 + }, + { + "t": 1789767770000, + "lon": -73.988477, + "lat": 40.687073, + "altM": 411 + }, + { + "t": 1789767771000, + "lon": -73.989099, + "lat": 40.687037, + "altM": 411 + }, + { + "t": 1789767772000, + "lon": -73.989799, + "lat": 40.687069, + "altM": 411 + }, + { + "t": 1789767773000, + "lon": -73.990343, + "lat": 40.687101, + "altM": 411 + }, + { "t": 1789767774000, "lon": -73.99111, "lat": 40.687258, "altM": 411 }, + { + "t": 1789767775000, + "lon": -73.991687, + "lat": 40.687416, + "altM": 411 + }, + { + "t": 1789767776000, + "lon": -73.992234, + "lat": 40.687698, + "altM": 411 + }, + { + "t": 1789767777000, + "lon": -73.992741, + "lat": 40.687951, + "altM": 411 + }, + { "t": 1789767778000, "lon": -73.99327, "lat": 40.688251, "altM": 411 }, + { + "t": 1789767779000, + "lon": -73.993693, + "lat": 40.688606, + "altM": 411 + }, + { "t": 1789767780000, "lon": -73.99409, "lat": 40.688991, "altM": 411 } + ] + } + ], + "captures": [ + { + "id": "c1", + "t": 1789766332000, + "lon": -73.98795, + "lat": 40.74968, + "altM": 1.5, + "headingDeg": 125.4, + "pitchDeg": 54.2, + "rangeM": 237, + "fovDeg": 22, + "sealed": true, + "title": "Two figures outside the 86th floor fence", + "handle": "kvn_on_34th", + "place": "W 34th St & 6th Ave", + "firstEyes": true, + "kind": "photo" + }, + { + "id": "c2", + "t": 1789766465000, + "lon": -73.98752, + "lat": 40.74482, + "altM": 1.5, + "headingDeg": 21.4, + "pitchDeg": 39, + "rangeM": 430, + "fovDeg": 30, + "sealed": true, + "title": "North face, police helicopter overhead", + "handle": "jules_flatiron", + "place": "5th Ave & 29th St", + "kind": "clip" + }, + { + "id": "c3", + "t": 1789766650000, + "lon": -73.99325, + "lat": 40.75195, + "altM": 142, + "headingDeg": 121.2, + "pitchDeg": 19.1, + "rangeM": 749, + "fovDeg": 18, + "sealed": true, + "title": "On the mast, east side, from the 40th floor", + "handle": "penn_plaza_40th", + "place": "1 Penn Plaza, 40th floor", + "kind": "clip" + }, + { + "id": "c4", + "t": 1789766800000, + "lon": -74.00355, + "lat": 40.75255, + "altM": 9, + "headingDeg": 106.8, + "pitchDeg": 13.3, + "rangeM": 1576, + "fovDeg": 14, + "sealed": true, + "title": "Three helicopters around the spire", + "handle": "hellsk1tchen", + "place": "The High Line at W 30th St", + "kind": "photo" + }, + { + "id": "c5", + "t": 1789767020000, + "lon": -73.98805, + "lat": 40.74745, + "altM": 55, + "headingDeg": 61.5, + "pitchDeg": 54.2, + "rangeM": 229, + "fovDeg": 40, + "sealed": true, + "title": "Officers on the 102nd floor deck", + "handle": "lena.ktown", + "place": "Rooftop, W 32nd St (Koreatown)", + "kind": "clip" + }, + { + "id": "c6", + "t": 1789767210000, + "lon": -73.98205, + "lat": 40.75112, + "altM": 1.5, + "headingDeg": 225.8, + "pitchDeg": 41.8, + "rangeM": 425, + "fovDeg": 28, + "sealed": true, + "title": "Crowd on 5th Ave looking up", + "handle": "midtown_mara", + "place": "5th Ave & 38th St", + "kind": "photo" + }, + { + "id": "c7", + "t": 1789767465000, + "lon": -73.97765, + "lat": 40.74662, + "altM": 48, + "headingDeg": 286.6, + "pitchDeg": 24.8, + "rangeM": 705, + "fovDeg": 20, + "sealed": true, + "title": "Both back over the rail at 102", + "handle": "rooftop_rafa", + "place": "Rooftop, Murray Hill", + "kind": "clip" + }, + { + "id": "c8", + "t": 1789767550000, + "lon": -73.98875, + "lat": 40.74905, + "altM": 1.5, + "headingDeg": 104.5, + "pitchDeg": 51.6, + "rangeM": 269, + "fovDeg": 34, + "sealed": true, + "title": "SKY-4 peeling away east", + "handle": "deli_guy_dan", + "place": "Broadway & 33rd St (Herald Sq)", + "kind": "photo" + } + ], + "chat": [ + { + "t": 1789766292292, + "handle": "deli_guy_dan", + "text": "why is everyone on 34th looking up" + }, + { + "t": 1789766312172, + "handle": "kvn_on_34th", + "text": "theres PEOPLE on the empire state. outside the fence on 86", + "badge": "local" + }, + { "t": 1789766317850, "handle": "midtown_mara", "text": "wait what" }, + { "t": 1789766325619, "handle": "brklyn_bea", "text": "link??" }, + { + "t": 1789766329198, + "handle": "kvn_on_34th", + "text": "sealed photo up. north side, two of them", + "badge": "first-eyes" + }, + { + "t": 1789766337383, + "handle": "throwaway_tom", + "text": "thats a window washer rig" + }, + { + "t": 1789766344538, + "handle": "kvn_on_34th", + "text": "no rig. no ropes that I can see", + "badge": "first-eyes" + }, + { + "t": 1789766352178, + "handle": "jules_flatiron", + "text": "omg I see them from 29th" + }, + { + "t": 1789766358429, + "handle": "nyc_scanner_nerd", + "text": "scanner: units responding to 350 5th", + "badge": "local" + }, + { "t": 1789766373726, "handle": "ess_ay_dee", "text": "👀👀👀" }, + { "t": 1789766381192, "handle": "midtown_mara", "text": "this is insane" }, + { + "t": 1789766393747, + "handle": "avgeek_jfk", + "text": "police helo just lifted out of the downtown heliport", + "badge": "pilot" + }, + { "t": 1789766401349, "handle": "brklyn_bea", "text": "I hear it" }, + { + "t": 1789766410475, + "handle": "nyc_scanner_nerd", + "text": "PD-14 overhead now, orbiting", + "badge": "local" + }, + { "t": 1789766411094, "handle": "deli_guy_dan", "text": "LOUD" }, + { "t": 1789766414564, "handle": "ess_ay_dee", "text": "🔥🔥" }, + { + "t": 1789766416354, + "handle": "hellsk1tchen", + "text": "can see the heli circling from the west side" + }, + { + "t": 1789766420210, + "handle": "throwaway_tom", + "text": "ok not window washers lol" + }, + { + "t": 1789766426239, + "handle": "murrayhill_mo", + "text": "is this a protest?" + }, + { + "t": 1789766430252, + "handle": "kvn_on_34th", + "text": "no banner, they just look like climbers. helmets", + "badge": "first-eyes" + }, + { + "t": 1789766442799, + "handle": "lena.ktown", + "text": "going up to our roof" + }, + { + "t": 1789766460205, + "handle": "jules_flatiron", + "text": "clip sealed from 5th & 29th", + "badge": "witness" + }, + { + "t": 1789766471407, + "handle": "brklyn_bea", + "text": "how did they even get out there" + }, + { + "t": 1789766484933, + "handle": "avgeek_jfk", + "text": "orbit looks ~1,100 ft, tight, maybe 500 m radius", + "badge": "pilot" + }, + { + "t": 1789766498611, + "handle": "midtown_mara", + "text": "they are not moving" + }, + { "t": 1789766514188, "handle": "ess_ay_dee", "text": "pray for them fr" }, + { + "t": 1789766527758, + "handle": "nyc_scanner_nerd", + "text": "second helo inbound from jersey", + "badge": "local" + }, + { "t": 1789766539663, "handle": "deli_guy_dan", "text": "news is here" }, + { + "t": 1789766548030, + "handle": "avgeek_jfk", + "text": "NEWS-7 up high, ~1,450", + "badge": "pilot" + }, + { "t": 1789766555781, "handle": "murrayhill_mo", "text": "its on tv now" }, + { "t": 1789766556291, "handle": "brklyn_bea", "text": "channel 7 live rn" }, + { "t": 1789766558836, "handle": "ess_ay_dee", "text": "😮" }, + { + "t": 1789766560599, + "handle": "throwaway_tom", + "text": "tv is 40s behind this chat lmao" + }, + { + "t": 1789766570844, + "handle": "hellsk1tchen", + "text": "two helis circling opposite sides" + }, + { + "t": 1789766590948, + "handle": "kvn_on_34th", + "text": "THEY ARE CLIMBING. the mast", + "badge": "first-eyes" + }, + { "t": 1789766592437, "handle": "midtown_mara", "text": "NO" }, + { "t": 1789766593967, "handle": "jules_flatiron", "text": "oh my god" }, + { "t": 1789766595742, "handle": "deli_guy_dan", "text": "nope nope nope" }, + { "t": 1789766595949, "handle": "ess_ay_dee", "text": "😮😮😮" }, + { "t": 1789766600423, "handle": "brklyn_bea", "text": "im shaking" }, + { + "t": 1789766605323, + "handle": "lena.ktown", + "text": "on the roof, I can see them on the east side", + "badge": "local" + }, + { + "t": 1789766611960, + "handle": "murrayhill_mo", + "text": "how high is that" + }, + { + "t": 1789766614645, + "handle": "avgeek_jfk", + "text": "mast starts ~1,250 ft. antenna tip 1,454", + "badge": "pilot" + }, + { "t": 1789766632315, "handle": "throwaway_tom", "text": "who does this" }, + { + "t": 1789766642783, + "handle": "nyc_scanner_nerd", + "text": "third helo lifting from E 34th St heliport", + "badge": "local" + }, + { + "t": 1789766651723, + "handle": "penn_plaza_40th", + "text": "from 1 Penn 40th fl. sealed. they are halfway up the mast", + "badge": "witness" + }, + { "t": 1789766653875, "handle": "deli_guy_dan", "text": "thats so close" }, + { + "t": 1789766666228, + "handle": "midtown_mara", + "text": "is that a drone?" + }, + { + "t": 1789766679818, + "handle": "hellsk1tchen", + "text": "drone over by the river too" + }, + { + "t": 1789766698960, + "handle": "avgeek_jfk", + "text": "not a drone, thats SKY-4 coming off the E 34th pad", + "badge": "pilot" + }, + { + "t": 1789766720235, + "handle": "brklyn_bea", + "text": "three helicopters now" + }, + { "t": 1789766724237, "handle": "ess_ay_dee", "text": "🔥🔥🔥" }, + { + "t": 1789766742526, + "handle": "metwx_paul", + "text": "winds ~15 kt from WNW at 1,000+ ft. thats why the orbits look stretched east", + "badge": "met" + }, + { + "t": 1789766757273, + "handle": "jules_flatiron", + "text": "the gusts up there must be brutal" + }, + { "t": 1789766770678, "handle": "murrayhill_mo", "text": "they stopped" }, + { + "t": 1789766789902, + "handle": "kvn_on_34th", + "text": "one is waving??", + "badge": "first-eyes" + }, + { + "t": 1789766800125, + "handle": "hellsk1tchen", + "text": "sealed from the high line, all three helis in frame", + "badge": "witness" + }, + { + "t": 1789766811949, + "handle": "deli_guy_dan", + "text": "crowd on 5th is massive now" + }, + { "t": 1789766823991, "handle": "brklyn_bea", "text": "please come down" }, + { + "t": 1789766841836, + "handle": "lena.ktown", + "text": "they are going higher", + "badge": "witness" + }, + { "t": 1789766852512, "handle": "throwaway_tom", "text": "HOW" }, + { + "t": 1789766860102, + "handle": "kvn_on_34th", + "text": "ONE IS AT THE TOP OF THE MAST", + "badge": "first-eyes" + }, + { "t": 1789766860109, "handle": "midtown_mara", "text": "NOOOO" }, + { + "t": 1789766862350, + "handle": "jules_flatiron", + "text": "oh my god oh my god" + }, + { "t": 1789766863618, "handle": "ess_ay_dee", "text": "😮😮😮😮" }, + { "t": 1789766864543, "handle": "deli_guy_dan", "text": "cant watch" }, + { "t": 1789766867421, "handle": "murrayhill_mo", "text": "insane" }, + { "t": 1789766868521, "handle": "brklyn_bea", "text": "😭" }, + { + "t": 1789766868692, + "handle": "hellsk1tchen", + "text": "the whole avenue just gasped" + }, + { + "t": 1789766875560, + "handle": "penn_plaza_40th", + "text": "whole office is at the window", + "badge": "witness" + }, + { + "t": 1789766887139, + "handle": "heli_dispatch_ret", + "text": "three ships stacked 1,000/1,250/1,450, all left orbits. textbook", + "badge": "pilot" + }, + { + "t": 1789766902829, + "handle": "throwaway_tom", + "text": "helmet cam. this is for a video 100%" + }, + { + "t": 1789766920104, + "handle": "avgeek_jfk", + "text": "NEWS-7 widening out, prob for the wide shot", + "badge": "pilot" + }, + { + "t": 1789766946498, + "handle": "midtown_mara", + "text": "is the deck closed?" + }, + { + "t": 1789766961174, + "handle": "nyc_scanner_nerd", + "text": "scanner says deck cleared, ESU going up", + "badge": "local" + }, + { "t": 1789766982717, "handle": "brklyn_bea", "text": "come on come on" }, + { "t": 1789767004607, "handle": "murrayhill_mo", "text": "whats ESU" }, + { + "t": 1789767011366, + "handle": "nyc_scanner_nerd", + "text": "emergency service unit. rescue specialists", + "badge": "local" + }, + { + "t": 1789767019943, + "handle": "lena.ktown", + "text": "sealed: officers on the 102 deck right under them", + "badge": "witness" + }, + { "t": 1789767021492, "handle": "ess_ay_dee", "text": "🙏" }, + { + "t": 1789767034821, + "handle": "deli_guy_dan", + "text": "they are talking to them i think" + }, + { + "t": 1789767062666, + "handle": "jules_flatiron", + "text": "PD-14 dropping lower" + }, + { + "t": 1789767099217, + "handle": "heli_dispatch_ret", + "text": "police ship tightening the orbit, stepping down to ~1,000", + "badge": "pilot" + }, + { + "t": 1789767130580, + "handle": "throwaway_tom", + "text": "third climber on the setback??" + }, + { "t": 1789767133848, "handle": "midtown_mara", "text": "wait three??" }, + { "t": 1789767140015, "handle": "brklyn_bea", "text": "I see a third one" }, + { + "t": 1789767167798, + "handle": "jules_flatiron", + "text": "thats the mast shadow lol. compare the 5th ave and high line shots", + "badge": "witness" + }, + { + "t": 1789767181784, + "handle": "hellsk1tchen", + "text": "yeah shadow, sun is behind us", + "badge": "witness" + }, + { + "t": 1789767210921, + "handle": "midtown_mara", + "text": "sealed from 38th, the crowd is all phones", + "badge": "witness" + }, + { + "t": 1789767232097, + "handle": "deli_guy_dan", + "text": "sold out of water lol" + }, + { + "t": 1789767258570, + "handle": "murrayhill_mo", + "text": "how long has it been" + }, + { + "t": 1789767263134, + "handle": "kvn_on_34th", + "text": "16 min since I saw them", + "badge": "first-eyes" + }, + { "t": 1789767290992, "handle": "ess_ay_dee", "text": "❤️❤️" }, + { "t": 1789767316410, "handle": "brklyn_bea", "text": "they are moving" }, + { + "t": 1789767330779, + "handle": "lena.ktown", + "text": "coming DOWN", + "badge": "witness" + }, + { "t": 1789767332756, "handle": "midtown_mara", "text": "YES" }, + { "t": 1789767335013, "handle": "deli_guy_dan", "text": "thank god" }, + { "t": 1789767335178, "handle": "ess_ay_dee", "text": "❤️❤️❤️" }, + { "t": 1789767354436, "handle": "throwaway_tom", "text": "slowly. slowly" }, + { + "t": 1789767390589, + "handle": "jules_flatiron", + "text": "first one at the rail" + }, + { + "t": 1789767418631, + "handle": "penn_plaza_40th", + "text": "officers reaching over the rail", + "badge": "witness" + }, + { + "t": 1789767440738, + "handle": "kvn_on_34th", + "text": "ONE IS IN", + "badge": "first-eyes" + }, + { "t": 1789767441838, "handle": "brklyn_bea", "text": "😭😭" }, + { "t": 1789767443828, "handle": "midtown_mara", "text": "ok im crying" }, + { + "t": 1789767458764, + "handle": "lena.ktown", + "text": "SECOND ONE IN", + "badge": "witness" + }, + { "t": 1789767461971, "handle": "ess_ay_dee", "text": "❤️🔥❤️🔥" }, + { + "t": 1789767464006, + "handle": "murrayhill_mo", + "text": "the street is clapping" + }, + { + "t": 1789767464239, + "handle": "rooftop_rafa", + "text": "sealed from murray hill, both over the rail", + "badge": "witness" + }, + { "t": 1789767464355, "handle": "deli_guy_dan", "text": "LETS GOOO" }, + { + "t": 1789767470125, + "handle": "hellsk1tchen", + "text": "cheering from the high line too" + }, + { + "t": 1789767490174, + "handle": "throwaway_tom", + "text": "they are so arrested" + }, + { + "t": 1789767520037, + "handle": "nyc_scanner_nerd", + "text": "scanner: two in custody, no injuries reported", + "badge": "local" + }, + { + "t": 1789767537435, + "handle": "avgeek_jfk", + "text": "SKY-4 departing east, next story", + "badge": "pilot" + }, + { + "t": 1789767549906, + "handle": "deli_guy_dan", + "text": "sealed one of SKY-4 leaving", + "badge": "witness" + }, + { + "t": 1789767574895, + "handle": "jules_flatiron", + "text": "what a day for midtown" + }, + { + "t": 1789767609219, + "handle": "midtown_mara", + "text": "the replay of this is gonna be wild" + }, + { + "t": 1789767638835, + "handle": "brklyn_bea", + "text": "thank you everyone for the updates" + }, + { + "t": 1789767673602, + "handle": "heli_dispatch_ret", + "text": "NEWS-7 and PD-14 still up. will hold till the street clears", + "badge": "pilot" + }, + { + "t": 1789767726348, + "handle": "murrayhill_mo", + "text": "traffic on 5th still stopped" + }, + { + "t": 1789767760677, + "handle": "kvn_on_34th", + "text": "cant believe I just looked up at the right time", + "badge": "first-eyes" + } + ], + "posts": [ + { + "id": "p1", + "t": 1789766338000, + "handle": "kvn_on_34th", + "kind": "witness", + "text": "Two people outside the safety fence on the 86th floor setback, north face. Sealed photo from W 34th St & 6th Ave, 22° zoom.", + "votes": 412, + "captureId": "c1" + }, + { + "id": "p2", + "t": 1789766440000, + "handle": "midtown_mara", + "kind": "question", + "text": "Is the observation deck being cleared? Is anyone still up there?", + "votes": 88 + }, + { + "id": "p3", + "t": 1789766490000, + "handle": "nyc_scanner_nerd", + "kind": "context", + "text": "Police aviation is on scene, orbiting at about 1,100 ft. News helicopters usually follow within minutes.", + "votes": 230 + }, + { + "id": "p4", + "t": 1789766655000, + "handle": "penn_plaza_40th", + "kind": "witness", + "text": "From 1 Penn Plaza, 40th floor: both are on the mooring mast, east side, about halfway up. Sealed clip.", + "votes": 377, + "captureId": "c3" + }, + { + "id": "p5", + "t": 1789766705000, + "handle": "avgeek_jfk", + "kind": "correction", + "text": "The \"drone\" in clips around 6:30 is SKY-4 lifting out of the East 34th St heliport. Its track matches.", + "votes": 156 + }, + { + "id": "p6", + "t": 1789766750000, + "handle": "metwx_paul", + "kind": "context", + "text": "Wind at 1,000–1,500 ft is about 15 kt from the WNW. That is why every orbit looks stretched toward the East River.", + "votes": 141 + }, + { + "id": "p7", + "t": 1789766895000, + "handle": "heli_dispatch_ret", + "kind": "context", + "text": "Three helicopters holding 1,000, 1,250 and 1,450 ft in left-hand orbits. Staggered altitudes are normal deconfliction.", + "votes": 264 + }, + { + "id": "p8", + "t": 1789767025000, + "handle": "lena.ktown", + "kind": "witness", + "text": "Rooftop in Koreatown: officers visible on the 102nd floor deck directly below the climbers. Sealed.", + "votes": 198, + "captureId": "c5" + }, + { + "id": "p9", + "t": 1789767175000, + "handle": "jules_flatiron", + "kind": "correction", + "text": "There is no third climber. The figure on the setback is the mast's shadow: compare the 5th Ave and High Line captures, taken 6 minutes apart.", + "votes": 301 + }, + { + "id": "p10", + "t": 1789767250000, + "handle": "brklyn_bea", + "kind": "question", + "text": "Has anyone been hurt?", + "votes": 64 + }, + { + "id": "p11", + "t": 1789767470000, + "handle": "rooftop_rafa", + "kind": "witness", + "text": "Both are back over the rail at the 102nd floor and officers have them. Sealed clip from Murray Hill.", + "votes": 520, + "captureId": "c7" + }, + { + "id": "p12", + "t": 1789767525000, + "handle": "nyc_scanner_nerd", + "kind": "context", + "text": "Scanner traffic: two in custody, no injuries reported. Unconfirmed until an official statement.", + "votes": 187 + } + ], + "sources": [ + { + "name": "Illustrative reconstruction", + "detail": "Helicopter tracks are synthetic, from a flight model (constant airspeed, 14 kt wind, rate-limited turns) shaped like real news and police orbits. Callsigns and tail numbers are fictional and are not real registrations." + }, + { + "name": "NYC Open Data · Building Footprints", + "detail": "Real footprints and roof heights for Midtown (NYC OTI, dataset 5zhs-2jue)." + }, + { + "name": "Esri World Imagery", + "detail": "Base imagery of the real place." + }, + { + "name": "Simulated Live and Record lanes", + "detail": "Chat, posts, handles and witness captures are simulated to show how a room forms around an event." + } + ] +} diff --git a/mobile/demo/snapshot.json b/mobile/demo/snapshot.json new file mode 100644 index 000000000..2c20eab6b --- /dev/null +++ b/mobile/demo/snapshot.json @@ -0,0 +1,1660 @@ +{ + "capturedAt": "2026-10-23T07:19:58.550Z", + "source": "Live God’s Eye feeds through the dev server (see each card’s source)", + "note": "Bundled first frame for demos. The shell shows capturedAt and replaces these with live cards as soon as situations() resolves.", + "situations": [ + { + "id": "quake-cluster-us6000u43g", + "kind": "quake-cluster", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "number", + "telemetry": "GROUND · 11 EVENTS · 24 H · MAX M7.0 · 50 KM", + "title": "11 earthquakes in 24 h near Nagqu, China", + "subtitle": "Largest M7.0 · first 14:33Z · USGS", + "place": "184 km ENE of Nagqu, China", + "lon": 93.7797, + "lat": 32.3805, + "camera": { + "lon": 93.7797, + "lat": 32.3805, + "height": 260000, + "heading": 0, + "pitch": -55 + }, + "layers": ["earthquakes"], + "time": { + "start": 1792679620353, + "end": 1792724020661 + }, + "metrics": [ + { + "label": "Quakes", + "value": 11, + "unit": "" + }, + { + "label": "Largest", + "value": "7.0", + "unit": "M" + } + ], + "headline": { + "value": 11, + "unit": "", + "label": "quakes in 24 h" + }, + "series": [ + { + "t": 1792679620353, + "v": 7 + }, + { + "t": 1792681924462, + "v": 5.2 + }, + { + "t": 1792684675210, + "v": 4.3 + }, + { + "t": 1792686093822, + "v": 4.9 + }, + { + "t": 1792687500942, + "v": 4.6 + }, + { + "t": 1792687816850, + "v": 4.5 + }, + { + "t": 1792688273999, + "v": 4.7 + }, + { + "t": 1792692404294, + "v": 5 + }, + { + "t": 1792715057688, + "v": 4.4 + }, + { + "t": 1792715711461, + "v": 4.1 + }, + { + "t": 1792724020661, + "v": 4.2 + } + ], + "seriesLabel": "magnitude per event", + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=93.30103,31.84151,94.25837,32.91949&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792724020661, + "source": "U.S. Geological Survey · cluster detected by God’s Eye", + "severity": 6, + "detected": true, + "thumbFile": "thumbs/quake-cluster-us6000u43g.jpg" + }, + { + "id": "cyclone-EONET_25339", + "kind": "cyclone", + "family": "Hazards", + "section": "now", + "band": "orbit", + "archetype": "sensor", + "telemetry": "ORBIT · LW IR · TY CHAMPI · CAT 2 · 90 KT", + "title": "Super Typhoon Champi", + "subtitle": "167 km/h winds · 345 km SE of Taipei", + "place": "Western Pacific", + "lon": 123.8, + "lat": 22.7, + "camera": { + "lon": 123.8, + "lat": 22.7, + "height": 2600000, + "heading": 0, + "pitch": -75 + }, + "layers": ["cyclones", "clouds", "lightning", "wind"], + "time": { + "start": 1792713600000, + "end": 1792713600000 + }, + "metrics": [ + { + "label": "Wind", + "value": 167, + "unit": "km/h" + } + ], + "headline": { + "value": 167, + "unit": "km/h", + "label": "CAT 2" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=118.68787,16.41182,128.91213,28.98818&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868840, + "source": "NASA EONET · IR: NOAA nowCOAST", + "severity": 8.25, + "thumbFile": "thumbs/cyclone-EONET_25339.jpg" + }, + { + "id": "squawk-4bb0e8", + "kind": "squawk", + "family": "Sky", + "section": "now", + "band": "sky", + "archetype": "track", + "telemetry": "SKY · FL417 · 539 KT · SQ 7700 · THY4MS", + "title": "THY4MS squawking 7700", + "subtitle": "General emergency · 41,700 ft · 728 km NW of Istanbul", + "place": "728 km NW of Istanbul", + "lon": 21.3533, + "lat": 44.3994, + "camera": { + "lon": 21.3533, + "lat": 44.3994, + "height": 120000, + "heading": 132.6, + "pitch": -45 + }, + "layers": ["squawk", "flights"], + "metrics": [ + { + "label": "Squawk", + "value": "7700", + "unit": "" + }, + { + "label": "Altitude", + "value": 41725, + "unit": "ft" + }, + { + "label": "Ground speed", + "value": 539, + "unit": "kt" + } + ], + "headline": { + "value": "7700", + "unit": "", + "label": "General emergency" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=20.78752,43.86041,21.91908,44.93839&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739887455, + "source": "OpenSky Network", + "severity": 7, + "momentId": "live-squawk-4bb0e8", + "thumbFile": "thumbs/squawk-4bb0e8.jpg" + }, + { + "id": "cyclone-ep222026", + "kind": "cyclone", + "family": "Hazards", + "section": "now", + "band": "orbit", + "archetype": "sensor", + "telemetry": "ORBIT · LW IR · TS VANCE · 60 KT · 991 HPA", + "title": "Tropical storm Vance", + "subtitle": "111 km/h winds · moving NW at 11 km/h · 739 km S of Acapulco", + "place": "Eastern Pacific", + "lon": -101.9, + "lat": 10.5, + "camera": { + "lon": -101.9, + "lat": 10.5, + "height": 2600000, + "heading": 0, + "pitch": -75 + }, + "layers": ["cyclones", "clouds", "lightning", "wind"], + "time": { + "start": 1792724400000, + "end": 1793156400000 + }, + "metrics": [ + { + "label": "Wind", + "value": 111, + "unit": "km/h" + }, + { + "label": "Pressure", + "value": 991, + "unit": "hPa" + }, + { + "label": "Gale radius", + "value": 167, + "unit": "km" + }, + { + "label": "Forecast", + "value": 120, + "unit": "h" + } + ], + "headline": { + "value": 111, + "unit": "km/h", + "label": "TS" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-106.69645,4.21182,-97.10355,16.78818&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868840, + "source": "NOAA NHC · NHC wind radii · IR: NOAA nowCOAST", + "severity": 7.5, + "thumbFile": "thumbs/cyclone-ep222026.jpg" + }, + { + "id": "lightning--22-146", + "kind": "lightning", + "family": "Weather", + "section": "now", + "band": "sky", + "archetype": "number", + "telemetry": "SKY · LIGHTNING · 15 MIN · 147,090 KM² · 06:45Z", + "title": "Thunderstorms · 592 km S of Cairns", + "subtitle": "41 lightning-active 0.5° cells, intense strike density in the last 15 min", + "place": "592 km S of Cairns", + "lon": 146.13071682060476, + "lat": -22.23122251384317, + "camera": { + "lon": 146.13071682060476, + "lat": -22.23122251384317, + "height": 1389278.948409936, + "heading": 0, + "pitch": -70 + }, + "layers": ["lightning", "clouds"], + "time": { + "start": 1792727100000, + "end": 1792737900000 + }, + "metrics": [ + { + "label": "Active area", + "value": 147090, + "unit": "km²" + }, + { + "label": "Active cells", + "value": 41, + "unit": "" + } + ], + "headline": { + "value": "147,090", + "unit": "km²", + "label": "lightning-active area, 15 min" + }, + "series": [ + { + "t": 1792727100000, + "v": 110462 + }, + { + "t": 1792728000000, + "v": 119598 + }, + { + "t": 1792728900000, + "v": 112087 + }, + { + "t": 1792729800000, + "v": 121311 + }, + { + "t": 1792730700000, + "v": 135470 + }, + { + "t": 1792731600000, + "v": 131391 + }, + { + "t": 1792732500000, + "v": 140477 + }, + { + "t": 1792733400000, + "v": 139776 + }, + { + "t": 1792734300000, + "v": 139813 + }, + { + "t": 1792735200000, + "v": 151432 + }, + { + "t": 1792736100000, + "v": 144057 + }, + { + "t": 1792737000000, + "v": 153871 + }, + { + "t": 1792737900000, + "v": 147090 + } + ], + "seriesLabel": "lightning-active area (km²) per 15 min", + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=143.83260,-25.06760,148.42883,-19.39485&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792737900000, + "source": "NOAA nowCOAST lightning density (Vaisala NLDN/GLD360)", + "severity": 4.945, + "thumbFile": "thumbs/lightning--22-146.jpg" + }, + { + "id": "cyclone-EONET_25457", + "kind": "cyclone", + "family": "Hazards", + "section": "now", + "band": "orbit", + "archetype": "sensor", + "telemetry": "ORBIT · LW IR · TC AGUEDA · 50 KT", + "title": "Tropical Cyclone Agueda", + "subtitle": "93 km/h winds · 1,375 km N of Antananarivo", + "place": "South Indian Ocean", + "lon": 49.7, + "lat": -6.7, + "camera": { + "lon": 49.7, + "lat": -6.7, + "height": 2600000, + "heading": 0, + "pitch": -75 + }, + "layers": ["cyclones", "clouds", "lightning", "wind"], + "time": { + "start": 1792692000000, + "end": 1792692000000 + }, + "metrics": [ + { + "label": "Wind", + "value": 93, + "unit": "km/h" + } + ], + "headline": { + "value": 93, + "unit": "km/h", + "label": "TS" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=44.95144,-12.98818,54.44856,-0.41182&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868840, + "source": "NASA EONET · IR: NOAA nowCOAST", + "severity": 7.25, + "thumbFile": "thumbs/cyclone-EONET_25457.jpg" + }, + { + "id": "gnss-baltic", + "kind": "gnss", + "family": "Infra", + "section": "now", + "band": "sky", + "archetype": "number", + "telemetry": "SKY · GNSS · 17% DEGRADED · 102 AIRCRAFT · 250 NM", + "title": "GNSS interference · Baltic Sea", + "subtitle": "17 of 102 aircraft report degraded GPS integrity (low NIC/NACp)", + "place": "Baltic Sea", + "lon": 21, + "lat": 56, + "camera": { + "lon": 21, + "lat": 56, + "height": 1100000, + "heading": 0, + "pitch": -80 + }, + "layers": ["gnss", "flights"], + "metrics": [ + { + "label": "Degraded aircraft", + "value": 17, + "unit": "" + }, + { + "label": "Sampled aircraft", + "value": 102, + "unit": "" + }, + { + "label": "Anomalous cells", + "value": 0, + "unit": "" + } + ], + "headline": { + "value": 17, + "unit": "%", + "label": "aircraft with degraded GNSS" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=16.78309,52.85591,25.21691,59.14409&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739888000, + "source": "adsb.lol NIC/NACp · gpsjam.org bands (a proxy for jamming, not proof)", + "severity": 3.1333333333333333, + "thumbFile": "thumbs/gnss-baltic.jpg" + }, + { + "id": "quake-us6000u43g", + "kind": "earthquake", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "sensor", + "telemetry": "GROUND · M7.0 · 18 KM DEEP · 14:33:40Z", + "title": "M7.0 earthquake", + "subtitle": "Largest in 24 h · 17 h ago · 10 other M2.5+ within 400 km this week", + "place": "191 km ENE of Nagqu, China", + "lon": 93.7797, + "lat": 32.3805, + "camera": { + "lon": 93.7797, + "lat": 32.3805, + "height": 450000, + "heading": 0, + "pitch": -65 + }, + "layers": ["earthquakes"], + "time": { + "start": 1792679620353, + "end": 1792739868848 + }, + "metrics": [ + { + "label": "Magnitude", + "value": 7, + "unit": "M" + }, + { + "label": "Depth", + "value": 18, + "unit": "km" + }, + { + "label": "M2.5+ in 24 h", + "value": 47, + "unit": "" + } + ], + "headline": { + "value": "7.0", + "unit": "M", + "label": "magnitude" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=92.82236,31.30253,94.73704,33.45847&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868825, + "source": "USGS", + "severity": 7, + "thumbFile": "thumbs/quake-us6000u43g.jpg" + }, + { + "id": "radar-salt-lake-city", + "kind": "radar", + "family": "Weather", + "section": "now", + "band": "sky", + "archetype": "sensor", + "telemetry": "SKY · MRMS · 41 DBZ · SALT LAKE CITY · 07:07Z", + "title": "Heavy rain over Salt Lake City", + "subtitle": "Radar returns to ~41 dBZ within 45 km · 15 heavy-echo pixels", + "place": "Salt Lake City", + "lon": -111.89, + "lat": 40.76, + "camera": { + "lon": -111.89, + "lat": 40.76, + "height": 160000, + "heading": 0, + "pitch": -55 + }, + "layers": ["radar", "lightning"], + "time": { + "start": 1792736407000, + "end": 1792739267000 + }, + "metrics": [ + { + "label": "Peak reflectivity", + "value": 41, + "unit": "dBZ" + }, + { + "label": "Frames", + "value": 13, + "unit": "" + } + ], + "headline": { + "value": 41, + "unit": "dBZ", + "label": "peak reflectivity" + }, + "series": [ + { + "t": 1792736407000, + "v": 33 + }, + { + "t": 1792736649000, + "v": 33 + }, + { + "t": 1792736881000, + "v": 41 + }, + { + "t": 1792737125000, + "v": 41 + }, + { + "t": 1792737351000, + "v": 33 + }, + { + "t": 1792737603000, + "v": 41 + }, + { + "t": 1792737850000, + "v": 41 + }, + { + "t": 1792738079000, + "v": 33 + }, + { + "t": 1792738327000, + "v": 41 + }, + { + "t": 1792738565000, + "v": 41 + }, + { + "t": 1792738809000, + "v": 41 + }, + { + "t": 1792739044000, + "v": 41 + }, + { + "t": 1792739267000, + "v": 41 + } + ], + "seriesLabel": "peak reflectivity (dBZ) within 45 km", + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-112.42368,40.22101,-111.35632,41.29899&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739267000, + "source": "NOAA MRMS base reflectivity via nowCOAST (dBZ read from colour scale)", + "severity": 4.1, + "thumbFile": "thumbs/radar-salt-lake-city.jpg" + }, + { + "id": "aq-jakarta", + "kind": "air-quality", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "number", + "telemetry": "GROUND · PM2.5 68 µG/M³ · AQI 189 · CAMS", + "title": "Unhealthy air · Jakarta", + "subtitle": "PM2.5 AQI 189 · worst of 40 major cities (model, not a monitor)", + "place": "Jakarta", + "lon": 106.85, + "lat": -6.21, + "camera": { + "lon": 106.85, + "lat": -6.21, + "height": 60000, + "heading": 0, + "pitch": -45 + }, + "layers": ["air-quality", "fires", "wind"], + "metrics": [ + { + "label": "PM2.5 AQI", + "value": 189, + "unit": "" + }, + { + "label": "PM2.5", + "value": 68, + "unit": "µg/m³" + } + ], + "headline": { + "value": 189, + "unit": "AQI", + "label": "US air quality index" + }, + "series": [ + { + "t": 1792648800000, + "v": 51 + }, + { + "t": 1792652400000, + "v": 48.5 + }, + { + "t": 1792656000000, + "v": 47.8 + }, + { + "t": 1792659600000, + "v": 50.1 + }, + { + "t": 1792663200000, + "v": 55.2 + }, + { + "t": 1792666800000, + "v": 89.6 + }, + { + "t": 1792670400000, + "v": 125.7 + }, + { + "t": 1792674000000, + "v": 141.1 + }, + { + "t": 1792677600000, + "v": 155.5 + }, + { + "t": 1792681200000, + "v": 163.4 + }, + { + "t": 1792684800000, + "v": 163.9 + }, + { + "t": 1792688400000, + "v": 160.2 + }, + { + "t": 1792692000000, + "v": 155.1 + }, + { + "t": 1792695600000, + "v": 149 + }, + { + "t": 1792699200000, + "v": 143.4 + }, + { + "t": 1792702800000, + "v": 138.3 + }, + { + "t": 1792706400000, + "v": 138.3 + }, + { + "t": 1792710000000, + "v": 147.6 + }, + { + "t": 1792713600000, + "v": 123.9 + }, + { + "t": 1792717200000, + "v": 93.8 + }, + { + "t": 1792720800000, + "v": 78.7 + }, + { + "t": 1792724400000, + "v": 72.6 + }, + { + "t": 1792728000000, + "v": 70.5 + }, + { + "t": 1792731600000, + "v": 62.6 + }, + { + "t": 1792735200000, + "v": 70.1 + }, + { + "t": 1792738800000, + "v": 68 + } + ], + "seriesLabel": "PM2.5 (µg/m³), last 24 h", + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=106.64669,-6.47949,107.05331,-5.94051&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792738800000, + "source": "Open-Meteo Air Quality API (CAMS forecast model)", + "severity": 2.9833333333333334, + "thumbFile": "thumbs/aq-jakarta.jpg" + }, + { + "id": "lightning--15-130", + "kind": "lightning", + "family": "Weather", + "section": "now", + "band": "sky", + "archetype": "sensor", + "telemetry": "SKY · LIGHTNING · 15 MIN · 79,459 KM² · 06:45Z", + "title": "Lightning cell · 254 km S of Darwin", + "subtitle": "31 lightning-active 0.5° cells, intense strike density in the last 15 min", + "place": "254 km S of Darwin", + "lon": 130.24373698308528, + "lat": -14.6711709665922, + "camera": { + "lon": 130.24373698308528, + "lat": -14.6711709665922, + "height": 1435334.507588173, + "heading": 0, + "pitch": -70 + }, + "layers": ["lightning", "clouds"], + "time": { + "start": 1792727100000, + "end": 1792737900000 + }, + "metrics": [ + { + "label": "Active area", + "value": 79459, + "unit": "km²" + }, + { + "label": "Active cells", + "value": 31, + "unit": "" + } + ], + "headline": { + "value": "79,459", + "unit": "km²", + "label": "lightning-active area, 15 min" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=127.97186,-17.60157,132.51561,-11.74077&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792737900000, + "source": "NOAA nowCOAST lightning density (Vaisala NLDN/GLD360)", + "severity": 3.74, + "thumbFile": "thumbs/lightning--15-130.jpg" + }, + { + "id": "quakes-24h", + "kind": "earthquake", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "number", + "telemetry": "GROUND · USGS · 47 EVENTS M2.5+ · 24 H", + "title": "47 earthquakes M2.5+ in 24 h", + "subtitle": "Worldwide · largest M7.0 · 191 km ENE of Nagqu, China", + "place": "Worldwide", + "lon": 93.86139090909091, + "lat": 32.43457272727273, + "camera": { + "lon": 93.86139090909091, + "lat": 32.43457272727273, + "height": 18000000, + "heading": 0, + "pitch": -90 + }, + "layers": ["earthquakes"], + "time": { + "start": 1792653468848, + "end": 1792739868848 + }, + "metrics": [ + { + "label": "M2.5+ in 24 h", + "value": 47, + "unit": "" + } + ], + "headline": { + "value": 47, + "unit": "", + "label": "quakes M2.5+ · 24 h" + }, + "series": [ + { + "t": 1792657068848, + "v": 3 + }, + { + "t": 1792660668848, + "v": 2 + }, + { + "t": 1792664268848, + "v": 2 + }, + { + "t": 1792667868848, + "v": 2 + }, + { + "t": 1792671468848, + "v": 0 + }, + { + "t": 1792675068848, + "v": 1 + }, + { + "t": 1792678668848, + "v": 0 + }, + { + "t": 1792682268848, + "v": 3 + }, + { + "t": 1792685868848, + "v": 4 + }, + { + "t": 1792689468848, + "v": 6 + }, + { + "t": 1792693068848, + "v": 2 + }, + { + "t": 1792696668848, + "v": 2 + }, + { + "t": 1792700268848, + "v": 2 + }, + { + "t": 1792703868848, + "v": 1 + }, + { + "t": 1792707468848, + "v": 3 + }, + { + "t": 1792711068848, + "v": 0 + }, + { + "t": 1792714668848, + "v": 3 + }, + { + "t": 1792718268848, + "v": 2 + }, + { + "t": 1792721868848, + "v": 2 + }, + { + "t": 1792725468848, + "v": 3 + }, + { + "t": 1792729068848, + "v": 0 + }, + { + "t": 1792732668848, + "v": 0 + }, + { + "t": 1792736268848, + "v": 2 + }, + { + "t": 1792739868848, + "v": 2 + } + ], + "seriesLabel": "M2.5+ quakes per hour", + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=61.93107,-3.49787,125.79171,68.36702&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868825, + "source": "USGS", + "severity": 2, + "thumbFile": "thumbs/quakes-24h.jpg" + }, + { + "id": "launch-7766f3bb-674c-4c71-b986-963bd633fcfe", + "kind": "launch", + "family": "Orbit", + "section": "now", + "band": "orbit", + "archetype": "sensor", + "telemetry": "ORBIT · T+00:06 · ELECTRON · SSO", + "title": "Electron | We're Not Hawking Around (3x HawkEye 360)", + "subtitle": "Rocket Lab · launched 7 min ago · Rocket Lab Launch Complex 1A", + "place": "Rocket Lab Launch Complex 1, Mahia Peninsula, New Zealand", + "lon": 177.864469, + "lat": -39.262833, + "camera": { + "lon": 177.864469, + "lat": -39.262833, + "height": 30000, + "heading": 0, + "pitch": -40 + }, + "layers": ["launches", "iss"], + "time": { + "start": 1792735860000, + "end": 1792743060000 + }, + "metrics": [ + { + "label": "NET", + "value": "2026-10-23T07:11:00.000Z", + "unit": "utc" + }, + { + "label": "Orbit", + "value": "SSO", + "unit": "" + }, + { + "label": "Status", + "value": "In Flight", + "unit": "" + } + ], + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=176.82026,-40.34081,178.90868,-38.18486&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739870188, + "source": "The Space Devs · Launch Library 2 · ascent azimuth indicative", + "severity": 3, + "thumbFile": "thumbs/launch-7766f3bb-674c-4c71-b986-963bd633fcfe.jpg" + }, + { + "id": "eye-tfl-00001.07450", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 07450 · PICCADILLY CIRCUS · 07:18:09Z", + "title": "Piccadilly Circus", + "subtitle": "London · Transport for London · looking N", + "place": "London", + "lon": -0.13484, + "lat": 51.5096, + "camera": { + "lon": -0.13484, + "lat": 51.5096, + "height": 600, + "heading": 337.5, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "N", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/tfl-00001.07450?label=Piccadilly+Circus&city=London&lat=51.509600&lon=-0.134840&heading=338&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "tfl-00001.07450", + "headingDeg": 337.5, + "provider": "Transport for London", + "city": "London" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-0.14567,51.50062,-0.12401,51.51858&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739889195, + "source": "Transport for London public camera", + "severity": 1.7, + "thumbFile": "thumbs/eye-tfl-00001.07450.jpg" + }, + { + "id": "military--31-116", + "kind": "military", + "family": "Sky", + "section": "now", + "band": "sky", + "archetype": "sensor", + "telemetry": "SKY · MIL · 13 AIRCRAFT · PC21", + "title": "Military air activity · Australia", + "subtitle": "13 military aircraft · PC21 · 60 km N of Perth", + "place": "60 km N of Perth", + "lon": 115.9501956923077, + "lat": -31.418267230769228, + "camera": { + "lon": 115.9501956923077, + "lat": -31.418267230769228, + "height": 900000, + "heading": 0, + "pitch": -70 + }, + "layers": ["military"], + "metrics": [ + { + "label": "In area", + "value": 13, + "unit": "" + }, + { + "label": "Tracked worldwide", + "value": 125, + "unit": "" + } + ], + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=113.89754,-33.75388,118.00285,-29.08266&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739869930, + "source": "adsb.lol", + "severity": 2.5, + "thumbFile": "thumbs/military--31-116.jpg" + }, + { + "id": "eye-tfl-00001.06502", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 06502 · TRAFALGAR SQUARE · 07:18:09Z", + "title": "Trafalgar Square", + "subtitle": "London · Transport for London · looking SE", + "place": "London", + "lon": -0.12765, + "lat": 51.5074, + "camera": { + "lon": -0.12765, + "lat": 51.5074, + "height": 600, + "heading": 135, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "SE", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/tfl-00001.06502?label=Trafalgar+Square&city=London&lat=51.507400&lon=-0.127650&heading=135&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "tfl-00001.06502", + "headingDeg": 135, + "provider": "Transport for London", + "city": "London" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-0.13847,51.49842,-0.11683,51.51638&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739889203, + "source": "Transport for London public camera", + "severity": 1.65, + "thumbFile": "thumbs/eye-tfl-00001.06502.jpg" + }, + { + "id": "jet--48-144", + "kind": "jet", + "family": "Weather", + "section": "now", + "band": "sky", + "archetype": "sensor", + "telemetry": "SKY · 250 HPA · FL340 · 139 KT · 48.0S 144.0E", + "title": "Jet stream core · 258 km/h", + "subtitle": "Fastest 250 hPa wind on a 12° global grid · 1,136 km S of Melbourne", + "place": "1,136 km S of Melbourne", + "lon": 144, + "lat": -48, + "camera": { + "lon": 144, + "lat": -48, + "height": 7500000, + "heading": 0, + "pitch": -90 + }, + "layers": ["jet", "clouds"], + "metrics": [ + { + "label": "Core speed", + "value": 258, + "unit": "km/h" + }, + { + "label": "Level", + "value": 250, + "unit": "hPa" + } + ], + "headline": { + "value": 139, + "unit": "kt", + "label": "jet core at FL340" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=118.82803,-70.45778,169.17197,-25.54222&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792738800000, + "source": "Open-Meteo forecast API · 250 hPa (12° grid)", + "severity": 2.475, + "thumbFile": "thumbs/jet--48-144.jpg" + }, + { + "id": "eye-tfl-00001.03500", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 03500 · TOWER BRIDGE APPROACH · 07:18:09Z", + "title": "Tower Bridge approach", + "subtitle": "London · Transport for London · looking NE", + "place": "London", + "lon": -0.07368, + "lat": 51.509, + "camera": { + "lon": -0.07368, + "lat": 51.509, + "height": 600, + "heading": 22.5, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "NE", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/tfl-00001.03500?label=Tower+Bridge+App.%2FEast+Smithfield&city=London&lat=51.509000&lon=-0.073680&heading=23&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "tfl-00001.03500", + "headingDeg": 22.5, + "provider": "Transport for London", + "city": "London" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-0.08450,51.50002,-0.06286,51.51798&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739889341, + "source": "Transport for London public camera", + "severity": 1.5999999999999999, + "thumbFile": "thumbs/eye-tfl-00001.03500.jpg" + }, + { + "id": "airport-LHR", + "kind": "airport", + "family": "Sky", + "section": "now", + "band": "sky", + "archetype": "sensor", + "telemetry": "SKY · LHR · 70 AIRCRAFT < FL130 · 50 KM", + "title": "Busiest airspace · LHR", + "subtitle": "70 aircraft below 4 km within 50 km of London Heathrow", + "place": "London Heathrow", + "lon": -0.45, + "lat": 51.47, + "camera": { + "lon": -0.45, + "lat": 51.47, + "height": 60000, + "heading": 20, + "pitch": -45 + }, + "layers": ["flights", "ga", "helicopters"], + "metrics": [ + { + "label": "Low aircraft", + "value": 70, + "unit": "" + }, + { + "label": "Airborne worldwide", + "value": 5740, + "unit": "" + } + ], + "headline": { + "value": 70, + "unit": "", + "label": "aircraft below FL130" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-0.88263,51.11068,-0.01737,51.82932&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739887455, + "source": "OpenSky Network", + "severity": 1.5, + "thumbFile": "thumbs/airport-LHR.jpg" + }, + { + "id": "eye-nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 899C8 · SYDNEY HARBOUR BRIDGE · 07:18:09Z", + "title": "Sydney Harbour Bridge", + "subtitle": "Sydney · Live Traffic NSW · looking SW", + "place": "Sydney", + "lon": 151.205623, + "lat": -33.865088, + "camera": { + "lon": 151.205623, + "lat": -33.865088, + "height": 600, + "heading": 225, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "SW", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8?label=York+Street+at+Margaret+Street+looking+north+towards+Sydney+Harbour+Bridge.&city=SYD+MET&lat=-33.865088&lon=151.205623&heading=225&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8", + "headingDeg": 225, + "provider": "Live Traffic NSW", + "city": "SYD MET" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=151.19751,-33.87407,151.21374,-33.85610&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739889979, + "source": "Live Traffic NSW public camera", + "severity": 1.55, + "thumbFile": "thumbs/eye-nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8.jpg" + }, + { + "id": "starlink-shell", + "kind": "starlink", + "family": "Orbit", + "section": "now", + "band": "orbit", + "archetype": "number", + "telemetry": "ORBIT · STARLINK · 10,651 SATS · 367 WITHIN 2,000 KM", + "title": "10,651 Starlink satellites in orbit", + "subtitle": "367 within 2,000 km of 1,401 km W of San Francisco right now", + "place": "1,401 km W of San Francisco", + "lon": -138.3690118858408, + "lat": 40, + "camera": { + "lon": -138.3690118858408, + "lat": 40, + "height": 9000000, + "heading": 0, + "pitch": -90 + }, + "layers": ["starlink"], + "metrics": [ + { + "label": "In orbit", + "value": 10651, + "unit": "" + }, + { + "label": "Within 2,000 km", + "value": 367, + "unit": "" + } + ], + "headline": { + "value": "10,651", + "unit": "", + "label": "Starlink satellites" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-164.75391,13.05066,-111.98412,66.94934&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868848, + "source": "CelesTrak TLE · SGP4", + "severity": 1.4, + "thumbFile": "thumbs/starlink-shell.jpg" + }, + { + "id": "bhote-koshi-2026", + "kind": "reconstruction", + "family": "Hazards", + "section": "reconstruction", + "band": "ground", + "archetype": "sensor", + "telemetry": "GROUND · RECON · 20.7 KM CORRIDOR · 20260826", + "title": "Bhote Koshi Outburst Flood", + "subtitle": "Reconstruction · 16 evidence beats · 2021 vs 2026 imagery", + "place": "Rasuwa, Nepal", + "lon": 85.3548, + "lat": 28.207, + "camera": { + "lon": 85.3548, + "lat": 28.207, + "height": 5412, + "heading": 344, + "pitch": -39, + "targetHeight": 1536 + }, + "layers": ["floods"], + "time": { + "start": 1787702400000, + "end": 1787745600000, + "at": 1787722200000 + }, + "metrics": [ + { + "label": "Corridor", + "value": 20.7, + "unit": "km" + }, + { + "label": "Witness anchors", + "value": 1, + "unit": "" + }, + { + "label": "Field reports", + "value": 4, + "unit": "" + } + ], + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=85.28599,28.12615,85.42361,28.28785&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": false, + "updatedAt": 1787702400000, + "source": "GeoPera · Vantor Open Data · bundled event pack", + "severity": 4, + "thumbFile": "thumbs/bhote-koshi-2026.jpg" + }, + { + "id": "eye-nsw-5e35e07b-beda-4590-b9eb-e3d52705242e", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 05242 · GEORGE STREET, RAILWAY · 07:18:10Z", + "title": "George Street, Railway Square", + "subtitle": "Sydney · Live Traffic NSW · looking NE", + "place": "Sydney", + "lon": 151.2041, + "lat": -33.88291, + "camera": { + "lon": 151.2041, + "lat": -33.88291, + "height": 600, + "heading": 45, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "NE", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/nsw-5e35e07b-beda-4590-b9eb-e3d52705242e?label=Railway+Square%2C+George+Street+looking+north+towards+Sydney+CBD.&city=SYD+MET&lat=-33.882910&lon=151.204100&heading=45&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "nsw-5e35e07b-beda-4590-b9eb-e3d52705242e", + "headingDeg": 45, + "provider": "Live Traffic NSW", + "city": "SYD MET" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=151.19598,-33.89189,151.21222,-33.87393&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739890281, + "source": "Live Traffic NSW public camera", + "severity": 1.5, + "thumbFile": "thumbs/eye-nsw-5e35e07b-beda-4590-b9eb-e3d52705242e.jpg" + }, + { + "id": "fires-29.7--94.2", + "kind": "fires", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "sensor", + "telemetry": "GROUND · EONET · WIND 8 KM/H → S · 29.7N 94.2W", + "title": "Wildfire Star Lake", + "subtitle": "1 open wildfire event nearby · smoke drifting S on 8 km/h winds", + "place": "117 km E of Houston", + "lon": -94.158617, + "lat": 29.664158, + "camera": { + "lon": -94.158617, + "lat": 29.664158, + "height": 80000, + "heading": 177, + "pitch": -45 + }, + "layers": ["fires", "wind", "air-quality"], + "metrics": [ + { + "label": "Events", + "value": 1, + "unit": "" + }, + { + "label": "Wind", + "value": 8, + "unit": "km/h" + }, + { + "label": "Worldwide", + "value": 71, + "unit": "" + } + ], + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-94.39122,29.39466,-93.92601,29.93365&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739868840, + "source": "NASA EONET wildfire events · wind: Open-Meteo", + "severity": 3.02, + "thumbFile": "thumbs/fires-29.7--94.2.jpg" + }, + { + "id": "eye-fi-c0167400", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 67400 · RUOHOLAHTI, HELSINKI · 07:18:10Z", + "title": "Ruoholahti, Helsinki", + "subtitle": "Helsinki · Fintraffic · looking N", + "place": "Helsinki", + "lon": 24.910959, + "lat": 60.16591, + "camera": { + "lon": 24.910959, + "lat": 60.16591, + "height": 600, + "heading": 0, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "N", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/fi-c0167400?label=kt51+Helsinki+Ruoholahti+%28view+00%29&city=Finland&lat=60.165910&lon=24.910959&heading=0&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "fi-c0167400", + "headingDeg": 0, + "provider": "Fintraffic", + "city": "Finland" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=24.89742,60.15693,24.92450,60.17489&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739890048, + "source": "Fintraffic public camera", + "severity": 1.45, + "thumbFile": "thumbs/eye-fi-c0167400.jpg" + }, + { + "id": "transit-translink-seq", + "kind": "transit", + "family": "Ground", + "section": "now", + "band": "ground", + "archetype": "sensor", + "telemetry": "GROUND · GTFS-RT · 1574 VEHICLES · 17:17 LOCAL", + "title": "Rush hour · South East Queensland", + "subtitle": "1574 TransLink vehicles reporting · 0 moving · 17:17 local time", + "place": "South East Queensland, Australia", + "lon": 153.0450072176869, + "lat": -27.496741579591838, + "camera": { + "lon": 153.0450072176869, + "lat": -27.496741579591838, + "height": 18000, + "heading": 0, + "pitch": -50 + }, + "layers": ["transit"], + "metrics": [ + { + "label": "Vehicles", + "value": 1574, + "unit": "" + }, + { + "label": "Moving", + "value": 0, + "unit": "" + } + ], + "headline": { + "value": 1574, + "unit": "", + "label": "vehicles live" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=152.96905,-27.58657,153.12096,-27.40691&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739888623, + "source": "TransLink GTFS-realtime · TransLink — Queensland Government (CC BY 4.0)", + "severity": 1.6, + "thumbFile": "thumbs/transit-translink-seq.jpg" + }, + { + "id": "eye-tln-103", + "kind": "camera", + "family": "Eyes", + "section": "now", + "band": "ground", + "archetype": "eye", + "telemetry": "GROUND · CAM 103 · VIRU SQUARE · 07:18:10Z", + "title": "Viru Square", + "subtitle": "Tallinn · City of Tallinn · looking NE", + "place": "Tallinn", + "lon": 24.752702, + "lat": 59.436563, + "camera": { + "lon": 24.752702, + "lat": 59.436563, + "height": 600, + "heading": 60.10000000000002, + "pitch": -25 + }, + "layers": ["cctv"], + "metrics": [ + { + "label": "Looking", + "value": "NE", + "unit": "" + } + ], + "media": { + "kind": "image", + "url": "/api/cctv/frame/tln-103?label=Viru+v%C3%A4ljak+%28suund+Mere+pst+ja+Narva+mnt%29&city=Tallinn&lat=59.436563&lon=24.752702&heading=60&fov=44&pitch=-18&ts=179273988", + "refreshMs": 30000, + "cameraId": "tln-103", + "headingDeg": 60.10000000000002, + "provider": "City of Tallinn", + "city": "Tallinn" + }, + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=24.73945,59.42758,24.76595,59.44555&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": true, + "updatedAt": 1792739890561, + "source": "City of Tallinn public camera", + "severity": 1.4, + "thumbFile": "thumbs/eye-tln-103.jpg" + }, + { + "id": "volcano-EONET_20710", + "kind": "volcano", + "family": "Hazards", + "section": "now", + "band": "ground", + "archetype": "sensor", + "telemetry": "GROUND · VOLCANO · 36.9S 71.4W · EONET", + "title": "Nevados del Chillan Volcano", + "subtitle": "Open eruption event since 2026-06-15 · 385 km S of Santiago", + "place": "Chile", + "lon": -71.378, + "lat": -36.868, + "camera": { + "lon": -71.378, + "lat": -36.868, + "height": 25000, + "heading": 0, + "pitch": -40 + }, + "layers": ["volcanoes"], + "metrics": [], + "thumbnail": "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-71.47906,-36.97580,-71.27694,-36.76020&bboxSR=4326&imageSR=3857&size=600,800&format=jpg&f=image", + "live": false, + "updatedAt": 1781481600000, + "source": "NASA EONET", + "severity": 1.3, + "thumbFile": "thumbs/volcano-EONET_20710.jpg" + } + ] +} diff --git a/mobile/demo/thumbs/airport-LHR.jpg b/mobile/demo/thumbs/airport-LHR.jpg new file mode 100644 index 000000000..fd785c064 Binary files /dev/null and b/mobile/demo/thumbs/airport-LHR.jpg differ diff --git a/mobile/demo/thumbs/aq-jakarta.jpg b/mobile/demo/thumbs/aq-jakarta.jpg new file mode 100644 index 000000000..775d663d1 Binary files /dev/null and b/mobile/demo/thumbs/aq-jakarta.jpg differ diff --git a/mobile/demo/thumbs/bhote-koshi-2026.jpg b/mobile/demo/thumbs/bhote-koshi-2026.jpg new file mode 100644 index 000000000..392d8510f Binary files /dev/null and b/mobile/demo/thumbs/bhote-koshi-2026.jpg differ diff --git a/mobile/demo/thumbs/cyclone-EONET_25339.jpg b/mobile/demo/thumbs/cyclone-EONET_25339.jpg new file mode 100644 index 000000000..4582e8d60 Binary files /dev/null and b/mobile/demo/thumbs/cyclone-EONET_25339.jpg differ diff --git a/mobile/demo/thumbs/cyclone-EONET_25457.jpg b/mobile/demo/thumbs/cyclone-EONET_25457.jpg new file mode 100644 index 000000000..2ca15b8bf Binary files /dev/null and b/mobile/demo/thumbs/cyclone-EONET_25457.jpg differ diff --git a/mobile/demo/thumbs/cyclone-ep222026.jpg b/mobile/demo/thumbs/cyclone-ep222026.jpg new file mode 100644 index 000000000..c357e2141 Binary files /dev/null and b/mobile/demo/thumbs/cyclone-ep222026.jpg differ diff --git a/mobile/demo/thumbs/eye-fi-c0167400.jpg b/mobile/demo/thumbs/eye-fi-c0167400.jpg new file mode 100644 index 000000000..98d2d4a68 Binary files /dev/null and b/mobile/demo/thumbs/eye-fi-c0167400.jpg differ diff --git a/mobile/demo/thumbs/eye-nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8.jpg b/mobile/demo/thumbs/eye-nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8.jpg new file mode 100644 index 000000000..6f275053c Binary files /dev/null and b/mobile/demo/thumbs/eye-nsw-58472235-c8aa-4ac4-8bbd-10ea610899c8.jpg differ diff --git a/mobile/demo/thumbs/eye-nsw-5e35e07b-beda-4590-b9eb-e3d52705242e.jpg b/mobile/demo/thumbs/eye-nsw-5e35e07b-beda-4590-b9eb-e3d52705242e.jpg new file mode 100644 index 000000000..e259c4f58 Binary files /dev/null and b/mobile/demo/thumbs/eye-nsw-5e35e07b-beda-4590-b9eb-e3d52705242e.jpg differ diff --git a/mobile/demo/thumbs/eye-tfl-00001.03500.jpg b/mobile/demo/thumbs/eye-tfl-00001.03500.jpg new file mode 100644 index 000000000..6e534fc14 Binary files /dev/null and b/mobile/demo/thumbs/eye-tfl-00001.03500.jpg differ diff --git a/mobile/demo/thumbs/eye-tfl-00001.06502.jpg b/mobile/demo/thumbs/eye-tfl-00001.06502.jpg new file mode 100644 index 000000000..60755a3fe Binary files /dev/null and b/mobile/demo/thumbs/eye-tfl-00001.06502.jpg differ diff --git a/mobile/demo/thumbs/eye-tfl-00001.07450.jpg b/mobile/demo/thumbs/eye-tfl-00001.07450.jpg new file mode 100644 index 000000000..3b4fd4b53 Binary files /dev/null and b/mobile/demo/thumbs/eye-tfl-00001.07450.jpg differ diff --git a/mobile/demo/thumbs/eye-tln-103.jpg b/mobile/demo/thumbs/eye-tln-103.jpg new file mode 100644 index 000000000..90e48f2c2 Binary files /dev/null and b/mobile/demo/thumbs/eye-tln-103.jpg differ diff --git a/mobile/demo/thumbs/fires-29.7--94.2.jpg b/mobile/demo/thumbs/fires-29.7--94.2.jpg new file mode 100644 index 000000000..c2546bc5b Binary files /dev/null and b/mobile/demo/thumbs/fires-29.7--94.2.jpg differ diff --git a/mobile/demo/thumbs/gnss-baltic.jpg b/mobile/demo/thumbs/gnss-baltic.jpg new file mode 100644 index 000000000..dd6099c0c Binary files /dev/null and b/mobile/demo/thumbs/gnss-baltic.jpg differ diff --git a/mobile/demo/thumbs/jet--48-144.jpg b/mobile/demo/thumbs/jet--48-144.jpg new file mode 100644 index 000000000..358873c2b Binary files /dev/null and b/mobile/demo/thumbs/jet--48-144.jpg differ diff --git a/mobile/demo/thumbs/launch-7766f3bb-674c-4c71-b986-963bd633fcfe.jpg b/mobile/demo/thumbs/launch-7766f3bb-674c-4c71-b986-963bd633fcfe.jpg new file mode 100644 index 000000000..81f63fe89 Binary files /dev/null and b/mobile/demo/thumbs/launch-7766f3bb-674c-4c71-b986-963bd633fcfe.jpg differ diff --git a/mobile/demo/thumbs/lightning--15-130.jpg b/mobile/demo/thumbs/lightning--15-130.jpg new file mode 100644 index 000000000..0b94496e2 Binary files /dev/null and b/mobile/demo/thumbs/lightning--15-130.jpg differ diff --git a/mobile/demo/thumbs/lightning--22-146.jpg b/mobile/demo/thumbs/lightning--22-146.jpg new file mode 100644 index 000000000..acca870ff Binary files /dev/null and b/mobile/demo/thumbs/lightning--22-146.jpg differ diff --git a/mobile/demo/thumbs/military--31-116.jpg b/mobile/demo/thumbs/military--31-116.jpg new file mode 100644 index 000000000..f8c33d32a Binary files /dev/null and b/mobile/demo/thumbs/military--31-116.jpg differ diff --git a/mobile/demo/thumbs/quake-cluster-us6000u43g.jpg b/mobile/demo/thumbs/quake-cluster-us6000u43g.jpg new file mode 100644 index 000000000..df611edf5 Binary files /dev/null and b/mobile/demo/thumbs/quake-cluster-us6000u43g.jpg differ diff --git a/mobile/demo/thumbs/quake-us6000u43g.jpg b/mobile/demo/thumbs/quake-us6000u43g.jpg new file mode 100644 index 000000000..dfcdbe33e Binary files /dev/null and b/mobile/demo/thumbs/quake-us6000u43g.jpg differ diff --git a/mobile/demo/thumbs/quakes-24h.jpg b/mobile/demo/thumbs/quakes-24h.jpg new file mode 100644 index 000000000..e5b1dbf48 Binary files /dev/null and b/mobile/demo/thumbs/quakes-24h.jpg differ diff --git a/mobile/demo/thumbs/radar-salt-lake-city.jpg b/mobile/demo/thumbs/radar-salt-lake-city.jpg new file mode 100644 index 000000000..876f84a4d Binary files /dev/null and b/mobile/demo/thumbs/radar-salt-lake-city.jpg differ diff --git a/mobile/demo/thumbs/squawk-4bb0e8.jpg b/mobile/demo/thumbs/squawk-4bb0e8.jpg new file mode 100644 index 000000000..9468d9b33 Binary files /dev/null and b/mobile/demo/thumbs/squawk-4bb0e8.jpg differ diff --git a/mobile/demo/thumbs/starlink-shell.jpg b/mobile/demo/thumbs/starlink-shell.jpg new file mode 100644 index 000000000..00bb3a038 Binary files /dev/null and b/mobile/demo/thumbs/starlink-shell.jpg differ diff --git a/mobile/demo/thumbs/transit-translink-seq.jpg b/mobile/demo/thumbs/transit-translink-seq.jpg new file mode 100644 index 000000000..78358696b Binary files /dev/null and b/mobile/demo/thumbs/transit-translink-seq.jpg differ diff --git a/mobile/demo/thumbs/volcano-EONET_20710.jpg b/mobile/demo/thumbs/volcano-EONET_20710.jpg new file mode 100644 index 000000000..5b6c8dd97 Binary files /dev/null and b/mobile/demo/thumbs/volcano-EONET_20710.jpg differ diff --git a/mobile/globe/API.md b/mobile/globe/API.md index f2751534c..3ae6d5411 100644 --- a/mobile/globe/API.md +++ b/mobile/globe/API.md @@ -111,3 +111,168 @@ When NHC has published an advisory but its cone geometry is still pending, the c - `?lat=&lon=` sets the viewer. - `?only=cyclone,eye` filters cards by id prefix. - `?w=330` sets the card width. + +--- + +# Round three: Gotham for everyone (DESIGN.md §12) + +Additive. Nothing above changes. Every call below exists on the object `createGlobe()` resolves to. Times are epoch ms unless a `Date` is shown. + +## Instant first frame + +```js +globe.situations({ cached: true }) → Promise + // resolves at once from the last good IndexedDB snapshot (written by every live + // situations() call), else the bundled mobile/demo/snapshot.json (real data). + // Each cached Situation adds: cached: true, cacheOrigin: 'device' | 'bundled', + // capturedAt (epoch ms), live: false, thumbUrl (bundled /mobile/demo/thumbs/.jpg + // or a Cache API blob URL) or null. +globe.situations() → Promise // live, as before (also saves the cache) +globe.cachedThumbnail(situation) → string | null // sync; thumbUrl for a cached card +globe.thumbnail(cachedSituation) → resolves to the cached JPEG when the card has no live scene +``` + +The globe paints its first frame with imagery only. Live layers start right after it, and weather, transit, GNSS, Starlink and satellites start about a second later. Background warm-ups (jet, TCM, AQ, CCTV, rasters) start at 4 s. + +## Recorder and time machine + +```js +globe.history() → { start, end, entities, points, bytes } // recorded range; start/end null when empty +globe.setTime(t) // unchanged. Inside the recorded range, contacts are drawn at their interpolated + // recorded positions with 4-minute ghost trails (pickable: 'pick' kind is the + // contact's kind, meta.layer 'history', entityId). Beyond the record, dimmed as before. +globe.trackOf(entityId) → Promise<[{ t, lon, lat, altM, headingDeg, speed }]> + // recorder samples merged with /api/flights/track (OpenSky) or /api/military/track + // (adsb.lol traces); the array has .source + +globe.playback.play({ speed = 60, from?, until? } = {}) → state + // speeds: 1, 10, 30, 60, 600. From live it replays the last 15 min. Reaching "now" goes live; + // inside a Moment it stops at the Moment's end. +globe.playback.stop() → state +globe.playback.state() → { playing, speed, t, live } +globe.playback.speeds // [1, 10, 30, 60, 600] + // event 'playback' → state, on start/stop and every 250 ms while playing. + // 'time' is also emitted every 250 ms while playing ({ live:false, time, playing:true }). + // Playing runs the render loop; at rest the globe is request-render again. + +globe.timeline({ from, to } = {}) → [{ t, kind, band, title, severity, situationId?, entityId?, momentId?, lon?, lat? }] + // kind: 'quake' | 'quake-cluster' | 'launch' | 'squawk' | 'cyclone' | 'fire' | 'circling' + // | 'lightning' | 'moment' (a Moment beat) | 'capture' | 'post' | 'chat-burst' + // band: 'orbit' | 'sky' | 'ground' | 'inside'; severity 0..3; sorted by t. + // Defaults to timeWindow(). Moment items appear for Moments that were loaded and overlap the range. +``` + +The recorder keeps every poll for low traffic (helicopters, approaches, anything below about 6 km) and one fix every 50 s for cruise traffic. Samples older than 30 min are thinned. The buffer is capped at 1.2 M samples (about 24 MB) and persisted to IndexedDB about once a minute, so a reload keeps up to 6 h. When OpenSky is down, the recorder also polls adsb.lol snapshots around New York, London, Los Angeles and the viewer every 15 s, so the detector has real data. + +Entity ids are layer-qualified: `flights:`, `military:`, `satellites:`, `earthquakes:`, `cctv:`, `vessels:`, `situation:`, `place:`, `moment:`, `moment::`, `capture::`. Every `'pick'` payload can be passed to `entity()` as is. + +## Detection + +Detections run on recorder data every poll. They appear only when real data shows them. + +- `circling`: two or more aircraft (rotorcraft and low-and-slow preferred, below about 8,000 ft and 155 kt), each turning through at least 360° within about 1.5 km of a common centre in the last 20 min. Card: `{ kind:'circling', band:'sky', archetype:'track', title:'3 helicopters circling Midtown Manhattan', momentId:'live-circling-…', members:[{ key, layer, callsign, helicopter }], entityIds, detected:true }`. Its thumbnail draws the recorded orbit tracks. +- `quake-cluster`: three or more M2.5+ earthquakes within 50 km in 24 h. Archetype `number`, with a magnitude series. +- `squawk` cards now carry `momentId: 'live-squawk-'`. + +```js +globe.detections() → Situation[] // current detections, sync +// event 'detections' → detector output, when the set of circling detections changes +``` + +## Moments + +```js +globe.moments() → Promise // live (circling, squawks) first, then the bundled hero +globe.moment(id) → Promise // 'empire-state' | 'live-circling-…' | 'live-squawk-' +globe.momentOfTheDay() → Promise // best live Moment if any, else the hero +globe.playMoment(idOrMoment, { speed, camera = true, autoplay = true, framing = 6 } = {}) → Promise + // speed defaults to moment.recommendedSpeed (hero: 30 → 50 s). camera:false leaves the camera alone. + // framing: degrees the cinematic camera looks below the subject (puts it in the upper half). + // Hides every live layer, draws tracks (glyph, 90 s bright trail, faint flown path, drop line), + // capture view frustums that pop in at their t, the subject building and its beacon, and flies + // the camera path keyed to the clock. Touching the globe releases the camera. +globe.exitMoment({ restoreCamera = true } = {}) // back to live (or the time before) and the old camera +globe.activeMoment() → { id, title, illustrative, t, start, end, playing, speed, cinematic, moment } | null +globe.seekMoment(t) // epoch ms, or a 0..1 fraction of the Moment +globe.momentCamera(on = true) // re-attach (or release) the cinematic camera → boolean +// event 'moment' → { type, item, t, momentId } +// type: 'start' (item = Moment) | 'capture' | 'chat' | 'post' | 'beat' | 'end' | 'exit' +// | 'camera' (item = { cinematic:false } when the person takes the camera) +// Items fire as the clock passes them while playing, and on small seeks. A seek back, or a jump of +// more than 90 s while paused, repositions silently: render the Live/Record lanes by filtering +// activeMoment().moment.chat/posts/captures by t <= activeMoment().t. +``` + +```ts +Moment = { + id, title, place, lon, lat, + time: { start, end }, // epoch ms + illustrative: boolean, // true for the bundled hero; false for live detections + illustrativeNote?: string, + recommendedSpeed?: number, + subject?: { lon, lat, altM, label, roofM?, antennaM?, decks? }, + cameraPath: [{ t, lon, lat, height /* m above ground */, heading, pitch }], + beats?: [{ t, title }], + tracks: [{ id, kind /* 'helicopter'|'aircraft' */, label, operator, callsign?, registration?, type?, + color?, entityId? /* live: 'flights:' */, points: [{ t, lon, lat, altM /* MSL */ }] }], + captures: [{ id, t, lon, lat, altM, headingDeg, pitchDeg, fovDeg, rangeM, title, handle, place, + sealed, firstEyes?, kind /* 'photo'|'clip' */, image? }], + chat: [{ t, handle, text, badge? /* 'first-eyes'|'witness'|'local'|'pilot'|'met' */ }], + posts: [{ id, t, handle, kind /* 'witness'|'context'|'question'|'correction' */, text, votes, captureId? }], + sources: [{ name, detail }], +} +``` + +The hero is `mobile/demo/moments/empire-state.json` (id `empire-state`): "Climbers on the Empire State Building", 25 min, 3 helicopters, 8 captures, 120 chat lines and 12 posts. Regenerate it with `node mobile/demo/build-empire-state.mjs`. Its Midtown massing is real NYC Open Data footprints and roof heights in `mobile/demo/midtown-buildings.json` (`node mobile/demo/build-midtown.mjs`). + +## Entities and dossiers + +```js +globe.entity(ref) → Promise // ref: entity id string, a 'pick' payload, or { kind, id } +Dossier = { + id, kind, title, subtitle, + identity: { icao24?, callsign?, registration?, type?, typeCode?, operator?, route?, country?, squawk?, + norad?, intlDesignator?, tle?, mmsi?, provider?, magnitude?, illustrative?, ... }, + live: { lon, lat, altM, speed /* m/s */, heading, squawk?, updatedAt, speedKt?, elevationDeg? } | null, + track: [{ t, lon, lat, altM }], + events: [{ t, title }], + links: [{ id, kind, title, relation, distanceKm? }], + sources: [{ name, fetchedAt, url?, hash /* 'sha256:…' (or 'fnv1a:…' outside secure contexts) */, detail? }], + privacy?: 'pia' | 'ladd' | 'no-public-identity', // identity then holds only what the transponder broadcasts + trackPending?: true, // the server track was slow; call trackOf(id) later for the full one + nextPass?: { start, max, end, maxElevationDeg, visible }, // satellites, for the viewer + illustrative?: true, // hero Moment tracks and captures +} +globe.search(query) → Promise<[{ id, kind, title, subtitle }]> // ≤ 30; "N46567", "UAL", "7700", + // "M5.2", "ISS", "Midtown", "empire"… across live aircraft, the record, satellites, quakes, + // cameras, situations, places (neighbourhoods, airports, cities) and Moments +globe.graph(ref) → { center, nodes: [{ id, kind, title }], edges: [{ from, to, relation }] } // ≤ 40 nodes, sync +``` + +Kinds: `aircraft`, `helicopter`, `military`, `satellite`, `vessel`, `quake`, `camera`, `situation`, `place`, `moment`, `track`, `capture`. There are never person entities. Aircraft dossiers wait at most 2.5 s for the server track (aircraft identity comes from adsbdb, 3.5 s budget). + +## Reactions and attention + +```js +globe.react({ lon, lat, kind: 'heart'|'fire'|'eyes'|'wow', count = 1, altM = 0 }) → number +globe.attentionHeat(points | null) // points: [{ lon, lat, weight? }]; soft glow where viewers are +``` + +Reactions draw on a screen-space canvas that the globe owns (`.gev-reactions`, pointer-events none, above the globe and below your HTML). Each glyph stays anchored to its point as the globe moves. At most 300 are alive at once, and the canvas animates only while some are alive. + +## Your sky now + +```js +globe.skyNow({ lon, lat } = viewer) → Promise<{ + at, observer, sunElevationDeg, + aircraft: [{ id, title, kind, lon, lat, altM, distanceKm, elevationDeg, azimuthDeg, headingDeg, speedMps, squawk }], + satellites: [{ id, title, norad, altKm, elevationDeg, azimuthDeg }], + iss: { visibleNow, aboveHorizon, elevationDeg, azimuthDeg, + nextPass: { start, max, end, maxElevationDeg, riseAzimuthDeg, visible } | null }, + sources: [string], +}> // aircraft within 50 km, satellites above the horizon; each list sorted by elevation, highest first +``` + +## Dev harness + +`mobile/globe/dev.html?moment=empire-state&speed=30` plays a Moment on load and prints its events in the HUD. `globe.debug` exposes `{ recorder, detector, stage, ghosts }` for tests. It is not part of the contract. diff --git a/mobile/globe/cache.js b/mobile/globe/cache.js new file mode 100644 index 000000000..192fab247 --- /dev/null +++ b/mobile/globe/cache.js @@ -0,0 +1,147 @@ +/** + * Instant first frame (DESIGN.md §12.8): the last good situations and their + * thumbnails, so the feed paints before any live feed answers. + * + * 1. IndexedDB: the last live situations() result in this browser + * 2. else the bundled snapshot, mobile/demo/snapshot.json (real data, + * captured by mobile/demo/capture-snapshot.mjs; see `capturedAt`) + * + * Thumbnails: the last rendered JPEG per situation id from the Cache API + * (secure contexts), else the bundled mobile/demo/thumbs/.jpg. + */ +import { idbGet, idbPut } from './idb.js'; + +const SNAPSHOT_URL = new URL('../demo/snapshot.json', import.meta.url).href; +const BUNDLED_THUMBS = import.meta.glob('../demo/thumbs/*.jpg', { + eager: true, + query: '?url', + import: 'default', +}); +const LAST_CACHE = 'gev-thumbs-last-v1'; +const cacheApi = () => + typeof caches !== 'undefined' && globalThis.isSecureContext; + +const bundledThumb = new Map(); +for (const [path, url] of Object.entries(BUNDLED_THUMBS)) { + const id = decodeURIComponent( + path + .split('/') + .pop() + .replace(/\.jpg$/, ''), + ); + bundledThumb.set(id, url); +} +const cachedThumb = new Map(); // id → blob: URL from the Cache API + +export function thumbFileName(id) { + return `${String(id).replace(/[^\w.-]+/g, '_')}.jpg`; +} + +function bundledFor(id) { + return ( + bundledThumb.get(thumbFileName(id).replace(/\.jpg$/, '')) || + bundledThumb.get(id) || + null + ); +} + +/** Sync: the best cached thumbnail URL for a situation, or null. */ +export function cachedThumbnail(situation) { + const id = situation?.id; + if (!id) return null; + return cachedThumb.get(id) || bundledFor(id) || situation.thumbUrl || null; +} + +/** Remember the last rendered thumbnail for an id (Cache API). */ +export async function rememberThumbnail(id, blob) { + if (!cacheApi() || !blob) return; + try { + const c = await caches.open(LAST_CACHE); + await c.put( + `${location.origin}/__gev-last/${encodeURIComponent(id)}`, + new Response(blob, { headers: { 'Content-Type': 'image/jpeg' } }), + ); + } catch { + /* quota or private mode */ + } +} + +async function hydrateThumbs(list) { + if (!cacheApi()) return; + try { + const c = await caches.open(LAST_CACHE); + await Promise.all( + list.map(async (s) => { + if (cachedThumb.has(s.id)) return; + const hit = await c.match( + `${location.origin}/__gev-last/${encodeURIComponent(s.id)}`, + ); + if (hit) cachedThumb.set(s.id, URL.createObjectURL(await hit.blob())); + }), + ); + } catch { + /* ignore */ + } +} + +let bundledPromise = null; +function loadBundled() { + if (!bundledPromise) + bundledPromise = fetch(SNAPSHOT_URL) + .then((r) => (r.ok ? r.json() : null)) + .catch(() => null); + return bundledPromise; +} +// Start the bundled fetch at import so a cached call never waits on it. +loadBundled(); + +function decorate(list, capturedAt, origin) { + return list.map((s) => ({ + ...s, + cached: true, + cacheOrigin: origin, + capturedAt, + live: false, + thumbUrl: cachedThumb.get(s.id) || bundledFor(s.id) || s.thumbUrl || null, + })); +} + +/** + * The last good situations, fast. Resolves [] only when there is nothing at + * all (no IndexedDB snapshot and no bundled file). + */ +export async function loadCachedSituations() { + const stored = await Promise.race([ + idbGet('kv', 'situations'), + new Promise((r) => setTimeout(() => r(null), 60)), + ]); + if (stored?.list?.length) { + hydrateThumbs(stored.list); + return decorate(stored.list, stored.capturedAt, 'device'); + } + const bundled = await loadBundled(); + if (bundled?.situations?.length) + return decorate( + bundled.situations, + Date.parse(bundled.capturedAt) || bundled.capturedAt, + 'bundled', + ); + return []; +} + +/** Store a live situations() result as the next first frame. */ +export function saveSituations(list) { + if (!list?.length) return; + const clean = list.map((s) => { + const { thumbUrl, cached, cacheOrigin, ...rest } = s; + void thumbUrl; + void cached; + void cacheOrigin; + return rest; + }); + idbPut('kv', 'situations', { capturedAt: Date.now(), list: clean }).catch( + () => {}, + ); +} + +export const hasBundledThumb = (id) => Boolean(bundledFor(id)); diff --git a/mobile/globe/compositor.js b/mobile/globe/compositor.js index 337719928..844eafc0c 100644 --- a/mobile/globe/compositor.js +++ b/mobile/globe/compositor.js @@ -24,6 +24,7 @@ import { cctvFrameUrl } from './feeds.js'; import { aqiColor, sampleField } from './feedsWeather.js'; import { strikeLevel } from './layers/weather.js'; import { BLACK_MARBLE_URL } from './imagery.js'; +import { cachedThumbnail, rememberThumbnail } from './cache.js'; const D2R = Math.PI / 180; const ESRI_TILE = (z, x, y) => @@ -1469,6 +1470,53 @@ const SCENE_DRAW = { vignette(g, W, H, 0.5); }, + /** Detected circling: each aircraft's real recorded orbit track. */ + async circling(g, view, sc, dpr) { + await base(g, view, 'sky'); + tint(g, view.W, view.H, 'sky', 0.38); + const colors = [ + 'rgba(94,200,255,1)', + 'rgba(255,209,102,1)', + 'rgba(255,159,107,1)', + 'rgba(155,225,93,1)', + 'rgba(201,167,255,1)', + ]; + const [cx, cy] = view.project(sc.lon, sc.lat); + for (const km of [0.5, 1, 1.5]) { + g.beginPath(); + g.arc(cx, cy, km * view.pxPerKm, 0, Math.PI * 2); + g.strokeStyle = 'rgba(160,210,255,0.28)'; + g.setLineDash([2 * dpr, 5 * dpr]); + g.lineWidth = 1 * dpr; + g.stroke(); + } + g.setLineDash([]); + (sc.tracks || []).forEach((tr, i) => { + const css = colors[i % colors.length]; + if (tr.points?.length > 1) { + pathLonLat(g, view, tr.points); + glowStroke(g, css.replace(',1)', ',0.85)'), 2.2 * dpr, 10 * dpr); + } + const last = tr.points?.at(-1); + if (last) { + const [x, y] = view.project(last[0], last[1]); + if (tr.helicopter) heliGlyph(g, x, y, 15 * dpr, css); + else planeGlyph(g, x, y, tr.heading || 0, 13 * dpr, css); + } + }); + g.save(); + g.globalCompositeOperation = 'lighter'; + g.drawImage( + glowSprite('rgba(255,209,102,0.9)', 64), + cx - 14 * dpr, + cy - 14 * dpr, + 28 * dpr, + 28 * dpr, + ); + g.restore(); + vignette(g, view.W, view.H); + }, + async plain(g, view, sc) { await base(g, view, sc.band || 'ground'); tint(g, view.W, view.H, sc.band || 'ground'); @@ -1556,6 +1604,11 @@ export function createCompositor({ feeds }) { const d = Math.max(1, Math.min(3, dpr)); const W = Math.round(width * d); const H = Math.round(height * d); + // A cached first-frame card has no scene: hand back its stored JPEG. + if (situation.cached && !SCENES.has(situation.id)) { + const url = cachedThumbnail(situation); + if (url) return Promise.resolve(url); + } const key = keyFor(situation, W, H, d); let p = mem.get(key); if (p) return p; @@ -1571,6 +1624,7 @@ export function createCompositor({ feeds }) { } } const blob = await render(situation, W, H, d); + rememberThumbnail(situation.id, blob); if (cacheApi) caches .open(CACHE_NAME) diff --git a/mobile/globe/detect.js b/mobile/globe/detect.js new file mode 100644 index 000000000..d1f968ac1 --- /dev/null +++ b/mobile/globe/detect.js @@ -0,0 +1,307 @@ +/** + * Detection on real data (DESIGN.md §12.4). Runs over the recorder, never + * over anything invented: when nothing in the record matches, nothing is + * raised. + * + * Circling: an aircraft "orbits" when, within the last ~20 min, its ground + * track turns through at least 360° in one direction while its positions stay + * within ~1.5 km of their centroid. Rotorcraft and low-and-slow contacts are + * preferred (airliners in a holding stack are excluded by altitude and + * speed). Two or more orbiters whose centres lie within ~1.5 km of a common + * centre make a detection: "3 helicopters circling Midtown Manhattan". A + * single aircraft on its second full orbit is a lesser detection + * ("Helicopter circling Lower Manhattan"). + * + * Quake clusters: three or more M2.5+ events within 50 km of each other in + * 24 h, from the USGS feed. + */ +import { haversineKm } from './geo.js'; +import { localPlace, describePlace } from './gazetteer.js'; + +const WINDOW_MS = 20 * 60_000; +const MAX_CENTER_KM = 1.5; +const MAX_ALT_M = 2400; // ~8,000 ft +const MAX_SPEED_MPS = 80; // ~155 kt +const D2R = Math.PI / 180; + +function bearing(a, b) { + const dx = (b.lon - a.lon) * Math.cos(a.lat * D2R); + const dy = b.lat - a.lat; + return (Math.atan2(dx, dy) / D2R + 360) % 360; +} +const metres = (a, b) => + Math.hypot( + (b.lon - a.lon) * 111_320 * Math.cos(a.lat * D2R), + (b.lat - a.lat) * 110_574, + ); + +/** + * Orbit analysis of one track (samples sorted by t). Returns the most recent + * full orbit: { center:{lon,lat}, radiusM, turns, dir, from, to, points } or null. + */ +export function analyseOrbit(samples) { + if (samples.length < 6) return null; + // Thin to points at least 60 m apart so jitter does not fake turning. + const pts = [samples[0]]; + for (const p of samples) if (metres(pts.at(-1), p) >= 60) pts.push(p); + if (pts.length < 6) return null; + // Walk backwards from the newest point accumulating signed turn. + let turn = 0; + let prevB = bearing(pts.at(-2), pts.at(-1)); + let startIdx = -1; + for (let i = pts.length - 2; i >= 1; i--) { + // A gap in the record breaks the orbit. + if (pts[i + 1].t - pts[i].t > 4 * 60_000) break; + const b = bearing(pts[i - 1], pts[i]); + let d = ((prevB - b + 540) % 360) - 180; + // A step that turns > 150° is a sampling artefact, not a turn. + if (Math.abs(d) > 150) d = 0; + turn += d; + prevB = b; + if (Math.abs(turn) >= 360) { + startIdx = i - 1; + break; + } + } + if (startIdx < 0) return null; + const orbit = pts.slice(startIdx); + let lon = 0; + let lat = 0; + for (const p of orbit) { + lon += p.lon; + lat += p.lat; + } + const center = { lon: lon / orbit.length, lat: lat / orbit.length }; + let r = 0; + let rMax = 0; + for (const p of orbit) { + const d = metres(center, p); + r += d; + rMax = Math.max(rMax, d); + } + r /= orbit.length; + if (r > MAX_CENTER_KM * 1000 || rMax > MAX_CENTER_KM * 1600) return null; + if (r < 80) return null; // hovering jitter, not an orbit + // Count full turns over the whole window (for "on its 6th orbit"). + let total = 0; + for (let i = 2; i < pts.length; i++) { + let d = + ((bearing(pts[i - 1], pts[i]) - bearing(pts[i - 2], pts[i - 1]) + 540) % + 360) - + 180; + if (Math.abs(d) > 150) d = 0; + total += d; + } + return { + center, + radiusM: Math.round(r), + turns: Math.max(1, Math.floor(Math.abs(total) / 360)), + dir: turn > 0 ? 'cw' : 'ccw', + from: orbit[0].t, + to: orbit.at(-1).t, + }; +} + +/** "near Port-Olry, Vanuatu" from a USGS place, else from the gazetteer. */ +function clusterPlace(q) { + const usgs = q.place ? q.place.replace(/^.*\bof\s+/, '').trim() : ''; + if (usgs) return `near ${usgs}`; + const p = describePlace(q.lat, q.lon); + if (!p) return ''; + return /\bkm\b/.test(p) ? `, ${p}` : `near ${p}`; +} + +const isCandidate = (meta, s) => + meta && + meta.kind !== 'vessel' && + !meta.onGround && + s.altM < MAX_ALT_M && + (meta.helicopter || s.speed < MAX_SPEED_MPS); + +/** + * @param {ReturnType} recorder + */ +export function createDetector(recorder) { + /** Detections by id (kept while they last, plus a history for pips). */ + const live = new Map(); + const history = []; + let lastRun = 0; + let lastOrbiters = []; + + function circling(now = Date.now()) { + const from = now - WINDOW_MS; + const orbiters = []; + for (const key of recorder.keys()) { + const meta = recorder.meta(key); + if (!meta || meta.kind === 'vessel') continue; + const samples = recorder.samples(key, from, now); + if (samples.length < 6) continue; + const lastS = samples.at(-1); + if (now - lastS.t > 5 * 60_000) continue; // gone quiet + if (!isCandidate(meta, lastS)) continue; + const orbit = analyseOrbit(samples); + if (orbit) orbiters.push({ key, meta, orbit, last: lastS }); + } + lastOrbiters = orbiters; + // Greedy clustering on orbit centres. + const used = new Set(); + const groups = []; + orbiters.sort( + (a, b) => + Number(b.meta.helicopter) - Number(a.meta.helicopter) || + b.orbit.turns - a.orbit.turns, + ); + for (const a of orbiters) { + if (used.has(a.key)) continue; + const g = [a]; + for (const b of orbiters) { + if (b === a || used.has(b.key)) continue; + const km = haversineKm( + a.orbit.center.lat, + a.orbit.center.lon, + b.orbit.center.lat, + b.orbit.center.lon, + ); + if (km <= MAX_CENTER_KM) g.push(b); + } + if (g.length >= 2) { + for (const m of g) used.add(m.key); + groups.push(g); + } + } + // A single aircraft on its second full orbit is a detection too (a + // police or news helicopter holding over a scene), ranked below groups. + const singles = orbiters + .filter((a) => !used.has(a.key) && a.orbit.turns >= 2) + .sort((a, b) => b.orbit.turns - a.orbit.turns) + .slice(0, 4); + for (const a of singles) groups.push([a]); + const out = []; + for (const g of groups) { + let lon = 0; + let lat = 0; + for (const m of g) { + lon += m.orbit.center.lon; + lat += m.orbit.center.lat; + } + lon /= g.length; + lat /= g.length; + const helis = g.filter((m) => m.meta.helicopter).length; + const place = localPlace(lat, lon); + const noun = + g.length === 1 + ? helis + ? 'Helicopter' + : 'Aircraft' + : helis === g.length + ? 'helicopters' + : helis + ? 'aircraft' + : 'low aircraft'; + const id = `circling-${lat.toFixed(2)}_${lon.toFixed(2)}`; + const firstOrbit = Math.min(...g.map((m) => m.orbit.from)); + const prev = live.get(id); + const det = { + id, + kind: 'circling', + title: + g.length === 1 + ? `${noun} circling ${place.name}` + : `${g.length} ${noun} circling ${place.name}`, + single: g.length === 1, + place: place.name, + lon, + lat, + since: prev?.since ?? firstOrbit, + updatedAt: now, + members: g.map((m) => ({ + key: m.key, + layer: m.meta.layer, + callsign: m.meta.callsign || m.key, + helicopter: Boolean(m.meta.helicopter), + radiusM: m.orbit.radiusM, + turns: m.orbit.turns, + dir: m.orbit.dir, + altM: Math.round(m.last.altM), + speed: m.last.speed, + lon: m.last.lon, + lat: m.last.lat, + })), + }; + live.set(id, det); + if (!prev) + history.push({ + t: firstOrbit, + kind: 'circling', + title: det.title, + situationId: id, + momentId: `live-${id}`, + lon, + lat, + }); + out.push(det); + } + // Detections that stopped circling linger 10 min, then go. + for (const [id, d] of live) + if (now - d.updatedAt > 10 * 60_000) live.delete(id); + if (history.length > 200) history.splice(0, history.length - 200); + return out; + } + + function quakeClusters(records, now = Date.now()) { + const recent = (records || []).filter( + (q) => Number.isFinite(q.time) && now - q.time < 86_400_000, + ); + const used = new Set(); + const out = []; + const sorted = recent.slice().sort((a, b) => b.mag - a.mag); + for (const q of sorted) { + if (used.has(q.stableId)) continue; + const near = recent.filter( + (o) => + !used.has(o.stableId) && + haversineKm(q.lat, q.lon, o.lat, o.lon) <= 50, + ); + if (near.length < 3) continue; + for (const o of near) used.add(o.stableId); + const times = near.map((o) => o.time).sort((a, b) => a - b); + out.push({ + id: `quake-cluster-${q.stableId}`, + kind: 'quake-cluster', + title: `${near.length} earthquakes in 24 h ${clusterPlace(q)}`.trim(), + lon: q.lon, + lat: q.lat, + maxMag: q.mag, + count: near.length, + since: times[0], + updatedAt: times.at(-1), + members: near.map((o) => ({ + id: o.stableId, + mag: o.mag, + time: o.time, + lon: o.lon, + lat: o.lat, + place: o.place, + })), + }); + } + return out; + } + + return { + /** Run the circling detector at most every `minGapMs`. */ + run({ force = false, minGapMs = 20_000 } = {}) { + const now = Date.now(); + if (!force && now - lastRun < minGapMs) return [...live.values()]; + lastRun = now; + circling(now); + return [...live.values()]; + }, + current: () => [...live.values()], + get: (id) => live.get(id) || null, + history: () => history.slice(), + /** Single orbiters seen in the last run (diagnostics and dossiers). */ + orbiters: () => lastOrbiters.slice(), + quakeClusters, + }; +} diff --git a/mobile/globe/detectCards.js b/mobile/globe/detectCards.js new file mode 100644 index 000000000..3f000f306 --- /dev/null +++ b/mobile/globe/detectCards.js @@ -0,0 +1,158 @@ +/** + * Situation cards for detections (circling, quake clusters). Same shape as + * situations.js cards, each with a compositor scene of its real data. + */ +import { SCENES } from './situations.js'; +import { thumbnailAround } from './geo.js'; + +const M_TO_FT = 3.28084; +const MPS_TO_KT = 1 / 0.514444; +const hhmm = (ms) => new Date(ms).toISOString().slice(11, 16) + 'Z'; +const fmtLL = (lat, lon) => + `${Math.abs(lat).toFixed(2)}°${lat >= 0 ? 'N' : 'S'} ${Math.abs(lon).toFixed(2)}°${lon >= 0 ? 'E' : 'W'}`; + +export function circlingCard(det, recorder) { + const helis = det.members.filter((m) => m.helicopter).length; + const alts = det.members.map((m) => m.altM).sort((a, b) => a - b); + const radii = det.members.map((m) => m.radiusM).sort((a, b) => a - b); + const turns = det.members.reduce((n, m) => n + m.turns, 0); + const lead = det.members[0]; + const ft = (m) => Math.round((m * M_TO_FT) / 50) * 50; + const id = det.id; + const card = { + id, + kind: 'circling', + family: 'Sky', + section: 'now', + band: 'sky', + archetype: 'track', + telemetry: [ + 'SKY', + `${det.members.length} ${helis === det.members.length ? 'ROTOR' : 'AIRCRAFT'} ORBITING`, + `R ${radii[0]}–${radii.at(-1)} M`, + `${ft(alts[0]).toLocaleString('en-US')}–${ft(alts.at(-1)).toLocaleString('en-US')} FT`, + lead?.callsign ? String(lead.callsign).toUpperCase() : null, + ] + .filter(Boolean) + .join(' · '), + title: det.title, + subtitle: `${det.members.map((m) => m.callsign).join(', ')} · ${turns} orbits since ${hhmm(det.since)} · detected from ADS-B`, + place: det.place, + lon: det.lon, + lat: det.lat, + camera: { + lon: det.lon, + lat: det.lat, + height: 2600, + heading: 25, + pitch: -32, + }, + layers: ['helicopters', 'flights', 'ga', 'military'], + time: { start: det.since, end: det.updatedAt }, + metrics: [ + { label: 'Aircraft', value: det.members.length, unit: '' }, + { label: 'Orbits', value: turns, unit: '' }, + { + label: 'Radius', + value: radii[Math.floor(radii.length / 2)], + unit: 'm', + }, + ...(lead?.speed + ? [ + { + label: 'Speed', + value: Math.round(lead.speed * MPS_TO_KT), + unit: 'kt', + }, + ] + : []), + ], + headline: det.single + ? { value: turns, unit: '', label: 'orbits' } + : { + value: det.members.length, + unit: '', + label: + helis === det.members.length + ? 'helicopters circling' + : 'aircraft circling', + }, + thumbnail: thumbnailAround(det.lon, det.lat, 2), + live: true, + updatedAt: det.updatedAt, + source: + 'Detected by God’s Eye from live ADS-B (OpenSky Network / adsb.lol, ODbL)', + severity: det.single ? 4.5 : 6.5, + momentId: `live-${det.id}`, + members: det.members.map(({ key, layer, callsign, helicopter }) => ({ + key, + layer, + callsign, + helicopter, + })), + entityIds: det.members.map((m) => `${m.layer || 'flights'}:${m.key}`), + detected: true, + }; + SCENES.set(id, { + type: 'circling', + lon: det.lon, + lat: det.lat, + spanKm: 3.2, + band: 'sky', + tracks: det.members.map((m) => { + const pts = recorder + .samples(m.key, det.updatedAt - 20 * 60_000, det.updatedAt) + .map((p) => [p.lon, p.lat]); + return { points: pts, helicopter: m.helicopter, heading: 0 }; + }), + }); + void fmtLL; + return card; +} + +export function quakeClusterCard(c) { + const id = c.id; + const card = { + id, + kind: 'quake-cluster', + family: 'Hazards', + section: 'now', + band: 'ground', + archetype: 'number', + telemetry: `GROUND · ${c.count} EVENTS · 24 H · MAX M${c.maxMag.toFixed(1)} · 50 KM`, + title: c.title, + subtitle: `Largest M${c.maxMag.toFixed(1)} · first ${hhmm(c.since)} · USGS`, + place: c.members[0]?.place || fmtLL(c.lat, c.lon), + lon: c.lon, + lat: c.lat, + camera: { lon: c.lon, lat: c.lat, height: 260_000, heading: 0, pitch: -55 }, + layers: ['earthquakes'], + time: { start: c.since, end: c.updatedAt }, + metrics: [ + { label: 'Quakes', value: c.count, unit: '' }, + { label: 'Largest', value: c.maxMag.toFixed(1), unit: 'M' }, + ], + headline: { value: c.count, unit: '', label: 'quakes in 24 h' }, + series: c.members + .slice() + .sort((a, b) => a.time - b.time) + .map((m) => ({ t: m.time, v: m.mag })), + seriesLabel: 'magnitude per event', + thumbnail: thumbnailAround(c.lon, c.lat, 60), + live: true, + updatedAt: c.updatedAt, + source: 'U.S. Geological Survey · cluster detected by God’s Eye', + severity: 3 + Math.max(0, c.maxMag - 4), + detected: true, + }; + SCENES.set(id, { + type: 'quake', + lon: c.lon, + lat: c.lat, + spanKm: 160, + band: 'ground', + quake: { lon: c.lon, lat: c.lat, mag: c.maxMag }, + nearby: c.members.map((m) => ({ lon: m.lon, lat: m.lat, mag: m.mag })), + }); + return card; +} diff --git a/mobile/globe/dev.js b/mobile/globe/dev.js index db89d4686..9a32510a2 100644 --- a/mobile/globe/dev.js +++ b/mobile/globe/dev.js @@ -59,3 +59,28 @@ if (params.get('labels') !== '0') { globe.on('camera', drawLabels); setInterval(drawLabels, 1000); } + +// ?moment=empire-state&speed=30 plays a Moment on load; its events print in the HUD. +const momentLines = []; +globe.on('moment', (e) => { + if (!showHud) return; + const it = e.item || {}; + const line = + e.type === 'chat' + ? `💬 ${it.handle}: ${it.text}` + : e.type === 'post' + ? `▤ ${it.kind} · ${it.handle}: ${it.text}` + : e.type === 'capture' + ? `◉ ${it.firstEyes ? 'FIRST EYES ' : ''}@${it.handle} · ${it.title}` + : e.type === 'beat' + ? `● ${it.title}` + : `[${e.type}]`; + momentLines.push(line); + while (momentLines.length > 8) momentLines.shift(); + hud.textContent = momentLines.join('\n'); +}); +if (params.get('moment')) + globe.playMoment(params.get('moment'), { + speed: Number(params.get('speed')) || undefined, + autoplay: params.get('autoplay') !== '0', + }); diff --git a/mobile/globe/entities.js b/mobile/globe/entities.js new file mode 100644 index 000000000..5ec893b67 --- /dev/null +++ b/mobile/globe/entities.js @@ -0,0 +1,1404 @@ +/** + * Entities, dossiers, search and the link graph (DESIGN.md §12.1). + * + * Every object is an entity with a layer-qualified id (`flights:a1b2c3`, + * `satellites:25544`, `earthquakes:us7000abcd`, `cctv:tfl-07450`, + * `situation:circling-40.75_-73.99`, `moment:empire-state:news-7`, + * `capture:empire-state:c1`, `place:midtown-manhattan`). A dossier carries + * identity, live state, track, events, links and receipts (each source with + * its fetch time and a SHA-256 of what was read). + * + * The line we don't cross: there are no person entities. Aircraft whose + * owners opted out (PIA / LADD) or that have no public registration are not + * named beyond what their transponder broadcasts. + */ +import { twoline2satrec } from 'satellite.js'; +import { findNextIssPass, lookAnglesAt } from '../../src/data/issPass.js'; +import { satPosition } from './layers/orbit.js'; +import { haversineKm } from './geo.js'; +import { NEIGHBORHOODS, WORLD_PLACES, localPlace } from './gazetteer.js'; +import { AIRPORTS } from './places.js'; + +const AIRCRAFT_LAYERS = new Set([ + 'flights', + 'military', + 'helicopters', + 'ga', + 'squawk', + 'history', + 'aircraft', + 'helicopter', + 'emergency', +]); +const SAT_GROUPS = ['stations', 'visual', 'gps', 'starlink']; +const M_TO_FT = 3.28084; +const MPS_TO_KT = 1 / 0.514444; + +export const slug = (s) => + String(s) + .toLowerCase() + .normalize('NFKD') + .replace(/[^\w\s-]/g, '') + .trim() + .replace(/[\s_]+/g, '-'); + +function fnv(str) { + let h1 = 0x811c9dc5; + let h2 = 0x01000193; + for (let i = 0; i < str.length; i++) { + const c = str.charCodeAt(i); + h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0; + h2 = Math.imul(h2 ^ c, 0x5bd1e995) >>> 0; + } + return h1.toString(16).padStart(8, '0') + h2.toString(16).padStart(8, '0'); +} + +/** SHA-256 hex of a value's JSON (FNV fallback outside secure contexts). */ +export async function receiptHash(value) { + const text = JSON.stringify(value ?? null); + try { + if (globalThis.crypto?.subtle) { + const buf = await crypto.subtle.digest( + 'SHA-256', + new TextEncoder().encode(text), + ); + return ( + 'sha256:' + + [...new Uint8Array(buf)] + .map((b) => b.toString(16).padStart(2, '0')) + .join('') + ); + } + } catch { + /* fall through */ + } + return `fnv1a:${fnv(text)}`; +} + +async function getJson(url, ms = 3500) { + const controller = new AbortController(); + const timer = setTimeout(() => controller.abort(), ms); + try { + const r = await fetch(url, { signal: controller.signal }); + if (!r.ok) return { ok: false, status: r.status }; + return { ok: true, json: await r.json() }; + } catch (error) { + return { ok: false, error }; + } finally { + clearTimeout(timer); + } +} + +/** Parse an entity reference into { type, layer, key, … }. */ +export function parseRef(ref) { + if (ref == null) return null; + if (typeof ref === 'object') { + if (ref.entityId) return parseRef(ref.entityId); + const layer = ref.meta?.entityLayer || ref.meta?.layer || ref.layer; + if (ref.kind === 'pin' || layer === 'pins') + return { type: 'pin', key: String(ref.id) }; + if (layer === 'moment' || ref.kind === 'track' || ref.kind === 'capture') + return parseRef(String(ref.id)); + if (ref.meta?.norad) + return { type: 'satellite', key: String(ref.meta.norad) }; + if (layer) return parseRef(`${layer}:${ref.id}`); + if (ref.kind && ref.id != null) return parseRef(`${ref.kind}:${ref.id}`); + return null; + } + const s = String(ref).trim(); + const i = s.indexOf(':'); + if (i < 0) return { type: 'unknown', key: s }; + const prefix = s.slice(0, i); + const rest = s.slice(i + 1); + if (AIRCRAFT_LAYERS.has(prefix)) + return { + type: 'aircraft', + layer: prefix === 'military' ? 'military' : 'flights', + key: rest.toLowerCase(), + }; + if (['satellites', 'iss', 'starlink', 'satellite', 'sat'].includes(prefix)) + return { type: 'satellite', key: rest.replace(/\D/g, '') || rest }; + if (['earthquakes', 'quake', 'earthquake'].includes(prefix)) + return { type: 'quake', key: rest }; + if (['cctv', 'camera', 'eye'].includes(prefix)) + return { type: 'camera', key: rest }; + if (['vessels', 'vessel', 'tankers'].includes(prefix)) + return { type: 'vessel', key: rest }; + if (prefix === 'situation') return { type: 'situation', key: rest }; + if (prefix === 'place') return { type: 'place', key: rest }; + if (prefix === 'capture') { + const [mid, cid] = rest.split(':'); + return { type: 'capture', moment: mid, key: cid }; + } + if (prefix === 'moment') { + const [mid, tid] = rest.split(':'); + return tid + ? { type: tid === 'subject' ? 'moment' : 'track', moment: mid, key: tid } + : { type: 'moment', moment: mid, key: mid }; + } + return { type: prefix, key: rest }; +} + +/** + * @param {{ feeds, recorder, detector, situations: () => Map, + * moments: { get(id): Promise, cached(): object[] }, + * viewer: () => ({lon,lat}|null), timeMs: () => number, + * trackOf: (key, layer) => Promise }} env + */ +export function createEntities(env) { + const { feeds, recorder } = env; + const identityCache = new Map(); + const dossierCache = new Map(); + + function liveAircraft(key) { + const lists = [ + ['military', feeds.military.data], + ['flights', feeds.flights.data], + ...(feeds.regionalFlights.entries?.() || []).map((e) => [ + 'flights', + e.data, + ]), + ]; + for (const [layer, data] of lists) { + const r = data?.records?.find((x) => x.id === key); + if (r) return { r, layer, source: data.source || layer }; + } + return null; + } + + function allAircraft() { + const byId = new Map(); + for (const e of feeds.regionalFlights.entries?.() || []) + for (const r of e.data?.records || []) byId.set(r.id, r); + for (const r of feeds.flights.data?.records || []) byId.set(r.id, r); + for (const r of feeds.military.data?.records || []) byId.set(r.id, r); + return [...byId.values()]; + } + + async function aircraftIdentity(key, callsign) { + let hit = identityCache.get(key); + if (hit && Date.now() - hit.at < 30 * 60_000) return hit; + const [type, route] = await Promise.all([ + /^[0-9a-f]{6}$/.test(key) + ? getJson(`/api/adsbdb/type/${key}`) + : Promise.resolve({ ok: false }), + callsign && /^[A-Z0-9]{2,8}$/.test(callsign.trim()) + ? getJson(`/api/adsbdb/route/${encodeURIComponent(callsign.trim())}`) + : Promise.resolve({ ok: false }), + ]); + hit = { + at: Date.now(), + type: type.ok && type.json?.found ? type.json : null, + route: route.ok && route.json?.found ? route.json : null, + typeFetched: type.ok, + }; + identityCache.set(key, hit); + return hit; + } + + function situationsWith(predicate) { + const out = []; + for (const s of env.situations().values()) if (predicate(s)) out.push(s); + return out; + } + + function aircraftLinks(key, r, here, identity) { + const links = []; + if (here) { + const near = []; + for (const o of allAircraft()) { + if (o.id === key || o.onGround) continue; + if (Math.abs(o.lat - here.lat) > 0.4) continue; + const d = haversineKm(here.lat, here.lon, o.lat, o.lon); + if (d <= 25) near.push({ o, d }); + } + near.sort((a, b) => a.d - b.d); + for (const { o, d } of near.slice(0, 8)) + links.push({ + id: `${o.military ? 'military' : 'flights'}:${o.id}`, + kind: o.military + ? 'military' + : o.helicopter + ? 'helicopter' + : 'aircraft', + title: o.callsign || o.id.toUpperCase(), + relation: 'nearby', + distanceKm: Math.round(d * 10) / 10, + }); + } + // Same operator in view: airline ICAO prefix of the callsign. + const prefix = /^([A-Z]{3})\d/.exec(r?.callsign || '')?.[1]; + if (prefix) { + const same = allAircraft() + .filter((o) => o.id !== key && o.callsign?.startsWith(prefix)) + .slice(0, 6); + for (const o of same) + links.push({ + id: `flights:${o.id}`, + kind: 'aircraft', + title: o.callsign, + relation: identity?.route?.airline + ? `same operator (${identity.route.airline})` + : `same operator (${prefix})`, + ...(here + ? { + distanceKm: Math.round( + haversineKm(here.lat, here.lon, o.lat, o.lon), + ), + } + : {}), + }); + } + for (const s of situationsWith( + (s) => + s.id === `squawk-${key}` || + s.members?.some?.((m) => m.key === key) || + s.entityIds?.includes?.(`flights:${key}`), + )) + links.push({ + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + relation: 'part of', + }); + for (const d of env.detector.current()) + if (d.members.some((m) => m.key === key)) + links.push({ + id: `situation:${d.id}`, + kind: 'situation', + title: d.title, + relation: 'circling with', + }); + if (identity?.route) { + for (const [rel, ap] of [ + ['from', identity.route.origin], + ['to', identity.route.destination], + ]) + if (ap?.code) + links.push({ + id: `place:${slug(ap.code)}`, + kind: 'place', + title: `${ap.code} · ${ap.name}`, + relation: rel, + ...(here && Number.isFinite(ap.lat) + ? { + distanceKm: Math.round( + haversineKm(here.lat, here.lon, ap.lat, ap.lon), + ), + } + : {}), + }); + } + if (here) + links.push({ + id: `place:${slug(localPlace(here.lat, here.lon).name)}`, + kind: 'place', + title: localPlace(here.lat, here.lon).name, + relation: 'over', + }); + return links; + } + + async function aircraftDossier(ref) { + const key = ref.key; + const live = liveAircraft(key); + const meta = recorder.meta(key) || {}; + const r = live?.r || null; + const callsign = (r?.callsign || meta.callsign || '').trim(); + const t = env.timeMs(); + const recState = recorder.stateAt(key, t); + const here = r + ? { lon: r.lon, lat: r.lat } + : recState + ? { lon: recState.lon, lat: recState.lat } + : null; + const pia = Boolean(r?.pia || meta.pia); + const ladd = Boolean(r?.ladd || meta.ladd); + const identity = pia || ladd ? null : await aircraftIdentity(key, callsign); + const hasPublic = Boolean(identity?.type?.registration || r?.registration); + const privacy = pia + ? 'pia' + : ladd + ? 'ladd' + : identity?.typeFetched && !hasPublic + ? 'no-public-identity' + : null; + // The server's full track can be slow (or down): the dossier waits at + // most 2.5 s for it, then uses the recorder's own samples. + const recorded = recorder.samples(key); + recorded.source = 'God’s Eye recorder'; + let trackPending = false; + const track = await Promise.race([ + env.trackOf(key, live?.layer || meta.layer).catch(() => recorded), + new Promise((r) => + setTimeout(() => { + trackPending = true; + r(recorded); + }, 2500), + ), + ]); + const isHeli = Boolean(r?.helicopter || meta.helicopter); + const isMil = Boolean(r?.military || meta.military); + const kind = isMil ? 'military' : isHeli ? 'helicopter' : 'aircraft'; + const fetchedAt = live + ? feeds[live.layer === 'military' ? 'military' : 'flights'].updatedAt || + Date.now() + : Date.now(); + const sources = []; + if (live) + sources.push({ + name: live.source, + fetchedAt, + url: live.layer === 'military' ? '/api/military' : '/api/flights', + hash: await receiptHash(r), + }); + if (track.length) + sources.push({ + name: track.source || 'God’s Eye recorder', + fetchedAt: Date.now(), + hash: await receiptHash(track.map((p) => [p.t, p.lon, p.lat, p.altM])), + }); + if (identity && (identity.type || identity.route)) + sources.push({ + name: 'adsbdb.com (community aircraft database)', + fetchedAt: identity.at, + url: `/api/adsbdb/type/${key}`, + hash: await receiptHash({ type: identity.type, route: identity.route }), + }); + const events = []; + for (const e of recorder.events()) + if (e.key === key) events.push({ t: e.t, title: e.title }); + if (track.length) + events.push({ + t: track[0].t, + title: `First position in the record (${new Date(track[0].t).toISOString().slice(11, 16)}Z)`, + }); + for (const d of env.detector.current()) + if (d.members.some((m) => m.key === key)) + events.push({ t: d.since, title: `Began circling ${d.place}` }); + events.sort((a, b) => a.t - b.t); + const reg = privacy + ? null + : identity?.type?.registration || r?.registration; + const typeName = identity?.type?.typeName || r?.type || meta.type || null; + const altM = r?.altM ?? recState?.altM ?? null; + const speed = r?.speed ?? recState?.speed ?? null; + return { + id: `${live?.layer || meta.layer || 'flights'}:${key}`, + kind, + title: callsign || key.toUpperCase(), + subtitle: [ + privacy ? null : identity?.route?.airline, + typeName, + reg, + altM != null ? `${Math.round((altM * M_TO_FT) / 100) * 100} ft` : null, + ] + .filter(Boolean) + .join(' · '), + identity: { + icao24: key, + callsign: callsign || null, + ...(reg ? { registration: reg } : {}), + ...(typeName && !(privacy === 'pia') ? { type: typeName } : {}), + ...(identity?.type?.typeCode && !privacy + ? { typeCode: identity.type.typeCode } + : {}), + ...(identity?.route?.airline && !privacy + ? { operator: identity.route.airline } + : {}), + ...(identity?.route && !privacy + ? { + route: `${identity.route.origin.code} → ${identity.route.destination.code}`, + } + : {}), + ...(r?.country ? { country: r.country } : {}), + ...(r?.squawk || meta.squawk + ? { squawk: r?.squawk || meta.squawk } + : {}), + category: isHeli ? 'rotorcraft' : r?.cls || meta.kind || null, + military: isMil, + }, + live: + r || recState + ? { + lon: here.lon, + lat: here.lat, + altM, + speed, + heading: r?.heading ?? recState?.headingDeg ?? null, + ...(r?.squawk ? { squawk: r.squawk } : {}), + onGround: Boolean(r?.onGround), + updatedAt: r ? r.seenAt || fetchedAt : recState.t, + speedKt: speed != null ? Math.round(speed * MPS_TO_KT) : null, + } + : null, + track: track.map(({ t: tt, lon, lat, altM: a }) => ({ + t: tt, + lon, + lat, + altM: a, + })), + events, + links: aircraftLinks(key, r, here, privacy ? null : identity), + sources, + ...(trackPending ? { trackPending: true } : {}), + ...(privacy ? { privacy } : {}), + }; + } + + function findSat(norad) { + for (const g of SAT_GROUPS) + for (const e of feeds[g]?.data?.entries || []) + if (e.line1.slice(2, 7).trim() === norad) return e; + return null; + } + + async function satelliteDossier(ref) { + let e = findSat(ref.key); + if (!e) { + await Promise.allSettled([feeds.stations.get(), feeds.visual.get()]); + e = findSat(ref.key); + } + if (!e) throw new Error(`No orbital elements for NORAD ${ref.key}`); + const satrec = twoline2satrec(e.line1, e.line2); + const t = env.timeMs(); + const p = satPosition(satrec, t); + const track = []; + for (let m = -45; m <= 45; m += 3) { + const q = satPosition(satrec, t + m * 60_000); + if (q) + track.push({ t: t + m * 60_000, lon: q.lon, lat: q.lat, altM: q.altM }); + } + const v = env.viewer(); + let pass = null; + let look = null; + if (v) { + look = lookAnglesAt(satrec, t, v.lat, v.lon); + pass = findNextIssPass({ + satrec, + latDeg: v.lat, + lonDeg: v.lon, + fromMs: Date.now(), + minElevDeg: 10, + horizonHours: 36, + }); + } + const intl = e.line1.slice(9, 17).trim(); + const epochYr = Number(e.line1.slice(18, 20)); + const epochDay = Number(e.line1.slice(20, 32)); + const epoch = + Date.UTC(epochYr < 57 ? 2000 + epochYr : 1900 + epochYr, 0, 1) + + (epochDay - 1) * 86_400_000; + const events = []; + if (pass) + events.push({ + t: pass.riseMs, + title: `Next pass over you: max ${Math.round(pass.maxElevDeg)}°${pass.visible ? ', visible' : ''}`, + }); + events.push({ t: epoch, title: 'Orbital elements epoch' }); + const links = []; + for (const s of situationsWith( + (s) => s.kind === 'iss' && ref.key === '25544', + )) + links.push({ + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + relation: 'featured in', + }); + if (p) + links.push({ + id: `place:${slug(localPlace(p.lat, p.lon).name)}`, + kind: 'place', + title: localPlace(p.lat, p.lon).name, + relation: 'over', + }); + return { + id: `satellites:${ref.key}`, + kind: 'satellite', + title: e.name.trim(), + subtitle: [ + `NORAD ${ref.key}`, + p ? `${Math.round(p.altM / 1000)} km` : null, + look ? `${Math.round(look.elevDeg)}° above your horizon` : null, + ] + .filter(Boolean) + .join(' · '), + identity: { + norad: ref.key, + intlDesignator: intl, + name: e.name.trim(), + tle: [e.line1, e.line2], + epoch, + }, + live: p + ? { + lon: p.lon, + lat: p.lat, + altM: p.altM, + speed: p.speedMps, + heading: null, + updatedAt: t, + ...(look + ? { elevationDeg: look.elevDeg, azimuthDeg: look.azDeg } + : {}), + } + : null, + track, + events, + nextPass: pass + ? { + start: pass.riseMs, + max: pass.maxElevMs, + end: pass.setMs, + maxElevationDeg: pass.maxElevDeg, + visible: Boolean(pass.visible), + } + : null, + links, + sources: [ + { + name: 'CelesTrak GP data (SGP4 via satellite.js)', + fetchedAt: feeds.stations.updatedAt || Date.now(), + url: '/api/celestrak/stations', + hash: await receiptHash([e.line1, e.line2]), + }, + ], + }; + } + + async function quakeDossier(ref) { + const data = await feeds.quakes.get().catch(() => feeds.quakes.data); + const q = data?.records?.find( + (x) => x.stableId === ref.key || x.usgsId === ref.key, + ); + if (!q) throw new Error(`Unknown earthquake ${ref.key}`); + const links = []; + for (const o of data.records) { + if (o === q) continue; + const d = haversineKm(q.lat, q.lon, o.lat, o.lon); + if (d <= 100 && Math.abs(o.time - q.time) < 7 * 86_400_000) + links.push({ + id: `earthquakes:${o.stableId}`, + kind: 'quake', + title: `M${o.mag.toFixed(1)} ${o.place || ''}`.trim(), + relation: o.time < q.time ? 'foreshock?' : 'aftershock?', + distanceKm: Math.round(d), + }); + } + links.splice(10); + for (const s of situationsWith( + (s) => + (s.kind === 'quake' || s.kind === 'quake-cluster') && + haversineKm(q.lat, q.lon, s.lat, s.lon) < 60, + )) + links.push({ + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + relation: 'part of', + }); + return { + id: `earthquakes:${q.stableId}`, + kind: 'quake', + title: `M${q.mag.toFixed(1)} earthquake`, + subtitle: [ + q.place, + q.depthKm != null ? `${Math.round(q.depthKm)} km deep` : null, + ] + .filter(Boolean) + .join(' · '), + identity: { usgsId: q.usgsId, magnitude: q.mag, depthKm: q.depthKm }, + live: { + lon: q.lon, + lat: q.lat, + altM: -(q.depthKm ?? 0) * 1000, + speed: 0, + heading: null, + updatedAt: q.time, + }, + track: [], + events: [{ t: q.time, title: `M${q.mag.toFixed(1)} · ${q.place || ''}` }], + links, + sources: [ + { + name: 'U.S. Geological Survey (M2.5+ week feed)', + fetchedAt: feeds.quakes.updatedAt, + url: q.usgsId + ? `https://earthquake.usgs.gov/earthquakes/eventpage/${q.usgsId}` + : 'https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_week.geojson', + hash: await receiptHash(q), + }, + ], + }; + } + + async function cameraDossier(ref) { + const data = await feeds.cctv.get().catch(() => feeds.cctv.data); + const c = data?.records?.find((x) => x.id === ref.key); + if (!c) throw new Error(`Unknown camera ${ref.key}`); + const links = []; + for (const o of data.records) { + if (o === c || Math.abs(o.lat - c.lat) > 0.02) continue; + const d = haversineKm(c.lat, c.lon, o.lat, o.lon); + if (d < 1.5) + links.push({ + id: `cctv:${o.id}`, + kind: 'camera', + title: o.name, + relation: 'nearby camera', + distanceKm: Math.round(d * 100) / 100, + }); + } + links.sort((a, b) => a.distanceKm - b.distanceKm).splice(8); + return { + id: `cctv:${c.id}`, + kind: 'camera', + title: c.name, + subtitle: [c.provider, c.city].filter(Boolean).join(' · '), + identity: { + provider: c.provider, + city: c.city, + headingDeg: c.heading ?? null, + fovDeg: c.fovDeg ?? null, + }, + live: { + lon: c.lon, + lat: c.lat, + altM: 0, + speed: 0, + heading: c.heading ?? null, + updatedAt: Date.now(), + }, + track: [], + events: [], + links, + sources: [ + { + name: `Public camera feed · ${c.provider || 'agency'}`, + fetchedAt: feeds.cctv.updatedAt, + url: `/api/cctv/frame/${encodeURIComponent(c.id)}`, + hash: await receiptHash(c), + }, + ], + }; + } + + async function vesselDossier(ref) { + const data = feeds.vessels.data; + const v = data?.records?.find((x) => x.id === ref.key); + const rec = recorder.stateAt(`v:${ref.key}`, env.timeMs()); + if (!v && !rec) throw new Error(`Unknown vessel ${ref.key}`); + const track = recorder.samples(`v:${ref.key}`); + return { + id: `vessels:${ref.key}`, + kind: 'vessel', + title: v?.name || ref.key, + subtitle: [v?.type, v?.destination ? `→ ${v.destination}` : null] + .filter(Boolean) + .join(' · '), + identity: { mmsi: ref.key, name: v?.name, type: v?.type }, + live: v + ? { + lon: v.lon, + lat: v.lat, + altM: 0, + speed: v.speed, + heading: v.heading, + updatedAt: feeds.vessels.updatedAt, + } + : null, + track: track.map(({ t, lon, lat }) => ({ t, lon, lat, altM: 0 })), + events: [], + links: [], + sources: v + ? [ + { + name: data.source || 'AISStream', + fetchedAt: feeds.vessels.updatedAt, + hash: await receiptHash(v), + }, + ] + : [], + }; + } + + function situationLinks(s) { + const links = []; + for (const m of s.members || []) + links.push({ + id: `${m.layer || 'flights'}:${m.key}`, + kind: m.helicopter ? 'helicopter' : 'aircraft', + title: m.callsign || m.key, + relation: 'circling', + }); + if (s.kind === 'squawk') { + const key = s.id.replace(/^squawk-/, ''); + links.push({ + id: `flights:${key}`, + kind: 'aircraft', + title: s.title.split(' ')[0], + relation: 'subject', + }); + } + if (s.media?.cameraId) + links.push({ + id: `cctv:${s.media.cameraId}`, + kind: 'camera', + title: s.title, + relation: 'camera', + }); + if (s.momentId) + links.push({ + id: `moment:${s.momentId}`, + kind: 'moment', + title: `Replay: ${s.title}`, + relation: 'moment', + }); + links.push({ + id: `place:${slug(s.place || localPlace(s.lat, s.lon).name)}`, + kind: 'place', + title: s.place || localPlace(s.lat, s.lon).name, + relation: 'at', + }); + // Other situations nearby. + for (const o of env.situations().values()) { + if (o.id === s.id) continue; + const d = haversineKm(s.lat, s.lon, o.lat, o.lon); + if (d < 150) + links.push({ + id: `situation:${o.id}`, + kind: 'situation', + title: o.title, + relation: 'nearby', + distanceKm: Math.round(d), + }); + } + return links; + } + + async function situationDossier(ref) { + const s = + env.situations().get(ref.key) || env.detector.get(ref.key) || null; + if (!s) throw new Error(`Unknown situation ${ref.key}`); + return { + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + subtitle: s.subtitle || s.place || '', + identity: { + genre: s.kind, + band: s.band, + archetype: s.archetype, + ...(s.momentId ? { momentId: s.momentId } : {}), + }, + live: { + lon: s.lon, + lat: s.lat, + altM: 0, + speed: 0, + heading: null, + updatedAt: s.updatedAt, + }, + track: [], + events: [ + ...(s.time?.start ? [{ t: s.time.start, title: 'Began' }] : []), + { t: s.updatedAt, title: 'Last update' }, + ], + links: situationLinks(s), + sources: [ + { + name: s.source || 'God’s Eye', + fetchedAt: s.updatedAt, + hash: await receiptHash(s.metrics || s), + }, + ], + }; + } + + async function momentDossier(ref) { + const m = await env.moments.get(ref.moment); + if (!m) throw new Error(`Unknown moment ${ref.moment}`); + const links = [ + ...m.tracks.map((t) => ({ + id: `moment:${m.id}:${t.id}`, + kind: 'track', + title: t.label, + relation: t.kind === 'helicopter' ? 'helicopter' : 'aircraft', + })), + ...m.captures.map((c) => ({ + id: `capture:${m.id}:${c.id}`, + kind: 'capture', + title: c.title, + relation: c.firstEyes ? 'first eyes' : 'witness capture', + })), + { + id: `place:${slug(m.place)}`, + kind: 'place', + title: m.place, + relation: 'at', + }, + ]; + return { + id: `moment:${m.id}`, + kind: 'moment', + title: m.title, + subtitle: `${m.place}${m.illustrative ? ' · Illustrative' : ''}`, + identity: { + illustrative: Boolean(m.illustrative), + tracks: m.tracks.length, + captures: m.captures.length, + }, + live: { + lon: m.lon, + lat: m.lat, + altM: 0, + speed: 0, + heading: null, + updatedAt: m.time.end, + }, + track: [], + events: (m.beats || []).map((b) => ({ t: b.t, title: b.title })), + links, + sources: await Promise.all( + m.sources.map(async (s) => ({ + name: s.name, + detail: s.detail, + fetchedAt: m.time.end, + hash: await receiptHash(s), + })), + ), + ...(m.illustrative ? { illustrative: true } : {}), + }; + } + + async function trackDossier(ref) { + const m = await env.moments.get(ref.moment); + const tr = m?.tracks.find((t) => t.id === ref.key); + if (!tr) throw new Error(`Unknown track ${ref.key}`); + const last = tr.points.at(-1); + const t = env.timeMs(); + const cur = + tr.points.find( + (p, i) => p.t <= t && (tr.points[i + 1]?.t ?? Infinity) > t, + ) || last; + const others = m.tracks + .filter((o) => o.id !== tr.id) + .map((o) => ({ + id: `moment:${m.id}:${o.id}`, + kind: 'track', + title: o.label, + relation: 'orbiting with', + })); + // A live Moment track is a real aircraft: hand over to its dossier. + if (!m.illustrative && tr.entityId) { + const d = await aircraftDossier(parseRef(tr.entityId)).catch(() => null); + if (d) { + d.links.push( + { + id: `moment:${m.id}`, + kind: 'moment', + title: m.title, + relation: 'in moment', + }, + ...others, + ); + return d; + } + } + return { + id: `moment:${m.id}:${tr.id}`, + kind: tr.kind === 'helicopter' ? 'helicopter' : 'aircraft', + title: tr.label, + subtitle: [tr.type, tr.operator, m.illustrative ? 'Illustrative' : null] + .filter(Boolean) + .join(' · '), + identity: { + callsign: tr.callsign || null, + registration: tr.registration || null, + type: tr.type || null, + operator: tr.operator || null, + illustrative: Boolean(m.illustrative), + }, + live: { + lon: cur.lon, + lat: cur.lat, + altM: cur.altM, + speed: null, + heading: null, + updatedAt: cur.t, + }, + track: tr.points, + events: (m.beats || []) + .filter((b) => b.title.includes(tr.label.split(' ')[0])) + .map((b) => ({ t: b.t, title: b.title })), + links: [ + { + id: `moment:${m.id}`, + kind: 'moment', + title: m.title, + relation: 'in moment', + }, + ...others, + ], + sources: [ + { + name: m.illustrative + ? 'Illustrative reconstruction (synthetic track)' + : 'God’s Eye recorder', + fetchedAt: m.time.end, + hash: await receiptHash( + tr.points.map((p) => [p.t, p.lon, p.lat, p.altM]), + ), + }, + ], + ...(m.illustrative ? { illustrative: true } : {}), + }; + } + + async function captureDossier(ref) { + const m = await env.moments.get(ref.moment); + const c = m?.captures.find((x) => x.id === ref.key); + if (!c) throw new Error(`Unknown capture ${ref.key}`); + return { + id: `capture:${m.id}:${c.id}`, + kind: 'capture', + title: c.title, + subtitle: `@${c.handle} · ${c.place || ''}${c.sealed ? ' · Sealed' : ''}${m.illustrative ? ' · Illustrative' : ''}`, + identity: { + handle: c.handle, + sealed: Boolean(c.sealed), + firstEyes: Boolean(c.firstEyes), + headingDeg: c.headingDeg, + fovDeg: c.fovDeg, + captureKind: c.kind || 'photo', + }, + live: { + lon: c.lon, + lat: c.lat, + altM: c.altM, + speed: 0, + heading: c.headingDeg, + updatedAt: c.t, + }, + track: [], + events: [ + { + t: c.t, + title: c.firstEyes + ? 'First eyes: first sealed capture' + : 'Sealed capture', + }, + ], + links: [ + { + id: `moment:${m.id}`, + kind: 'moment', + title: m.title, + relation: 'witness of', + }, + ...m.posts + .filter((p) => p.captureId === c.id) + .map((p) => ({ + id: `post:${m.id}:${p.id}`, + kind: 'post', + title: p.text.slice(0, 60), + relation: 'posted as', + })), + ], + sources: [ + { + name: m.illustrative + ? 'Illustrative capture (simulated)' + : 'Signed capture', + fetchedAt: c.t, + hash: await receiptHash(c), + }, + ], + ...(m.illustrative ? { illustrative: true } : {}), + }; + } + + function allPlaces() { + const out = []; + for (const [name, lon, lat, r] of NEIGHBORHOODS) + out.push({ name, lon, lat, kind: 'neighbourhood', radiusKm: r }); + for (const a of AIRPORTS) + out.push({ + name: `${a.code} · ${a.name}`, + code: a.code, + lon: a.lon, + lat: a.lat, + kind: 'airport', + }); + for (const [name, lon, lat] of WORLD_PLACES) + out.push({ name, lon, lat, kind: 'city' }); + return out; + } + + function placeBySlug(s) { + return allPlaces().find( + (p) => slug(p.name) === s || (p.code && slug(p.code) === s), + ); + } + + async function placeDossier(ref) { + const p = placeBySlug(ref.key); + if (!p) throw new Error(`Unknown place ${ref.key}`); + const links = []; + for (const s of env.situations().values()) { + const d = haversineKm(p.lat, p.lon, s.lat, s.lon); + if (d < 120) + links.push({ + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + relation: 'happening near', + distanceKm: Math.round(d), + }); + } + const near = allAircraft() + .map((o) => ({ o, d: haversineKm(p.lat, p.lon, o.lat, o.lon) })) + .filter((x) => x.d < 30 && !x.o.onGround) + .sort((a, b) => a.d - b.d) + .slice(0, 12); + for (const { o, d } of near) + links.push({ + id: `${o.military ? 'military' : 'flights'}:${o.id}`, + kind: o.helicopter ? 'helicopter' : 'aircraft', + title: o.callsign || o.id, + relation: 'overhead', + distanceKm: Math.round(d * 10) / 10, + }); + return { + id: `place:${ref.key}`, + kind: 'place', + title: p.name, + subtitle: p.kind, + identity: { kind: p.kind, ...(p.code ? { code: p.code } : {}) }, + live: { + lon: p.lon, + lat: p.lat, + altM: 0, + speed: 0, + heading: null, + updatedAt: Date.now(), + }, + track: [], + events: [], + links, + sources: [ + { + name: 'Bundled gazetteer (public centroids)', + fetchedAt: Date.now(), + hash: await receiptHash(p), + }, + ], + }; + } + + async function entity(ref) { + const r = parseRef(ref); + if (!r) throw new TypeError('entity() needs an id or a pick'); + const cacheKey = JSON.stringify(r); + const hit = dossierCache.get(cacheKey); + if (hit && Date.now() - hit.at < 5000) return hit.d; + let d; + switch (r.type) { + case 'aircraft': + d = await aircraftDossier(r); + break; + case 'satellite': + d = await satelliteDossier(r); + break; + case 'quake': + d = await quakeDossier(r); + break; + case 'camera': + d = await cameraDossier(r); + break; + case 'vessel': + d = await vesselDossier(r); + break; + case 'situation': + d = await situationDossier(r); + break; + case 'moment': + d = await momentDossier(r); + break; + case 'track': + d = await trackDossier(r); + break; + case 'capture': + d = await captureDossier(r); + break; + case 'place': + d = await placeDossier(r); + break; + default: { + // Bare ids: try a situation, then an aircraft hex. + if (env.situations().has(r.key) || env.detector.get(r.key)) + d = await situationDossier({ key: r.key }); + else if (/^[0-9a-f]{6}$/i.test(r.key)) + d = await aircraftDossier({ key: r.key.toLowerCase() }); + else throw new Error(`Unknown entity ${String(ref)}`); + } + } + dossierCache.set(cacheKey, { at: Date.now(), d }); + if (dossierCache.size > 80) + dossierCache.delete(dossierCache.keys().next().value); + return d; + } + + /* ── Search ────────────────────────────────────────────────── */ + + function score(hay, q) { + if (!hay) return 0; + const h = String(hay).toLowerCase(); + if (h === q) return 100; + if (h.startsWith(q)) return 70; + if (h.includes(` ${q}`)) return 50; + if (h.includes(q)) return 30; + return 0; + } + + async function search(query) { + const raw = String(query ?? '').trim(); + const q = raw.toLowerCase(); + if (!q) return []; + const out = []; + const push = (s, item) => { + if (s > 0) out.push({ ...item, _s: s }); + }; + // Squawk codes. + if (/^7[567]00$/.test(q)) { + for (const r of allAircraft()) + if (r.squawk === q) + push(95, { + id: `flights:${r.id}`, + kind: 'aircraft', + title: r.callsign || r.id, + subtitle: `Squawking ${r.squawk} · ${Math.round((r.altM * M_TO_FT) / 100) * 100} ft`, + }); + } + // Magnitude ("M5.2", "m5"). + const mag = /^m\s?(\d(?:\.\d)?)$/.exec(q); + const quakes = feeds.quakes.data?.records || []; + if (mag) { + const m = Number(mag[1]); + for (const x of quakes) + if (x.mag >= m && x.mag < m + (mag[1].includes('.') ? 0.1 : 1)) + push(90 + x.mag, { + id: `earthquakes:${x.stableId}`, + kind: 'quake', + title: `M${x.mag.toFixed(1)} earthquake`, + subtitle: x.place || '', + }); + } + for (const x of quakes) + push(score(x.place, q) * 0.8, { + id: `earthquakes:${x.stableId}`, + kind: 'quake', + title: `M${x.mag.toFixed(1)} earthquake`, + subtitle: x.place || '', + }); + // Aircraft: callsign, hex, registration (live + recorder). + const seen = new Set(); + for (const r of allAircraft()) { + const s = Math.max( + score(r.callsign, q), + score(r.id, q), + score(r.registration, q), + score(identityCache.get(r.id)?.type?.registration, q), + ); + if (!s) continue; + seen.add(r.id); + push(s + 5, { + id: `${r.military ? 'military' : 'flights'}:${r.id}`, + kind: r.military + ? 'military' + : r.helicopter + ? 'helicopter' + : 'aircraft', + title: r.callsign || r.id.toUpperCase(), + subtitle: [ + r.type || r.country, + `${Math.round((r.altM * M_TO_FT) / 100) * 100} ft`, + ] + .filter(Boolean) + .join(' · '), + }); + } + if (out.length < 30) + for (const key of recorder.keys()) { + if (seen.has(key)) continue; + const m = recorder.meta(key); + const s = Math.max( + score(m?.callsign, q), + score(key, q), + score(m?.registration, q), + ); + if (s) + push(s - 10, { + id: `${m?.layer || 'flights'}:${key}`, + kind: m?.kind || 'aircraft', + title: m?.callsign || key.toUpperCase(), + subtitle: 'In the record', + }); + } + // Satellites. + const sats = new Set(); + for (const g of SAT_GROUPS) + for (const e of feeds[g]?.data?.entries || []) { + const id = e.line1.slice(2, 7).trim(); + if (sats.has(id)) continue; + const name = e.name.trim(); + const s = Math.max( + score(name, q), + q === 'iss' && id === '25544' ? 100 : 0, + score(id, q), + ); + if (!s) continue; + sats.add(id); + push(s, { + id: `satellites:${id}`, + kind: 'satellite', + title: name, + subtitle: `NORAD ${id}`, + }); + } + // Cameras. + for (const c of feeds.cctv.data?.records || []) { + const s = Math.max(score(c.name, q), score(c.city, q) * 0.5); + if (s) + push(s * 0.9, { + id: `cctv:${c.id}`, + kind: 'camera', + title: c.name, + subtitle: [c.provider, c.city].filter(Boolean).join(' · '), + }); + } + // Situations and detections. + for (const s of env.situations().values()) { + const sc = Math.max( + score(s.title, q), + score(s.place, q) * 0.8, + score(s.kind, q) * 0.7, + ); + if (sc) + push(sc + 8, { + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + subtitle: s.place || s.subtitle || '', + }); + } + // Places. + for (const p of allPlaces()) { + const s = Math.max(score(p.name, q), p.code ? score(p.code, q) : 0); + if (s) + push(s * (p.kind === 'neighbourhood' ? 0.95 : 0.85), { + id: `place:${slug(p.code || p.name)}`, + kind: 'place', + title: p.name, + subtitle: p.kind, + }); + } + // Moments. + for (const m of env.moments.cached()) { + const s = Math.max(score(m.title, q), score(m.place, q) * 0.8); + if (s) + push(s + 10, { + id: `moment:${m.id}`, + kind: 'moment', + title: m.title, + subtitle: `${m.place}${m.illustrative ? ' · Illustrative' : ''}`, + }); + for (const tr of m.tracks || []) { + const st = Math.max(score(tr.label, q), score(tr.callsign, q)); + if (st) + push(st, { + id: `moment:${m.id}:${tr.id}`, + kind: 'track', + title: tr.label, + subtitle: m.title, + }); + } + } + const best = new Map(); + for (const o of out) + if (!best.has(o.id) || best.get(o.id)._s < o._s) best.set(o.id, o); + return [...best.values()] + .sort((a, b) => b._s - a._s) + .slice(0, 30) + .map(({ _s, ...rest }) => rest); + } + + /* ── Graph ─────────────────────────────────────────────────── */ + + function graph(ref, { max = 40 } = {}) { + const r = parseRef(ref); + if (!r) return { nodes: [], edges: [] }; + const nodes = new Map(); + const edges = []; + const add = (id, kind, title) => { + if (!nodes.has(id) && nodes.size < max) + nodes.set(id, { id, kind, title }); + return nodes.has(id); + }; + const link = (from, l) => { + if (add(l.id, l.kind, l.title)) + edges.push({ from, to: l.id, relation: l.relation }); + }; + const cached = [...dossierCache.values()].map((x) => x.d); + const dossierOf = (id) => cached.find((d) => d.id === id); + let centerId; + if (r.type === 'situation') { + const s = env.situations().get(r.key) || env.detector.get(r.key); + if (!s) return { nodes: [], edges: [] }; + centerId = `situation:${s.id}`; + add(centerId, 'situation', s.title); + for (const l of situationLinks(s)) link(centerId, l); + } else if (r.type === 'aircraft') { + const live = liveAircraft(r.key); + const meta = recorder.meta(r.key); + centerId = `${live?.layer || meta?.layer || 'flights'}:${r.key}`; + add( + centerId, + live?.r?.helicopter ? 'helicopter' : 'aircraft', + live?.r?.callsign || meta?.callsign || r.key, + ); + const st = live?.r || recorder.stateAt(r.key, env.timeMs()); + const here = st ? { lon: st.lon, lat: st.lat } : null; + const d = dossierOf(centerId); + const links = + d?.links || + aircraftLinks(r.key, live?.r, here, identityCache.get(r.key)); + for (const l of links) link(centerId, l); + } else { + const d = cached.find((x) => parseRef(x.id)?.key === r.key); + if (!d) return { nodes: [], edges: [] }; + centerId = d.id; + add(centerId, d.kind, d.title); + for (const l of d.links) link(centerId, l); + } + // Second ring: members of linked situations, linked situations of members. + for (const n of [...nodes.values()]) { + if (n.id === centerId || nodes.size >= max) continue; + const pr = parseRef(n.id); + if (pr?.type === 'situation') { + const s = env.situations().get(pr.key) || env.detector.get(pr.key); + for (const m of s?.members || []) + link(n.id, { + id: `${m.layer || 'flights'}:${m.key}`, + kind: m.helicopter ? 'helicopter' : 'aircraft', + title: m.callsign || m.key, + relation: 'circling', + }); + } + } + return { center: centerId, nodes: [...nodes.values()], edges }; + } + + return { entity, search, graph, parseRef, identityCache }; +} diff --git a/mobile/globe/feeds.js b/mobile/globe/feeds.js index 9968a057f..f34aafa7c 100644 --- a/mobile/globe/feeds.js +++ b/mobile/globe/feeds.js @@ -208,6 +208,11 @@ export function createMilitaryFeed() { cls, helicopter: cls === 'helicopter', military: true, + // adsb.lol dbFlags: 4 = PIA, 8 = LADD (owner privacy programmes). + pia: Boolean(a.dbFlags & 4), + ladd: Boolean(a.dbFlags & 8), + seenAt: + Date.now() - (finite(a.seen_pos) ?? finite(a.seen) ?? 0) * 1000, }); } return { diff --git a/mobile/globe/gazetteer.js b/mobile/globe/gazetteer.js index 183ce8a0c..b5ebbbb80 100644 --- a/mobile/globe/gazetteer.js +++ b/mobile/globe/gazetteer.js @@ -245,3 +245,95 @@ export function describePlace(lat, lon, list) { if (p.km < 15) return p.name; return `${p.km.toLocaleString('en-US')} km ${p.dir} of ${p.name}`; } + +/** + * Neighbourhoods and landmarks in the cities where helicopters gather + * (news, police, tours) — [name, lon, lat, radiusKm]. Public centroids, + * rounded. Used to name a detection ("circling Midtown Manhattan"). + */ +export const NEIGHBORHOODS = Object.freeze([ + ['Midtown Manhattan', -73.9851, 40.7549, 1.6], + ['Lower Manhattan', -74.0091, 40.7075, 1.4], + ['Upper East Side', -73.9566, 40.7736, 1.5], + ['Upper West Side', -73.9754, 40.787, 1.5], + ['Central Park', -73.9654, 40.7829, 1.2], + ['Harlem', -73.9465, 40.8116, 1.6], + ['Chelsea, Manhattan', -74.0014, 40.7465, 0.9], + ['Greenwich Village', -74.0037, 40.7336, 0.9], + ['the Lower East Side', -73.9861, 40.715, 1.0], + ['Washington Heights', -73.9393, 40.8417, 1.4], + ['the South Bronx', -73.9162, 40.8166, 2.0], + ['the Bronx', -73.8648, 40.8448, 4.0], + ['Downtown Brooklyn', -73.9857, 40.6928, 1.2], + ['Williamsburg, Brooklyn', -73.9573, 40.7081, 1.4], + ['Brooklyn', -73.9442, 40.6782, 5.0], + ['Long Island City', -73.9485, 40.7447, 1.4], + ['Queens', -73.7949, 40.7282, 6.0], + ['Staten Island', -74.1502, 40.5795, 6.0], + ['Jersey City', -74.0776, 40.7282, 2.5], + ['Hoboken', -74.0324, 40.744, 1.0], + ['Newark', -74.1724, 40.7357, 3.0], + ['JFK Airport', -73.7781, 40.6413, 3.0], + ['LaGuardia Airport', -73.874, 40.7769, 1.6], + ['Newark Airport', -74.1745, 40.6895, 2.5], + ['Downtown Los Angeles', -118.2468, 34.0407, 2.0], + ['Hollywood', -118.3287, 34.0928, 2.0], + ['Koreatown, Los Angeles', -118.3009, 34.0618, 1.5], + ['South Los Angeles', -118.2827, 33.9897, 3.5], + ['Santa Monica', -118.4912, 34.0195, 2.5], + ['Venice, Los Angeles', -118.4695, 33.985, 1.6], + ['Long Beach', -118.1937, 33.7701, 4.0], + ['Pasadena', -118.1445, 34.1478, 3.0], + ['Burbank', -118.309, 34.1808, 3.0], + ['the San Fernando Valley', -118.45, 34.2, 8.0], + ['Inglewood', -118.3531, 33.9617, 2.5], + ['Compton', -118.2201, 33.8958, 2.5], + ['LAX', -118.4085, 33.9416, 2.5], + ['Anaheim', -117.9145, 33.8366, 3.5], + ['Westminster, London', -0.1357, 51.4975, 1.4], + ['the City of London', -0.0918, 51.5155, 1.2], + ['Canary Wharf', -0.0235, 51.5054, 1.2], + ['Camden, London', -0.1426, 51.539, 1.6], + ['Hackney, London', -0.0553, 51.545, 2.0], + ['Brixton, London', -0.1145, 51.4613, 1.6], + ['Stratford, London', -0.0035, 51.5413, 1.6], + ['Croydon', -0.0982, 51.3762, 3.0], + ['Heathrow', -0.4543, 51.47, 3.0], + ['the Loop, Chicago', -87.6298, 41.8837, 1.4], + ['the South Side, Chicago', -87.62, 41.78, 5.0], + ['the West Side, Chicago', -87.72, 41.88, 4.0], + ['Downtown San Francisco', -122.4014, 37.7881, 1.5], + ['the Mission, San Francisco', -122.4194, 37.7599, 1.4], + ['Oakland', -122.2711, 37.8044, 4.0], + ['Downtown Seattle', -122.3321, 47.6062, 1.5], + ['Downtown Houston', -95.3698, 29.7604, 2.0], + ['Downtown Dallas', -96.797, 32.7767, 2.0], + ['Downtown Miami', -80.1918, 25.7743, 1.6], + ['Miami Beach', -80.13, 25.7907, 2.5], + ['Downtown Atlanta', -84.388, 33.749, 2.0], + ['Downtown Phoenix', -112.074, 33.4484, 2.5], + ['Las Vegas Strip', -115.1728, 36.1147, 2.5], + ['Downtown Toronto', -79.3832, 43.6532, 2.0], + ['Central Paris', 2.3488, 48.8534, 2.5], + ['La Défense', 2.2385, 48.8918, 1.4], + ['Mitte, Berlin', 13.4049, 52.52, 2.5], + ['Central Sydney', 151.2093, -33.8688, 2.0], + ['Shinjuku, Tokyo', 139.7036, 35.6938, 2.0], + ['Chiyoda, Tokyo', 139.7536, 35.6938, 2.0], +]); + +/** + * The most local name for a point: a neighbourhood when it is inside one, + * else "N km DIR of City". Returns { name, local:boolean }. + */ +export function localPlace(lat, lon) { + let best = null; + for (const [name, plon, plat, r] of NEIGHBORHOODS) { + if (Math.abs(plat - lat) > 0.2) continue; + const km = haversineKm(lat, lon, plat, plon); + if (km <= r * 1.35 && (!best || km / r < best.score)) + best = { name, score: km / r }; + } + if (best) return { name: best.name, local: true }; + return { name: describePlace(lat, lon), local: false }; +} diff --git a/mobile/globe/ghosts.js b/mobile/globe/ghosts.js new file mode 100644 index 000000000..7e9e821c0 --- /dev/null +++ b/mobile/globe/ghosts.js @@ -0,0 +1,172 @@ +/** + * History view (DESIGN.md §12.5): when the clock is in the recorded past, + * every recorded contact is drawn where it actually was, interpolated + * between polls, with a ghost trail of the four minutes before. + * + * One BillboardCollection (glyphs move in place, keyed by entity) and one + * PolylineCollection for trails, rebuilt at most 4×/s and only for the + * contacts nearest the view centre. + */ +import * as Cesium from 'cesium'; +import { glyph } from './glyphs.js'; + +const D2R = Math.PI / 180; +const GLYPH_CAP = 900; +const TRAIL_CAP = 160; +const TRAIL_MS = 4 * 60_000; +const NEAR_FAR = new Cesium.NearFarScalar(2e4, 1.2, 3e6, 0.6); + +const COLORS = { + aircraft: Cesium.Color.fromCssColorString('#BFE6FF'), + helicopter: Cesium.Color.fromCssColorString('#9BE15D'), + military: Cesium.Color.fromCssColorString('#FFD166'), + vessel: Cesium.Color.fromCssColorString('#38E1C6'), + emergency: Cesium.Color.fromCssColorString('#FF3B30'), +}; + +export function createGhosts({ scene, recorder, requestRender }) { + const root = scene.primitives.add(new Cesium.PrimitiveCollection()); + root.show = false; + const glyphs = root.add(new Cesium.BillboardCollection()); + const trails = root.add(new Cesium.PolylineCollection()); + const byKey = new Map(); // key → { bb, state } + let lastTrails = 0; + let shown = false; + let lastMs = 0; + + const colorOf = (meta) => + meta?.emergency ? COLORS.emergency : COLORS[meta?.kind] || COLORS.aircraft; + + function hide() { + if (!shown) return; + shown = false; + root.show = false; + glyphs.removeAll(); + trails.removeAll(); + byKey.clear(); + requestRender(); + } + + function update(ms, view, { force = false } = {}) { + lastMs = ms; + const rect = view?.rect + ? { + west: view.rect.west - 0.5, + east: view.rect.east + 0.5, + south: view.rect.south - 0.5, + north: view.rect.north + 0.5, + } + : null; + const list = recorder.snapshotAt(ms, { rect }); + const c = view?.center || { lon: 0, lat: 0 }; + const cos = Math.cos(c.lat * D2R); + for (const s of list) + s.d = (s.lat - c.lat) ** 2 + ((s.lon - c.lon) * cos) ** 2; + list.sort((a, b) => a.d - b.d); + const keep = list.slice(0, GLYPH_CAP); + const seen = new Set(); + for (const s of keep) { + seen.add(s.key); + let e = byKey.get(s.key); + const pos = Cesium.Cartesian3.fromDegrees(s.lon, s.lat, s.altM || 0); + if (!e) { + const g = glyph( + s.meta?.kind === 'vessel' + ? 'ship' + : s.meta?.helicopter + ? 'heli' + : 'plane', + ); + e = { + bb: glyphs.add({ + position: pos, + image: g.image, + imageId: g.imageId, + color: colorOf(s.meta).withAlpha(0.92), + scale: s.meta?.helicopter ? 0.55 : 0.46, + alignedAxis: Cesium.Cartesian3.UNIT_Z, + scaleByDistance: NEAR_FAR, + disableDepthTestDistance: 150_000, + id: { layer: 'history', key: s.key }, + }), + }; + byKey.set(s.key, e); + } else e.bb.position = pos; + e.bb.rotation = -(s.headingDeg || 0) * D2R; + e.state = s; + } + for (const [key, e] of byKey) + if (!seen.has(key)) { + glyphs.remove(e.bb); + byKey.delete(key); + } + const now = performance.now(); + if (force || now - lastTrails > 250) { + lastTrails = now; + trails.removeAll(); + for (const s of keep.slice(0, TRAIL_CAP)) { + const pts = recorder.trail(s.key, ms - TRAIL_MS, ms, 60); + if (pts.length < 2) continue; + trails.add({ + positions: pts.map(([lo, la, h]) => + Cesium.Cartesian3.fromDegrees(lo, la, h || 0), + ), + width: 2.5, + material: Cesium.Material.fromType('PolylineGlow', { + color: colorOf(s.meta).withAlpha(0.7), + glowPower: 0.25, + taperPower: 0.4, + }), + }); + } + } + shown = true; + root.show = true; + requestRender(); + return keep.length; + } + + return { + update, + hide, + get shown() { + return shown; + }, + get glyphs() { + return glyphs; + }, + pick(key) { + const e = byKey.get(key); + if (!e?.state) return null; + const s = e.state; + const m = s.meta || {}; + const layer = m.layer || 'flights'; + return { + kind: m.kind || 'aircraft', + id: key, + entityId: `${layer}:${key}`, + title: m.callsign || m.title || key.toUpperCase(), + subtitle: [ + 'Recorded', + new Date(lastMs).toISOString().slice(11, 19) + 'Z', + `${Math.round((s.altM * 3.28084) / 100) * 100} ft`, + `${Math.round(s.speed / 0.514444)} kt`, + ].join(' · '), + lon: s.lon, + lat: s.lat, + meta: { + layer: 'history', + entityLayer: layer, + icao24: key, + altitudeM: s.altM, + speedMps: s.speed, + headingDeg: s.headingDeg, + recordedAt: lastMs, + }, + }; + }, + destroy() { + scene.primitives.remove(root); + }, + }; +} diff --git a/mobile/globe/idb.js b/mobile/globe/idb.js new file mode 100644 index 000000000..cf1273af0 --- /dev/null +++ b/mobile/globe/idb.js @@ -0,0 +1,124 @@ +/** + * A minimal promise wrapper over IndexedDB for the engine's own stores + * (recorder segments, the last good situations snapshot). Every call fails + * soft: no IndexedDB (private mode, insecure frames) resolves to null. + */ +const DB_NAME = 'gev-globe'; +const DB_VERSION = 1; +export const STORES = Object.freeze(['seg', 'meta', 'kv']); + +let dbPromise = null; + +function open() { + if (dbPromise) return dbPromise; + dbPromise = new Promise((resolve) => { + let req; + try { + req = globalThis.indexedDB?.open(DB_NAME, DB_VERSION); + } catch { + resolve(null); + return; + } + if (!req) { + resolve(null); + return; + } + req.onupgradeneeded = () => { + const db = req.result; + for (const name of STORES) + if (!db.objectStoreNames.contains(name)) db.createObjectStore(name); + }; + req.onsuccess = () => resolve(req.result); + req.onerror = () => resolve(null); + req.onblocked = () => resolve(null); + }); + return dbPromise; +} + +function done(req) { + return new Promise((resolve) => { + req.onsuccess = () => resolve(req.result); + req.onerror = () => resolve(null); + }); +} + +export async function idbGet(store, key) { + const db = await open(); + if (!db) return null; + try { + return await done(db.transaction(store).objectStore(store).get(key)); + } catch { + return null; + } +} + +export async function idbPut(store, key, value) { + const db = await open(); + if (!db) return false; + try { + await done( + db.transaction(store, 'readwrite').objectStore(store).put(value, key), + ); + return true; + } catch { + return false; + } +} + +/** Put many [key, value] pairs in one transaction. */ +export async function idbPutMany(store, entries) { + const db = await open(); + if (!db || !entries.length) return false; + return new Promise((resolve) => { + try { + const tx = db.transaction(store, 'readwrite'); + const os = tx.objectStore(store); + for (const [k, v] of entries) os.put(v, k); + tx.oncomplete = () => resolve(true); + tx.onerror = () => resolve(false); + tx.onabort = () => resolve(false); + } catch { + resolve(false); + } + }); +} + +/** All [key, value] pairs with lower <= key (numeric keys). */ +export async function idbEntries(store, lower = null) { + const db = await open(); + if (!db) return []; + return new Promise((resolve) => { + const out = []; + try { + const range = + lower == null ? null : globalThis.IDBKeyRange.lowerBound(lower); + const req = db.transaction(store).objectStore(store).openCursor(range); + req.onsuccess = () => { + const c = req.result; + if (!c) return resolve(out); + out.push([c.key, c.value]); + c.continue(); + }; + req.onerror = () => resolve(out); + } catch { + resolve(out); + } + }); +} + +/** Delete keys below `upper` (numeric keys). */ +export async function idbDeleteBelow(store, upper) { + const db = await open(); + if (!db) return false; + try { + await done( + db + .transaction(store, 'readwrite') + .objectStore(store) + .delete(globalThis.IDBKeyRange.upperBound(upper, true)), + ); + return true; + } catch { + return false; + } +} diff --git a/mobile/globe/index.js b/mobile/globe/index.js index 1271e3c08..5c2f179ea 100644 --- a/mobile/globe/index.js +++ b/mobile/globe/index.js @@ -30,6 +30,22 @@ * labels() entries may carry `detail` ('CAT 2 · 85 KT · 974 HPA', 'SQ 7700') * New layers: radar, clouds, lightning, wind, jet, air-quality, gnss, * transit; cyclones gain a filled cone and NHC wind radii. + * + * Round-three additions (DESIGN.md §12, full notes in ./API.md): + * + * globe.situations({ cached: true }) instant first frame (IDB / bundled) + * globe.cachedThumbnail(situation) bundled / cached thumb URL (sync) + * globe.history() → { start, end, entities, points } the recorder + * globe.trackOf(entityId) → Promise<[{ t, lon, lat, altM, headingDeg, speed }]> + * globe.playback.play({ speed }) / stop() / state() event 'playback' + * globe.timeline({ from, to }) → [{ t, kind, band, title, severity, … }] + * globe.detections() → Situation[] circling, quake clusters + * globe.moments() / moment(id) / momentOfTheDay() / playMoment(m, opts) + * / exitMoment() / activeMoment() / seekMoment(t) / momentCamera(on) + * event 'moment' → { type, item, t, momentId } + * globe.entity(ref) → Promise globe.search(q) globe.graph(ref) + * globe.react({ lon, lat, kind, count }) globe.attentionHeat(points) + * globe.skyNow({ lon, lat }) → Promise<{ aircraft, satellites, iss }> */ import * as Cesium from 'cesium'; import { createImagery } from './imagery.js'; @@ -68,6 +84,25 @@ import { createPins } from './pins.js'; import { createCompositor } from './compositor.js'; import { haversineKm } from './geo.js'; import { applyModelAtmosphereWorkaround } from '../../src/app/atmosphereCompat.js'; +import { createRecorder } from './recorder.js'; +import { createDetector } from './detect.js'; +import { circlingCard, quakeClusterCard } from './detectCards.js'; +import { createGhosts } from './ghosts.js'; +import { createStage } from './stage.js'; +import { + loadBuildings, + loadHero, + momentFromAircraft, + momentFromCircling, +} from './moments.js'; +import { createEntities } from './entities.js'; +import { createReactions } from './reactions.js'; +import { skyNow } from './sky.js'; +import { + cachedThumbnail, + loadCachedSituations, + saveSituations, +} from './cache.js'; export { LENSES, FAMILIES }; @@ -142,6 +177,19 @@ const DATA_CREDITS = { transit: 'Transit: agency GTFS-realtime feeds (see per-feed credit)', }; +/** + * Where helicopters gather for news: when OpenSky is unavailable the flights + * feed is a 250 nm snapshot around the view, so the recorder also polls + * these anchors (and the viewer) to give the circling detector real data. + */ +const WATCH_ANCHORS = Object.freeze([ + { key: 'watch:nyc', lat: 40.75, lon: -73.98 }, + { key: 'watch:lon', lat: 51.51, lon: -0.12 }, + { key: 'watch:la', lat: 34.05, lon: -118.25 }, +]); +const WATCH_POLL_MS = 15_000; +const PLAYBACK_SPEEDS = Object.freeze([1, 10, 30, 60, 600]); + function viewerOptions(creditContainer, options) { return { animation: false, @@ -332,6 +380,7 @@ export async function createGlobe(container, options = {}) { active: () => active && document.visibilityState !== 'hidden', timeMs, isLive: () => live, + timeMode: (ms, isLive) => timeMode(ms, isLive), layersChanged() { if (layersTimer) return; layersTimer = setTimeout(() => { @@ -340,9 +389,89 @@ export async function createGlobe(container, options = {}) { }, 60); }, }; + // ── Recorder, detector, history, Moments ───────────────────────── + const recorder = createRecorder({ persist: opts.record !== false }); + const detector = createDetector(recorder); + let momentState = null; // { moment, idx, prevT, restore } + function timeMode(ms, isLive) { + if (momentState) return 'moment'; + if (!isLive && recorder.covers(ms, 90_000)) return 'history'; + return 'none'; + } + const ingestFeed = (feed, kind) => + feed.subscribe((f) => { + if (f.data?.records && f.error == null) + recorder.ingest(f.data.records, { kind }); + }); + const unsubs = [ + ingestFeed(feeds.flights, 'aircraft'), + ingestFeed(feeds.military, 'military'), + ingestFeed(feeds.vessels, 'vessel'), + ]; + // Regional snapshots (fallback anchors, situations, sky-now) are recorded too. + { + const get = feeds.regionalFlights.get.bind(feeds.regionalFlights); + const seenData = new WeakSet(); + feeds.regionalFlights.get = async (...args) => { + const data = await get(...args); + if (data?.records && !seenData.has(data)) { + seenData.add(data); + recorder.ingest(data.records, { + kind: 'aircraft', + at: data.time || Date.now(), + }); + } + return data; + }; + } + recorder.load().catch(() => {}); + let watchTimer = null; + const watchAnchors = opts.watchAnchors ?? WATCH_ANCHORS; + async function pollWatch() { + watchTimer = setTimeout(pollWatch, WATCH_POLL_MS); + if (!ctx.active() || opts.record === false) return; + // With global OpenSky coverage the flights feed already records them. + const f = feeds.flights.data; + if (f && !f.regional && !feeds.flights.error) { + if (Date.now() - feeds.flights.updatedAt > 30_000) + feeds.flights.get({ maxAgeMs: 12_000 }).catch(() => {}); + } else { + const anchors = [...watchAnchors]; + if (viewerPos) + anchors.push({ + key: 'watch:viewer', + lat: viewerPos.lat, + lon: viewerPos.lon, + }); + await Promise.allSettled( + anchors.map((a) => + feeds.regionalFlights.get( + a.key, + { lat: a.lat, lon: a.lon }, + { maxAgeMs: WATCH_POLL_MS - 1000 }, + ), + ), + ); + } + feeds.military.get({ maxAgeMs: 20_000 }).catch(() => {}); + const before = detector.current().length; + const now = detector.run(); + if (now.length !== before) emit('detections', now); + } + watchTimer = setTimeout(pollWatch, 2500); + const layers = buildLayers(ctx, feeds); const pins = createPins({ scene, requestRender }); const compositor = createCompositor({ feeds }); + const ghosts = createGhosts({ scene, recorder, requestRender }); + const stage = createStage({ scene, requestRender, emit }); + const reactions = createReactions({ + host, + project: (lon, lat, altM) => api.project(lon, lat, altM), + }); + const removePostRender = scene.postRender.addEventListener(() => + reactions.afterRender(), + ); // Slow keyless sources warm in the background so the first feed has them. setTimeout(() => { for (const f of [ @@ -355,7 +484,7 @@ export async function createGlobe(container, options = {}) { feeds.clouds, ]) f.get().catch(() => {}); - }, 1500); + }, 4000); let viewerPos = opts.observer ? { lon: opts.observer.lon, lat: opts.observer.lat } : null; @@ -472,6 +601,8 @@ export async function createGlobe(container, options = {}) { lastView = computeView(); imagery.onHeight(lastView.heightM); for (const layer of layers.values()) if (layer.on) layer.onView(lastView); + if (!momentState && !live && timeMode(timeMs(), live) === 'history') + ghosts.update(timeMs(), lastView, { force: true }); emit('camera', { lon: lastView.center.lon, lat: lastView.center.lat, @@ -514,6 +645,12 @@ export async function createGlobe(container, options = {}) { if (id && typeof id === 'object' && id.layer === 'pins') { if (selected) api.select(null); emit('pick', pins.pick(id.key)); + } else if (id && typeof id === 'object' && id.layer === 'history') { + if (selected) api.select(null); + emit('pick', ghosts.pick(id.key)); + } else if (id && typeof id === 'object' && id.layer === 'moment') { + if (selected) api.select(null); + emit('pick', stage.pick(id.key)); } else if ( id && typeof id === 'object' && @@ -566,6 +703,8 @@ export async function createGlobe(container, options = {}) { timeTimer = null; const ms = timeMs(); for (const layer of layers.values()) if (layer.on) layer.onTime(ms, live); + if (timeMode(ms, live) === 'history') ghosts.update(ms, lastView); + else ghosts.hide(); if (selected) drawSelection(); requestRender(); } @@ -660,7 +799,441 @@ export async function createGlobe(container, options = {}) { }; } + // ── Clock control (scrub, playback, Moments) ─────────────────── + /** Put the clock at `ms` (the past or a Moment). Cheap enough per frame. */ + function setClock(ms, { fromPlayback = false } = {}) { + live = false; + clock.shouldAnimate = false; + clock.clockStep = Cesium.ClockStep.TICK_DEPENDENT; + clock.currentTime = Cesium.JulianDate.fromDate(new Date(ms)); + // Coalesce layer updates: ~20/s while scrubbing, ~5/s while playing. + if (!timeTimer) timeTimer = setTimeout(applyTime, fromPlayback ? 200 : 50); + if (momentState) { + stage.update(ms); + momentTick(ms, { fromPlayback }); + } else if (timeMode(ms, false) === 'history' && fromPlayback) + ghosts.update(ms, lastView); + requestRender(); + } + + let playing = false; + let playSpeed = 60; + let playRaf = 0; + let playLast = 0; + let playEmit = 0; + let playUntil = null; + function playbackState() { + return { playing, speed: playSpeed, t: timeMs(), live }; + } + function stopPlayback() { + if (!playing) return; + playing = false; + cancelAnimationFrame(playRaf); + playRaf = 0; + applyTime(); + emit('playback', playbackState()); + } + function playFrame(now) { + if (!playing) return; + const dt = Math.min(0.5, Math.max(0, (now - playLast) / 1000)); + playLast = now; + let t = timeMs() + dt * playSpeed * 1000; + const end = playUntil ?? Date.now(); + if (t >= end) { + t = end; + if (momentState) { + setClock(t, { fromPlayback: true }); + stopPlayback(); + return; + } + stopPlayback(); + api.setTime(null); + return; + } + setClock(t, { fromPlayback: true }); + if (now - playEmit > 250) { + playEmit = now; + emit('playback', playbackState()); + emit('time', { live: false, time: new Date(t), playing: true }); + } + playRaf = requestAnimationFrame(playFrame); + } + function startPlayback({ speed, from, until } = {}) { + if (Number.isFinite(speed) && speed > 0) playSpeed = speed; + playUntil = Number.isFinite(until) + ? until + : momentState + ? momentState.moment.time.end + : null; + let t = Number.isFinite(from) ? from : timeMs(); + if (live && !Number.isFinite(from)) { + // From now there is nothing to play forward: replay the last 15 min. + const h = recorder.range(); + t = Math.max( + h.start ?? Date.now() - 15 * 60_000, + Date.now() - 15 * 60_000, + ); + } + if (momentState && t >= momentState.moment.time.end - 500) + t = momentState.moment.time.start; + setClock(t, { fromPlayback: true }); + playing = true; + playLast = performance.now(); + cancelAnimationFrame(playRaf); + playRaf = requestAnimationFrame(playFrame); + emit('playback', playbackState()); + } + + // ── Moments ────────────────────────────────────────────────────── + const momentCache = new Map(); // id → Moment (bundled and built) + let heroLoaded = null; + function hero() { + if (!heroLoaded) + heroLoaded = loadHero().then((m) => { + momentCache.set(m.id, m); + return m; + }); + return heroLoaded; + } + function liveMoments() { + const out = []; + for (const det of detector.current()) { + const m = momentFromCircling(det, recorder); + if (m.tracks.length >= 1) { + momentCache.set(m.id, m); + out.push(m); + } + } + for (const e of recorder.events()) { + if (e.kind !== 'squawk' || Date.now() - e.t > 3 * 3600_000) continue; + const m = squawkMoment(e.key, e.title); + if (m) out.push(m); + } + return out; + } + function squawkMoment(key, title) { + const meta = recorder.meta(key); + const points = recorder + .samples(key) + .map((p) => ({ t: p.t, lon: p.lon, lat: p.lat, altM: p.altM })); + if (points.length < 4) return null; + const m = momentFromAircraft({ + id: `live-squawk-${key}`, + title: title || `${meta?.callsign || key} squawking`, + key, + points, + meta, + }); + if (m) momentCache.set(m.id, m); + return m; + } + async function resolveMoment(idOrMoment) { + if (idOrMoment && typeof idOrMoment === 'object') return idOrMoment; + const id = String(idOrMoment || ''); + if (!id || id === 'empire-state' || id === 'hero') return hero(); + if (id.startsWith('live-circling-')) { + const det = detector.get(id.slice(5)); + if (det) { + const m = momentFromCircling(det, recorder); + momentCache.set(m.id, m); + return m; + } + } + if (id.startsWith('live-squawk-')) { + const key = id.slice('live-squawk-'.length); + const ev = recorder.events().find((e) => e.key === key); + const m = squawkMoment(key, ev?.title); + if (m) return m; + } + return momentCache.get(id) || null; + } + const sortedBy = (list) => (list || []).slice().sort((a, b) => a.t - b.t); + function indexAfter(list, t) { + let lo = 0; + let hi = list.length; + while (lo < hi) { + const mid = (lo + hi) >> 1; + if (list[mid].t <= t) lo = mid + 1; + else hi = mid; + } + return lo; + } + /** Emit 'moment' events for items the clock just passed. */ + function momentTick(t, { fromPlayback = false } = {}) { + const st = momentState; + if (!st) return; + const jump = t - st.prevT; + const quiet = jump < 0 || (!fromPlayback && jump > 90_000); + for (const [type, list] of st.lists) { + const i1 = indexAfter(list, t); + if (!quiet) + for (let i = st.idx[type]; i < i1; i++) + emit('moment', { + type, + item: list[i], + t: list[i].t, + momentId: st.moment.id, + }); + st.idx[type] = i1; + } + st.prevT = t; + if (!st.ended && t >= st.moment.time.end - 1) { + st.ended = true; + emit('moment', { type: 'end', item: null, t, momentId: st.moment.id }); + } else if (t < st.moment.time.end - 1) st.ended = false; + } + + // ── Timeline ───────────────────────────────────────────────────── + let lastSituations = new Map(); + function timelineEvents({ from, to } = {}) { + const win = api.timeWindow(); + const lo = Number.isFinite(+from) ? +from : win.start.getTime(); + const hi = Number.isFinite(+to) ? +to : win.end.getTime(); + const out = []; + const add = (e) => { + if (Number.isFinite(e.t) && e.t >= lo && e.t <= hi) out.push(e); + }; + for (const q of feeds.quakes.data?.records || []) + if (q.time && q.mag >= 4) + add({ + t: q.time, + kind: 'quake', + band: 'ground', + title: `M${q.mag.toFixed(1)} ${q.place || ''}`.trim(), + severity: q.mag >= 6.5 ? 3 : q.mag >= 5.5 ? 2 : q.mag >= 4.5 ? 1 : 0, + entityId: `earthquakes:${q.stableId}`, + lon: q.lon, + lat: q.lat, + }); + for (const c of detector.quakeClusters(feeds.quakes.data?.records)) + add({ + t: c.since, + kind: 'quake-cluster', + band: 'ground', + title: c.title, + severity: 2, + situationId: c.id, + lon: c.lon, + lat: c.lat, + }); + for (const l of feeds.launches.data?.records || []) + add({ + t: l.net, + kind: 'launch', + band: 'orbit', + title: l.name, + severity: 1, + entityId: `launches:${l.id}`, + lon: l.lon, + lat: l.lat, + }); + for (const e of recorder.events()) + add({ + t: e.t, + kind: 'squawk', + band: 'sky', + title: e.title, + severity: 3, + entityId: `flights:${e.key}`, + momentId: `live-squawk-${e.key}`, + lon: e.lon, + lat: e.lat, + }); + for (const s of feeds.cyclones.data?.records || []) + add({ + t: s.t, + kind: 'cyclone', + band: 'orbit', + title: + `${s.label || s.classification || 'Storm'} ${s.name || ''} advisory`.trim(), + severity: s.windKt >= 96 ? 3 : s.windKt >= 64 ? 2 : 1, + entityId: `cyclones:${s.id}`, + lon: s.lon, + lat: s.lat, + }); + const fires = (feeds.fires.data?.records || []) + .filter((f) => Number.isFinite(f.t)) + .sort((a, b) => (b.frp ?? b.acres ?? 0) - (a.frp ?? a.acres ?? 0)) + .slice(0, 30); + for (const f of fires) + add({ + t: f.t, + kind: 'fire', + band: 'ground', + title: f.title || 'Fire', + severity: 1, + entityId: `fires:${f.id}`, + lon: f.lon, + lat: f.lat, + }); + for (const d of detector.history()) add({ ...d, band: 'sky', severity: 2 }); + // Lightning onset: the first 15-min bin that jumps well above the + // series' earlier median, from the live lightning card. + for (const s of lastSituations.values()) { + if (s.kind !== 'lightning' || !(s.series?.length > 4)) continue; + const vals = s.series.map((p) => p.v); + for (let i = 3; i < vals.length; i++) { + const prior = vals.slice(0, i).sort((a, b) => a - b); + const med = prior[Math.floor(prior.length / 2)]; + if (vals[i] > Math.max(3 * med, med + 50)) { + add({ + t: s.series[i].t, + kind: 'lightning', + band: 'sky', + title: `Lightning onset · ${s.place || s.title}`, + severity: 1, + situationId: s.id, + lon: s.lon, + lat: s.lat, + }); + break; + } + } + } + // Moments: the active one's captures, posts, chat bursts and beats. + const ms = [...momentCache.values()]; + for (const m of ms) { + if (m.time.end < lo || m.time.start > hi) continue; + for (const b of m.beats || []) + add({ + t: b.t, + kind: 'moment', + band: 'sky', + title: b.title, + severity: 1, + momentId: m.id, + }); + for (const c of m.captures || []) + add({ + t: c.t, + kind: 'capture', + band: 'inside', + title: `${c.firstEyes ? 'First eyes · ' : ''}@${c.handle} · ${c.title}`, + severity: c.firstEyes ? 2 : 1, + momentId: m.id, + entityId: `capture:${m.id}:${c.id}`, + lon: c.lon, + lat: c.lat, + }); + for (const p of m.posts || []) + add({ + t: p.t, + kind: 'post', + band: 'inside', + title: `${p.kind}: ${p.text.slice(0, 70)}`, + severity: 0, + momentId: m.id, + }); + // Chat bursts: 6+ lines inside 30 s. + const chat = m.chat || []; + let lastBurst = -Infinity; + for (let i = 0; i + 5 < chat.length; i++) + if ( + chat[i + 5].t - chat[i].t < 30_000 && + chat[i].t - lastBurst > 60_000 + ) { + lastBurst = chat[i].t; + add({ + t: chat[i].t, + kind: 'chat-burst', + band: 'inside', + title: `Chat burst: “${chat[i + 2].text.slice(0, 40)}”`, + severity: 0, + momentId: m.id, + }); + } + } + return out.sort((a, b) => a.t - b.t); + } + + // ── Entities ───────────────────────────────────────────────────── + const trackCache = new Map(); + async function trackOf(key, layer) { + key = String(key).toLowerCase(); + const cached = trackCache.get(key); + // A failed fetch is remembered for 5 min so a dead route costs nothing. + const ttl = cached?.points?.length ? 60_000 : 5 * 60_000; + let remote = cached && Date.now() - cached.at < ttl ? cached.points : null; + let source = cached?.source || null; + if (!remote && /^[0-9a-f]{6}$/.test(key)) { + remote = []; + const tryJson = async (url) => { + try { + const r = await fetch(url, { signal: AbortSignal.timeout(7000) }); + return r.ok ? await r.json() : null; + } catch { + return null; + } + }; + // OpenSky first for civil traffic; adsb.lol traces cover everything. + const sky = + layer === 'military' + ? null + : await tryJson(`/api/flights/track?icao24=${key}`); + if (Array.isArray(sky?.path)) { + source = 'OpenSky Network tracks'; + for (const [tSec, lat, lon, baro, trk] of sky.path) + if (Number.isFinite(lat) && Number.isFinite(lon)) + remote.push({ + t: tSec * 1000, + lon, + lat, + altM: baro ?? 0, + headingDeg: trk ?? 0, + speed: 0, + }); + } else { + const lol = await tryJson(`/api/military/track?hex=${key}`); + if (Array.isArray(lol?.trace)) { + source = 'adsb.lol traces (ODbL)'; + const t0 = (lol.timestamp || 0) * 1000; + for (const p of lol.trace) { + const [dt, lat, lon, alt, gs, trk] = p; + if (!Number.isFinite(lat) || !Number.isFinite(lon)) continue; + remote.push({ + t: t0 + dt * 1000, + lon, + lat, + altM: alt === 'ground' ? 0 : (alt ?? 0) * 0.3048, + headingDeg: trk ?? 0, + speed: (gs ?? 0) * 0.514444, + }); + } + } + } + trackCache.set(key, { at: Date.now(), points: remote, source }); + if (remote.length) + recorder.merge(key, remote, recorder.meta(key) || undefined); + } + const pts = recorder.samples(key); + const out = pts.length ? pts : remote || []; + out.source = source + ? `${source} + God’s Eye recorder` + : 'God’s Eye recorder'; + return out; + } + const entities = createEntities({ + feeds, + recorder, + detector, + situations: () => { + const m = new Map(lastSituations); + for (const d of detector.current()) if (!m.has(d.id)) m.set(d.id, d); + return m; + }, + moments: { + get: (id) => resolveMoment(id), + cached: () => [...momentCache.values()], + }, + viewer: () => viewerPos, + timeMs, + trackOf, + }); + hero().catch(() => {}); + // ── API ────────────────────────────────────────────────────────── + let booting = false; + const userTouched = new Set(); const contactsNearImpl = createContactIndex(feeds, { active: ctx.active }); const api = { @@ -675,6 +1248,7 @@ export async function createGlobe(container, options = {}) { }, setLayer(id, on) { + if (!booting) userTouched.add(id); const layer = layers.get(id); if (!layer) throw new RangeError(`Unknown layer: ${id}`); if (!layer.available) return false; @@ -694,6 +1268,12 @@ export async function createGlobe(container, options = {}) { setTime(date) { if (date == null) { + // NOW leaves a Moment too (the camera stays where it is). + if (momentState) { + api.exitMoment({ restoreCamera: false }); + return; + } + if (playing) stopPlayback(); live = true; clock.clockStep = Cesium.ClockStep.SYSTEM_CLOCK; clock.shouldAnimate = true; @@ -705,13 +1285,7 @@ export async function createGlobe(container, options = {}) { const ms = date instanceof Date ? date.getTime() : Number(date); if (!Number.isFinite(ms)) throw new TypeError('setTime needs a Date, epoch ms or null'); - live = false; - clock.shouldAnimate = false; - clock.clockStep = Cesium.ClockStep.TICK_DEPENDENT; - clock.currentTime = Cesium.JulianDate.fromDate(new Date(ms)); - // Coalesce a fast scrub into ~20 layer updates a second. - if (!timeTimer) timeTimer = setTimeout(applyTime, 50); - requestRender(); + setClock(ms); emit('time', { live: false, time: new Date(ms) }); }, @@ -835,16 +1409,254 @@ export async function createGlobe(container, options = {}) { situations(extra = {}) { const observer = extra.observer ?? viewerPos ?? opts.observer; - return buildSituations({ feeds, timeMs }, { observer }).then((list) => { + const withDistance = (list) => { if (observer && Number.isFinite(observer.lat)) for (const s of list) s.distanceKm = Math.round( haversineKm(observer.lat, observer.lon, s.lat, s.lon), ); return list; + }; + if (extra.cached) return loadCachedSituations().then(withDistance); + return buildSituations({ feeds, timeMs }, { observer }).then((list) => { + for (const s of list) + if (s.kind === 'squawk') s.momentId = `live-${s.id}`; + // Detections on real data join the feed at the top of their band. + detector.run({ force: true }); + const extraCards = []; + for (const d of detector.current()) + try { + extraCards.push(circlingCard(d, recorder)); + } catch (error) { + console.warn('[globe:circling]', error); + } + for (const c of detector.quakeClusters(feeds.quakes.data?.records)) + extraCards.push(quakeClusterCard(c)); + const all = [...extraCards, ...list]; + lastSituations = new Map(all.map((s) => [s.id, s])); + saveSituations(all); + return withDistance(all); }); }, + /** Bundled or last-rendered thumbnail URL for a (cached) situation, sync. */ + cachedThumbnail(situation) { + return cachedThumbnail(situation); + }, + + /** Current detections (circling, quake clusters) as Situations, sync. */ + detections() { + const out = []; + for (const d of detector.current()) out.push(circlingCard(d, recorder)); + for (const c of detector.quakeClusters(feeds.quakes.data?.records)) + out.push(quakeClusterCard(c)); + return out; + }, + + /** The recorder's range: { start, end, entities, points } (epoch ms). */ + history() { + const r = recorder.range(); + return { + start: r.start, + end: r.end, + entities: r.entities, + points: r.points, + bytes: r.bytes, + }; + }, + + trackOf(entityId) { + const ref = entities.parseRef(entityId); + return trackOf(ref?.key ?? entityId, ref?.layer); + }, + + playback: { + speeds: PLAYBACK_SPEEDS, + play(o = {}) { + startPlayback(o); + return playbackState(); + }, + stop() { + stopPlayback(); + return playbackState(); + }, + state: playbackState, + }, + + timeline(range) { + return timelineEvents(range); + }, + + async moments() { + const out = liveMoments(); + try { + out.push(await hero()); + } catch { + /* bundled file missing */ + } + return out; + }, + + moment(id) { + return resolveMoment(id); + }, + + async momentOfTheDay() { + const live = liveMoments() + .filter( + (m) => m.tracks.length >= 2 || m.time.end - m.time.start > 5 * 60_000, + ) + .sort((a, b) => b.tracks.length - a.tracks.length); + return live[0] || hero(); + }, + + async playMoment( + idOrMoment, + { speed, camera = true, autoplay = true, framing } = {}, + ) { + const m = await resolveMoment(idOrMoment); + if (!m) throw new Error(`Unknown moment: ${idOrMoment}`); + stopPlayback(); + const restore = momentState?.restore || { + destination: camera + ? Cesium.Cartesian3.clone(scene.camera.positionWC) + : null, + heading: scene.camera.heading, + pitch: scene.camera.pitch, + wasLive: live, + time: timeMs(), + }; + if (selected) api.select(null); + const buildings = m.stage?.buildings + ? await loadBuildings(m.stage.buildings) + : null; + const lists = [ + ['capture', sortedBy(m.captures)], + ['chat', sortedBy(m.chat)], + ['post', sortedBy(m.posts)], + ['beat', sortedBy(m.beats)], + ]; + momentState = { + moment: m, + lists, + idx: Object.fromEntries(lists.map(([k]) => [k, 0])), + prevT: m.time.start - 1, + restore, + ended: false, + }; + momentCache.set(m.id, m); + ghosts.hide(); + // The Moment owns the scene: every live layer steps aside. + for (const layer of layers.values()) + if (layer.root) layer.root.show = false; + await stage.load(m, { buildings }); + if (Number.isFinite(framing)) stage.setFraming(framing); + stage.setCinematic(camera); + setClock(m.time.start); + applyTime(); + emit('moment', { + type: 'start', + item: m, + t: m.time.start, + momentId: m.id, + }); + if (autoplay) + startPlayback({ + speed: speed ?? m.recommendedSpeed ?? 1, + from: m.time.start, + until: m.time.end, + }); + return m; + }, + + exitMoment({ restoreCamera = true } = {}) { + if (!momentState) return false; + const { restore, moment } = momentState; + stopPlayback(); + momentState = null; + stage.unload(); + for (const layer of layers.values()) + if (layer.root) layer.root.show = Boolean(layer.on); + emit('moment', { + type: 'exit', + item: null, + t: timeMs(), + momentId: moment.id, + }); + if (restore?.wasLive !== false) api.setTime(null); + else api.setTime(restore.time); + if (restoreCamera && restore?.destination) + scene.camera.flyTo({ + destination: restore.destination, + orientation: { + heading: restore.heading, + pitch: restore.pitch, + roll: 0, + }, + duration: 1.4, + }); + requestRender(); + return true; + }, + + activeMoment() { + if (!momentState) return null; + const m = momentState.moment; + return { + id: m.id, + title: m.title, + illustrative: Boolean(m.illustrative), + t: timeMs(), + start: m.time.start, + end: m.time.end, + playing, + speed: playSpeed, + cinematic: stage.cinematic, + moment: m, + }; + }, + + seekMoment(t) { + if (!momentState) return; + const m = momentState.moment; + const ms = + t >= 0 && t <= 1 + ? m.time.start + t * (m.time.end - m.time.start) + : Number(t); + setClock(Math.max(m.time.start, Math.min(m.time.end, ms))); + emit('time', { live: false, time: new Date(timeMs()) }); + }, + + momentCamera(on = true) { + stage.setCinematic(on); + requestRender(); + return stage.cinematic; + }, + + entity(ref) { + return entities.entity(ref); + }, + + search(query) { + return entities.search(query); + }, + + graph(ref) { + return entities.graph(ref); + }, + + react(r) { + return reactions.react(r); + }, + + attentionHeat(points) { + reactions.heat(points); + }, + + skyNow(pos = viewerPos) { + return skyNow(feeds, pos || {}); + }, + /** Genres the last situations() call left out, and why (for QA/UI). */ omitted() { return buildSituations.lastOmitted || []; @@ -964,7 +1776,10 @@ export async function createGlobe(container, options = {}) { const candidates = []; for (const layer of layers.values()) { const glyphs = - layer.on && layer.renderer?.glyphMode && layer.renderer.glyphs; + layer.on && + layer.root?.show !== false && + layer.renderer?.glyphMode && + layer.renderer.glyphs; if (!glyphs) continue; // Semantic zoom for words too: from orbit only the headline layers. if (planetary && !PLANETARY_LABELS.has(layer.id)) continue; @@ -1002,6 +1817,40 @@ export async function createGlobe(container, options = {}) { score: -50, }); } + for (const l of stage.labels()) { + const pos = Cesium.Cartesian3.fromDegrees(l.lon, l.lat, l.altM || 0); + if (!occluder.isPointVisible(pos)) continue; + const p = scene.cartesianToCanvasCoordinates(pos, scratch); + if (!p || p.x < 0 || p.y < 0 || p.x > w || p.y > h) continue; + const pick = { + id: l.id, + kind: l.kind, + title: l.title, + ...(l.detail ? { labelDetail: l.detail } : {}), + }; + candidates.push({ + layer: { id: 'moment', pick: () => pick }, + key: l.id, + x: p.x, + y: p.y, + score: l.score, + }); + } + if (ghosts.shown) + for (let i = 0; i < ghosts.glyphs.length && i < 400; i++) { + const bb = ghosts.glyphs.get(i); + if (!occluder.isPointVisible(bb.position)) continue; + const p = scene.cartesianToCanvasCoordinates(bb.position, scratch); + if (!p || p.x < 0 || p.y < 0 || p.x > w || p.y > h) continue; + const d = Math.hypot(p.x - w / 2, p.y - h / 2) / Math.max(w, h); + candidates.push({ + layer: { id: 'history', pick: (key) => ghosts.pick(key) }, + key: bb.id.key, + x: p.x, + y: p.y, + score: 10 + d * 4, + }); + } candidates.sort((a, b) => a.score - b.score); // Greedy placement: a label never overlaps one already placed. const placed = []; @@ -1054,12 +1903,25 @@ export async function createGlobe(container, options = {}) { requestRender, + /** Internals for dev harnesses and tests (not part of the contract). */ + get debug() { + return { recorder, detector, stage, ghosts }; + }, + get viewer() { return viewer; }, destroy() { clearInterval(tick); + clearTimeout(watchTimer); + cancelAnimationFrame(playRaf); + for (const u of unsubs) u(); + removePostRender(); + recorder.destroy(); + ghosts.destroy(); + stage.destroy(); + reactions.destroy(); clearTimeout(viewTimer); clearTimeout(layersTimer); clearTimeout(timeTimer); @@ -1087,9 +1949,52 @@ export async function createGlobe(container, options = {}) { }); api.setLens(opts.lens); lastView = computeView(); - for (const id of opts.layers ?? DEFAULT_LAYERS) - if (layers.has(id)) api.setLayer(id, true); - refreshLayerViews(); + // First frame first: the globe paints with imagery only, then the live + // layers start (heavy weather/ground layers a beat later). + const HEAVY = new Set([ + 'radar', + 'clouds', + 'lightning', + 'wind', + 'jet', + 'gnss', + 'transit', + 'starlink', + 'satellites', + ]); + const startIds = opts.layers ?? DEFAULT_LAYERS; + const startLayers = (heavy) => { + if (viewer.isDestroyed()) return; + booting = true; + for (const id of startIds) + if ( + layers.has(id) && + HEAVY.has(id) === heavy && + !layers.get(id).on && + !userTouched.has(id) + ) + api.setLayer(id, true); + booting = false; + refreshLayerViews(); + requestRender(); + }; + let started = false; + const removeFirstFrame = scene.postRender.addEventListener(() => { + if (started) return; + started = true; + setTimeout(() => removeFirstFrame(), 0); + setTimeout(() => startLayers(false), 30); + setTimeout(() => startLayers(true), 900); + }); + // A hidden tab never renders: start anyway after a second. + setTimeout(() => { + if (!started) { + started = true; + removeFirstFrame(); + startLayers(false); + startLayers(true); + } + }, 1200); requestRender(); // Listeners attach after this resolves: hand them the starting state. setTimeout(() => { diff --git a/mobile/globe/layers/air.js b/mobile/globe/layers/air.js index 05ff40c65..f5ceeab16 100644 --- a/mobile/globe/layers/air.js +++ b/mobile/globe/layers/air.js @@ -129,8 +129,12 @@ export class AircraftLayer extends Layer { } onTime(ms, live) { - // Aircraft are live-only: away from now they dim to show they are not + // Inside the recorded past the history layer draws where everything + // actually was, and inside a Moment its stage owns the sky: the live + // snapshot hides. Beyond the record, aircraft dim to show they are not // a reconstruction of that moment. + const mode = this.ctx.timeMode?.(ms, live) || 'none'; + this.root.show = this.on && mode === 'none'; this.renderer.setAlpha(live ? 1 : 0.3); } diff --git a/mobile/globe/moments.js b/mobile/globe/moments.js new file mode 100644 index 000000000..9410c04b0 --- /dev/null +++ b/mobile/globe/moments.js @@ -0,0 +1,180 @@ +/** + * Moments (DESIGN.md §12.4): 4D reconstructions on one clock. + * + * bundled the hero, "Climbers on the Empire State Building" + * (mobile/demo/moments/empire-state.json, illustrative: true) + * live built on demand from the recorder for every detection + * (circling, emergency squawk): real tracks, illustrative: false + */ +import { localPlace } from './gazetteer.js'; + +const HERO_URL = new URL('../demo/moments/empire-state.json', import.meta.url) + .href; +const BUILDINGS_URL = new URL('../demo/midtown-buildings.json', import.meta.url) + .href; +const D2R = Math.PI / 180; + +let heroPromise = null; +let buildingsPromise = null; + +export function loadHero() { + if (!heroPromise) + heroPromise = fetch(HERO_URL) + .then((r) => (r.ok ? r.json() : Promise.reject(new Error(r.status)))) + .catch((error) => { + heroPromise = null; + throw error; + }); + return heroPromise; +} + +export function loadBuildings(name) { + if (name !== 'midtown-buildings.json') return Promise.resolve(null); + if (!buildingsPromise) + buildingsPromise = fetch(BUILDINGS_URL) + .then((r) => (r.ok ? r.json() : null)) + .catch(() => { + buildingsPromise = null; + return null; + }); + return buildingsPromise; +} + +/** A slow orbit of camera keys around a point (for live Moments). */ +export function orbitCameraPath( + lon, + lat, + start, + end, + { rangeM = 2600, heightM = 1100, lookAltM = 250, startBearing = 200 } = {}, +) { + const keys = []; + const n = 9; + const kx = 111_320 * Math.cos(lat * D2R); + for (let i = 0; i < n; i++) { + const f = i / (n - 1); + const b = (startBearing + 140 * f) % 360; + const r = rangeM * (1.2 - 0.35 * Math.sin(Math.PI * f)); + const h = heightM * (1.15 - 0.3 * Math.sin(Math.PI * f)); + const x = Math.sin(b * D2R) * r; + const y = Math.cos(b * D2R) * r; + keys.push({ + t: Math.round(start + (end - start) * f), + lon: lon + x / kx, + lat: lat + y / 110_574, + height: Math.round(h), + heading: (b + 180) % 360, + pitch: (Math.atan2(lookAltM - h, r) * 180) / Math.PI, + }); + } + return keys; +} + +/** + * A live Moment from a circling detection, from the recorder's samples. + * @param {object} det detector output + * @param {object} recorder + */ +export function momentFromCircling(det, recorder) { + const start = Math.max(det.since - 4 * 60_000, Date.now() - 45 * 60_000); + const end = Math.max(det.updatedAt, Date.now()); + const tracks = []; + for (const m of det.members) { + const pts = recorder + .samples(m.key, start, end) + .map((p) => ({ t: p.t, lon: p.lon, lat: p.lat, altM: p.altM })); + if (pts.length < 2) continue; + const meta = recorder.meta(m.key) || {}; + tracks.push({ + id: m.key, + entityId: `${meta.layer || 'flights'}:${m.key}`, + kind: meta.helicopter ? 'helicopter' : 'aircraft', + label: meta.callsign || m.key.toUpperCase(), + callsign: meta.callsign || null, + registration: meta.registration || null, + type: meta.type || null, + operator: '', + points: pts, + }); + } + let maxAlt = 0; + for (const tr of tracks) + for (const p of tr.points) maxAlt = Math.max(maxAlt, p.altM); + const place = localPlace(det.lat, det.lon).name; + return { + id: `live-${det.id}`, + title: det.title, + place, + lon: det.lon, + lat: det.lat, + time: { start, end }, + illustrative: false, + live: true, + situationId: det.id, + recommendedSpeed: 30, + subject: { lon: det.lon, lat: det.lat, altM: 0, label: place }, + cameraPath: orbitCameraPath(det.lon, det.lat, start, end, { + rangeM: 2000, + heightM: Math.max(1400, maxAlt * 3), + lookAltM: maxAlt * 0.4, + }), + beats: [{ t: det.since, title: 'First complete orbit in the record' }], + tracks, + captures: [], + chat: [], + posts: [], + sources: [ + { + name: 'God’s Eye recorder', + detail: + 'Positions recorded from live ADS-B polls (OpenSky Network / adsb.lol, ODbL) in this browser.', + }, + { + name: 'Circling detector', + detail: `${det.members.length} aircraft each completed at least one orbit within 1.5 km of a common centre.`, + }, + ], + }; +} + +/** A live Moment for one aircraft (an emergency squawk) from its track. */ +export function momentFromAircraft({ id, title, key, points, meta, place }) { + if (!points?.length) return null; + const start = points[0].t; + const end = Math.max(points.at(-1).t, start + 60_000); + const last = points.at(-1); + return { + id, + title, + place: place || localPlace(last.lat, last.lon).name, + lon: last.lon, + lat: last.lat, + time: { start, end }, + illustrative: false, + live: true, + recommendedSpeed: 60, + subject: null, + follow: { trackId: key, rangeM: 22_000, heightM: 7_000 }, + cameraPath: [], + beats: [], + tracks: [ + { + id: key, + entityId: `${meta?.layer || 'flights'}:${key}`, + kind: meta?.helicopter ? 'helicopter' : 'aircraft', + label: meta?.callsign || key.toUpperCase(), + operator: '', + points, + }, + ], + captures: [], + chat: [], + posts: [], + sources: [ + { + name: 'God’s Eye recorder', + detail: 'Positions recorded from live ADS-B polls in this browser.', + }, + ], + }; +} diff --git a/mobile/globe/reactions.js b/mobile/globe/reactions.js new file mode 100644 index 000000000..4bbc6c8eb --- /dev/null +++ b/mobile/globe/reactions.js @@ -0,0 +1,169 @@ +/** + * Geolocated reactions (DESIGN.md §12.6): hearts, fire, eyes and wow rise + * from the reactor's place on the globe. A screen-space canvas over the + * viewer (pointer-events: none) draws pre-rendered emoji sprites; each + * particle is re-projected every frame so the burst stays anchored to its + * point while the globe moves. The loop runs only while particles live. + * + * attentionHeat(points) draws a soft additive glow where viewers are; it is + * redrawn after every globe render, so it costs nothing at rest. + */ +const KINDS = { heart: '❤️', fire: '🔥', eyes: '👀', wow: '😮' }; +const CAP = 300; +const LIFE_S = 2.6; + +export function createReactions({ host, project, onFrame }) { + const canvas = document.createElement('canvas'); + canvas.className = 'gev-reactions'; + canvas.style.cssText = + 'position:absolute;inset:0;width:100%;height:100%;pointer-events:none;z-index:2;'; + host.appendChild(canvas); + const g = canvas.getContext('2d'); + const sprites = new Map(); + const parts = []; + let heat = null; + let raf = 0; + let dpr = 1; + + function sprite(kind) { + let s = sprites.get(kind); + if (s) return s; + const size = 64; + const c = document.createElement('canvas'); + c.width = c.height = size; + const x = c.getContext('2d'); + x.textAlign = 'center'; + x.textBaseline = 'middle'; + x.font = `${size * 0.78}px "Apple Color Emoji","Segoe UI Emoji","Noto Color Emoji",sans-serif`; + x.shadowColor = 'rgba(0,0,0,0.45)'; + x.shadowBlur = 6; + x.fillText(KINDS[kind] || KINDS.heart, size / 2, size / 2 + 3); + s = c; + sprites.set(kind, s); + return s; + } + + function resize() { + dpr = Math.min(2, globalThis.devicePixelRatio || 1); + const w = Math.round(host.clientWidth * dpr); + const h = Math.round(host.clientHeight * dpr); + if (canvas.width !== w || canvas.height !== h) { + canvas.width = w; + canvas.height = h; + } + } + + function drawHeat() { + if (!heat?.length) return; + g.save(); + g.globalCompositeOperation = 'lighter'; + for (const p of heat) { + const s = project(p.lon, p.lat, 0); + if (!s) continue; + const r = (26 + 40 * Math.sqrt(p.weight ?? 1)) * dpr; + const grad = g.createRadialGradient( + s.x * dpr, + s.y * dpr, + 0, + s.x * dpr, + s.y * dpr, + r, + ); + grad.addColorStop(0, 'rgba(255,120,150,0.30)'); + grad.addColorStop(0.45, 'rgba(255,90,140,0.12)'); + grad.addColorStop(1, 'rgba(255,90,140,0)'); + g.fillStyle = grad; + g.fillRect(s.x * dpr - r, s.y * dpr - r, r * 2, r * 2); + } + g.restore(); + } + + function draw(now) { + resize(); + g.clearRect(0, 0, canvas.width, canvas.height); + drawHeat(); + for (let i = parts.length - 1; i >= 0; i--) { + const p = parts[i]; + const age = (now - p.born) / 1000; + if (age > LIFE_S) { + parts.splice(i, 1); + continue; + } + if (age < 0) continue; + const s = project(p.lon, p.lat, p.altM); + if (!s) continue; + const f = age / LIFE_S; + const rise = p.rise * (1 - (1 - f) ** 2.2); + const x = s.x + p.dx * f + Math.sin(age * p.wobble + p.phase) * 9; + const y = s.y - rise; + const size = p.size * (age < 0.18 ? age / 0.18 : 1) * (1 - 0.25 * f); + g.globalAlpha = f < 0.7 ? 1 : 1 - (f - 0.7) / 0.3; + g.drawImage( + sprite(p.kind), + (x - size / 2) * dpr, + (y - size / 2) * dpr, + size * dpr, + size * dpr, + ); + } + g.globalAlpha = 1; + } + + function loop(now) { + draw(now); + raf = parts.length ? requestAnimationFrame(loop) : 0; + if (!parts.length) onFrame?.(); + } + + return { + react({ lon, lat, kind = 'heart', count = 1, altM = 0 } = {}) { + if (!Number.isFinite(lon) || !Number.isFinite(lat)) return 0; + const k = KINDS[kind] ? kind : 'heart'; + const n = Math.max(1, Math.min(40, Math.round(count))); + const now = performance.now(); + for (let i = 0; i < n; i++) { + if (parts.length >= CAP) parts.shift(); + parts.push({ + lon, + lat, + altM, + kind: k, + born: now + i * (90 + Math.random() * 70), + rise: 120 + Math.random() * 110, + dx: (Math.random() - 0.5) * 70, + wobble: 2 + Math.random() * 3, + phase: Math.random() * 6.28, + size: 22 + Math.random() * 16, + }); + } + if (!raf) raf = requestAnimationFrame(loop); + return n; + }, + heat(points) { + heat = Array.isArray(points) + ? points.filter( + (p) => Number.isFinite(p?.lon) && Number.isFinite(p?.lat), + ) + : null; + if (!raf) { + resize(); + g.clearRect(0, 0, canvas.width, canvas.height); + drawHeat(); + } + }, + /** Redraw the heat after a globe render (camera moved). */ + afterRender() { + if (raf || !heat?.length) return; + resize(); + g.clearRect(0, 0, canvas.width, canvas.height); + drawHeat(); + }, + get count() { + return parts.length; + }, + destroy() { + cancelAnimationFrame(raf); + canvas.remove(); + }, + }; +} diff --git a/mobile/globe/recorder.js b/mobile/globe/recorder.js new file mode 100644 index 000000000..56c822c72 --- /dev/null +++ b/mobile/globe/recorder.js @@ -0,0 +1,548 @@ +/** + * The recorder (DESIGN.md §12.5, "it remembers"): every live contact's + * position on every poll, kept for about six hours. + * + * Memory layout: one growable Int32Array per entity, five ints per sample: + * t (epoch s) · lon×1e6 · lat×1e6 · alt (m) · heading×10 << 12 | speed (dm/s) + * That is 20 bytes a sample. Low traffic (helicopters, approaches, anything + * below ~6 km) keeps every poll (≥ 6 s apart); cruise traffic keeps one fix + * every 50 s, since straight lines interpolate. Samples older than 30 min + * are thinned (1/min low, 1/3 min cruise), and the whole buffer is capped at + * 1.2 M samples (~24 MB; oldest minutes are evicted first). + * + * Persistence: once a minute the new samples go to IndexedDB as one segment + * (at most one sample per entity per 30 s, per 2 min for cruise), with each + * entity's metadata. + * Segments older than the window are deleted. On start the recorder replays + * the stored segments, so a reload keeps its history. + */ +import { idbDeleteBelow, idbEntries, idbPut, idbPutMany } from './idb.js'; + +const STRIDE = 5; +const MIN_GAP_S = 6; +// Cruise traffic (above ~6 km) flies straight lines: one fix a minute +// interpolates to within metres of the truth, so it is recorded sparsely. +// Low traffic (helicopters, approaches, circling) keeps every poll. +const CRUISE_ALT_M = 6000; +const CRUISE_GAP_S = 50; +const FINE_WINDOW_S = 30 * 60; +const COARSE_GAP_S = 60; +const CRUISE_COARSE_GAP_S = 180; +const PERSIST_GAP_S = 30; +const CRUISE_PERSIST_GAP_S = 120; +const MAX_INTERP_GAP_S = 6 * 60; +const D2R = Math.PI / 180; + +function packHs(heading, speed) { + const h = Math.round(((((heading ?? 0) % 360) + 360) % 360) * 10) & 0xfff; + const s = Math.max(0, Math.min(4095, Math.round((speed ?? 0) * 10))); + return (h << 12) | s; +} +const unpackH = (v) => ((v >>> 12) & 0xfff) / 10; +const unpackS = (v) => (v & 0xfff) / 10; + +class Track { + constructor(key, meta) { + this.key = key; + this.meta = meta; + this.buf = new Int32Array(STRIDE * 16); + this.n = 0; + this.persistedT = 0; + } + get firstT() { + return this.n ? this.buf[0] : 0; + } + get lastT() { + return this.n ? this.buf[(this.n - 1) * STRIDE] : 0; + } + push(t, lon, lat, alt, hs) { + if (this.n && t <= this.lastT) { + // Out-of-order (a merged backfill): insert in place. + return this.insert(t, lon, lat, alt, hs); + } + if ((this.n + 1) * STRIDE > this.buf.length) { + const next = new Int32Array(this.buf.length * 2); + next.set(this.buf); + this.buf = next; + } + const o = this.n * STRIDE; + this.buf[o] = t; + this.buf[o + 1] = lon; + this.buf[o + 2] = lat; + this.buf[o + 3] = alt; + this.buf[o + 4] = hs; + this.n++; + return true; + } + insert(t, lon, lat, alt, hs) { + const i = this.lowerBound(t); + if (i < this.n && Math.abs(this.buf[i * STRIDE] - t) < 2) return false; + if (i > 0 && Math.abs(this.buf[(i - 1) * STRIDE] - t) < 2) return false; + if ((this.n + 1) * STRIDE > this.buf.length) { + const next = new Int32Array(this.buf.length * 2); + next.set(this.buf); + this.buf = next; + } + this.buf.copyWithin((i + 1) * STRIDE, i * STRIDE, this.n * STRIDE); + const o = i * STRIDE; + this.buf[o] = t; + this.buf[o + 1] = lon; + this.buf[o + 2] = lat; + this.buf[o + 3] = alt; + this.buf[o + 4] = hs; + this.n++; + return true; + } + /** First index with t >= value. */ + lowerBound(t) { + let lo = 0; + let hi = this.n; + while (lo < hi) { + const mid = (lo + hi) >> 1; + if (this.buf[mid * STRIDE] < t) lo = mid + 1; + else hi = mid; + } + return lo; + } + sample(i) { + const o = i * STRIDE; + const b = this.buf; + return { + t: b[o] * 1000, + lon: b[o + 1] / 1e6, + lat: b[o + 2] / 1e6, + altM: b[o + 3], + headingDeg: unpackH(b[o + 4]), + speed: unpackS(b[o + 4]), + }; + } + /** Remove samples before t; thin samples between t and fineFrom. */ + compact(dropBefore, fineFrom) { + const b = this.buf; + let w = 0; + let lastKept = -Infinity; + for (let i = 0; i < this.n; i++) { + const o = i * STRIDE; + const t = b[o]; + if (t < dropBefore) continue; + const isLast = i === this.n - 1; + const gap = b[o + 3] > CRUISE_ALT_M ? CRUISE_COARSE_GAP_S : COARSE_GAP_S; + if (t < fineFrom && !isLast && t - lastKept < gap) continue; + if (w !== i) b.copyWithin(w * STRIDE, o, o + STRIDE); + lastKept = t; + w++; + } + const removed = this.n - w; + this.n = w; + if (this.buf.length > 64 && this.n * STRIDE * 4 < this.buf.length) { + this.buf = this.buf.slice(0, Math.max(STRIDE * 16, this.n * STRIDE * 2)); + } + return removed; + } +} + +const lerp = (a, b, f) => a + (b - a) * f; +function lerpAngle(a, b, f) { + const d = ((b - a + 540) % 360) - 180; + return (a + d * f + 360) % 360; +} + +/** + * @param {{ windowMs?: number, maxSamples?: number, persist?: boolean }} [opts] + */ +export function createRecorder({ + windowMs = 6 * 3600_000, + maxSamples = 1_200_000, + persist = true, +} = {}) { + const tracks = new Map(); + let total = 0; + let pending = []; // [key, t, lon, lat, alt, hs] + let segSeq = 0; + const dirtyMeta = new Set(); + const listeners = new Set(); + const events = []; // { t, kind, key, title } (first squawk, first seen helicopters…) + let loaded = false; + let loading = null; + let minT = Infinity; + let maxT = -Infinity; + + function bounds() { + minT = Infinity; + maxT = -Infinity; + for (const tr of tracks.values()) { + if (!tr.n) continue; + if (tr.firstT < minT) minT = tr.firstT; + if (tr.lastT > maxT) maxT = tr.lastT; + } + } + + function append(key, meta, t, lon, lat, alt, hs, { fromStore = false } = {}) { + let tr = tracks.get(key); + if (!tr) { + tr = new Track(key, meta); + tracks.set(key, tr); + } else if (meta) { + const prev = tr.meta; + if ( + !prev || + prev.squawk !== meta.squawk || + prev.callsign !== meta.callsign || + (meta.registration && prev.registration !== meta.registration) + ) { + tr.meta = { ...prev, ...meta }; + if (!fromStore) dirtyMeta.add(key); + } + } + const cruise = alt > CRUISE_ALT_M; + if ( + tr.n && + t > tr.lastT && + t - tr.lastT < (cruise && !fromStore ? CRUISE_GAP_S : MIN_GAP_S) + ) + return false; + if (!tr.push(t, lon, lat, alt, hs)) return false; + total++; + if (t < minT) minT = t; + if (t > maxT) maxT = t; + if ( + !fromStore && + persist && + t - tr.persistedT >= (cruise ? CRUISE_PERSIST_GAP_S : PERSIST_GAP_S) + ) { + tr.persistedT = t; + pending.push([key, t, lon, lat, alt, hs]); + } + return true; + } + + /** + * Record a feed's records. `kind` names the source family: + * 'aircraft' (flights / regional), 'military', 'vessel'. + */ + function ingest(records, { kind = 'aircraft', at = Date.now() } = {}) { + if (!records?.length) return 0; + let n = 0; + const nowS = Math.floor(at / 1000); + for (const r of records) { + if (!Number.isFinite(r.lon) || !Number.isFinite(r.lat)) continue; + // The transponder's own last-contact time is the truth: a stale + // upstream repeats old positions with old times, never "now". + const seen = Number.isFinite(r.seenAt) + ? Math.floor(Math.min(r.seenAt, at + 5000) / 1000) + : nowS; + if (nowS - seen > 15 * 60) continue; + const key = kind === 'vessel' ? `v:${r.id}` : String(r.id); + const meta = + kind === 'vessel' + ? { kind: 'vessel', layer: 'vessels', title: r.name, type: r.type } + : { + kind: r.military + ? 'military' + : r.helicopter + ? 'helicopter' + : 'aircraft', + layer: r.military ? 'military' : 'flights', + callsign: r.callsign, + registration: r.registration || undefined, + type: r.type || undefined, + country: r.country || undefined, + squawk: r.squawk || undefined, + helicopter: Boolean(r.helicopter), + military: Boolean(r.military), + ga: Boolean(r.ga), + category: r.category ?? undefined, + onGround: Boolean(r.onGround), + ...(r.pia ? { pia: true } : {}), + ...(r.ladd ? { ladd: true } : {}), + }; + const before = tracks.get(key); + const hadEmergency = before?.meta?.emergency; + if (r.emergency) meta.emergency = true; + if ( + append( + key, + meta, + seen, + Math.round(r.lon * 1e6), + Math.round(r.lat * 1e6), + Math.round(r.altM ?? 0), + packHs(r.heading, r.speed), + ) + ) + n++; + if (r.emergency && !hadEmergency) + events.push({ + t: seen * 1000, + kind: 'squawk', + key, + title: `${r.callsign || r.id} squawking ${r.squawk}`, + lon: r.lon, + lat: r.lat, + }); + } + if (events.length > 400) events.splice(0, events.length - 400); + if (n) for (const fn of listeners) fn({ added: n, kind }); + return n; + } + + /** Merge an externally fetched track ([{t, lon, lat, altM, headingDeg?, speed?}]). */ + function merge(key, points, meta) { + let n = 0; + for (const p of points) { + if (!Number.isFinite(p.t) || !Number.isFinite(p.lon)) continue; + if ( + append( + key, + meta, + Math.floor(p.t / 1000), + Math.round(p.lon * 1e6), + Math.round(p.lat * 1e6), + Math.round(p.altM ?? 0), + packHs(p.headingDeg, p.speed), + { fromStore: true }, + ) + ) + n++; + } + return n; + } + + function compactAll() { + const nowS = Math.floor(Date.now() / 1000); + let dropBefore = nowS - Math.floor(windowMs / 1000); + const fineFrom = nowS - FINE_WINDOW_S; + let removed = 0; + for (const [key, tr] of tracks) { + removed += tr.compact(dropBefore, fineFrom); + if (!tr.n) tracks.delete(key); + } + total -= removed; + // Over budget: evict the oldest ten minutes at a time. + while (total > maxSamples && dropBefore < nowS - 600) { + dropBefore += 600; + for (const [key, tr] of tracks) { + total -= tr.compact(dropBefore, fineFrom); + if (!tr.n) tracks.delete(key); + } + } + bounds(); + } + + async function flush() { + if (!persist || !pending.length) return; + const rows = pending; + pending = []; + const keys = []; + const index = new Map(); + const data = new Int32Array(rows.length * 6); + rows.forEach(([key, t, lon, lat, alt, hs], i) => { + let k = index.get(key); + if (k == null) { + k = keys.length; + keys.push(key); + index.set(key, k); + } + data.set([k, t, lon, lat, alt, hs], i * 6); + }); + const segKey = rows[0][1] + (segSeq++ % 1000) / 1000; + await idbPut('seg', segKey, { keys, data: data.buffer }); + if (dirtyMeta.size) { + const metas = []; + for (const key of dirtyMeta) { + const tr = tracks.get(key); + if (tr?.meta) metas.push([key, tr.meta]); + } + dirtyMeta.clear(); + await idbPutMany('meta', metas); + } + idbDeleteBelow( + 'seg', + Math.floor((Date.now() - windowMs) / 1000) - 60, + ).catch(() => {}); + } + + async function load() { + if (loaded) return; + if (loading) return loading; + loading = (async () => { + if (!persist) return; + const since = Math.floor((Date.now() - windowMs) / 1000); + const [segs, metas] = await Promise.all([ + idbEntries('seg', since), + idbEntries('meta'), + ]); + const metaBy = new Map(metas); + for (const [, seg] of segs) { + if (!seg?.keys || !seg.data) continue; + const d = new Int32Array(seg.data); + for (let i = 0; i + 5 < d.length; i += 6) { + const key = seg.keys[d[i]]; + append( + key, + metaBy.get(key) || { kind: 'aircraft' }, + d[i + 1], + d[i + 2], + d[i + 3], + d[i + 4], + d[i + 5], + { fromStore: true }, + ); + } + } + // Stored history is coarse (30 s); new polls continue each track. + for (const tr of tracks.values()) tr.persistedT = tr.lastT; + })().finally(() => { + loaded = true; + }); + return loading; + } + + const flushTimer = setInterval(() => flush().catch(() => {}), 60_000); + const compactTimer = setInterval(compactAll, 5 * 60_000); + const onHide = () => { + if (document.visibilityState === 'hidden') flush().catch(() => {}); + }; + document.addEventListener('visibilitychange', onHide); + + /** Interpolated state of one track at `ms`, or null outside its record. */ + function stateAt(tr, ms, { holdMs = 45_000 } = {}) { + if (!tr?.n) return null; + const s = ms / 1000; + const first = tr.firstT; + const last = tr.lastT; + if (s < first - 5 || s > last + holdMs / 1000) return null; + const i = tr.lowerBound(s); + if (i >= tr.n) { + // Past the last fix: dead-reckon briefly along the last heading. + const p = tr.sample(tr.n - 1); + const dt = s - last; + if (p.speed > 1 && dt > 0) { + const h = p.headingDeg * D2R; + const d = p.speed * Math.min(dt, 45); + p.lat += (d * Math.cos(h)) / 111_320; + p.lon += (d * Math.sin(h)) / (111_320 * Math.cos(p.lat * D2R)); + } + p.t = ms; + return p; + } + if (i === 0) return { ...tr.sample(0), t: ms }; + const a = tr.sample(i - 1); + const b = tr.sample(i); + const gap = (b.t - a.t) / 1000; + if (gap > MAX_INTERP_GAP_S) return null; + const f = (ms - a.t) / (b.t - a.t || 1); + return { + t: ms, + lon: lerp(a.lon, b.lon, f), + lat: lerp(a.lat, b.lat, f), + altM: lerp(a.altM, b.altM, f), + headingDeg: lerpAngle(a.headingDeg, b.headingDeg, f), + speed: lerp(a.speed, b.speed, f), + }; + } + + return { + ingest, + merge, + load, + flush, + compact: compactAll, + events: () => events.slice(), + subscribe(fn) { + listeners.add(fn); + return () => listeners.delete(fn); + }, + /** { start, end, entities, points } in epoch ms; null start/end when empty. */ + range() { + if (!Number.isFinite(minT)) bounds(); + return { + start: Number.isFinite(minT) ? minT * 1000 : null, + end: Number.isFinite(maxT) ? maxT * 1000 : null, + entities: tracks.size, + points: total, + bytes: total * STRIDE * 4, + }; + }, + covers(ms, slackMs = 60_000) { + if (!Number.isFinite(minT)) return false; + return ms >= minT * 1000 - slackMs && ms <= maxT * 1000 + slackMs; + }, + has: (key) => tracks.has(String(key)), + meta: (key) => tracks.get(String(key))?.meta || null, + keys: () => tracks.keys(), + /** All samples of one entity: [{ t, lon, lat, altM, headingDeg, speed }]. */ + samples(key, fromMs = -Infinity, toMs = Infinity) { + const tr = tracks.get(String(key)); + if (!tr) return []; + const out = []; + const i0 = Number.isFinite(fromMs) ? tr.lowerBound(fromMs / 1000) : 0; + for (let i = i0; i < tr.n; i++) { + const p = tr.sample(i); + if (p.t > toMs) break; + out.push(p); + } + return out; + }, + stateAt(key, ms, opts) { + return stateAt(tracks.get(String(key)), ms, opts); + }, + /** + * Every entity with a state at `ms` (optionally inside `rect`): + * [{ key, meta, lon, lat, altM, headingDeg, speed }]. + */ + snapshotAt(ms, { rect = null, holdMs = 45_000 } = {}) { + const out = []; + for (const tr of tracks.values()) { + if (!tr.n) continue; + const s = ms / 1000; + if (s < tr.firstT - 5 || s > tr.lastT + holdMs / 1000) continue; + if (rect) { + // Cheap reject on the nearest raw fix before interpolating. + const i = Math.min(tr.n - 1, tr.lowerBound(s)); + const lat = tr.buf[i * STRIDE + 2] / 1e6; + const lon = tr.buf[i * STRIDE + 1] / 1e6; + if (lat < rect.south - 1 || lat > rect.north + 1) continue; + if ( + rect.west <= rect.east && + (lon < rect.west - 1.5 || lon > rect.east + 1.5) + ) + continue; + } + const p = stateAt(tr, ms, { holdMs }); + if (!p) continue; + if (rect && !inRectLL(rect, p.lon, p.lat)) continue; + out.push({ key: tr.key, meta: tr.meta, ...p }); + } + return out; + }, + /** Positions of one entity between two instants (for ghost trails). */ + trail(key, fromMs, toMs, maxPoints = 120) { + const tr = tracks.get(String(key)); + if (!tr?.n) return []; + const i0 = tr.lowerBound(fromMs / 1000); + const i1 = tr.lowerBound(toMs / 1000); + const step = Math.max(1, Math.ceil((i1 - i0) / maxPoints)); + const out = []; + for (let i = i0; i < i1; i += step) { + const p = tr.sample(i); + out.push([p.lon, p.lat, p.altM]); + } + const end = stateAt(tr, toMs); + if (end) out.push([end.lon, end.lat, end.altM]); + return out; + }, + destroy() { + clearInterval(flushTimer); + clearInterval(compactTimer); + document.removeEventListener('visibilitychange', onHide); + flush().catch(() => {}); + }, + }; +} + +function inRectLL(rect, lon, lat) { + if (lat < rect.south || lat > rect.north) return false; + if (rect.west <= rect.east) return lon >= rect.west && lon <= rect.east; + return lon >= rect.west || lon <= rect.east; +} diff --git a/mobile/globe/sky.js b/mobile/globe/sky.js new file mode 100644 index 000000000..c150afcb8 --- /dev/null +++ b/mobile/globe/sky.js @@ -0,0 +1,180 @@ +/** + * "Your sky now" (DESIGN.md §12.3): what is above a person this minute. + * Aircraft within ~50 km from the live ADS-B feeds (fetching a regional + * snapshot around the person when the current one does not cover them), + * satellites above the horizon from CelesTrak elements (SGP4), and the ISS + * with its next pass. + */ +import { twoline2satrec } from 'satellite.js'; +import { findNextIssPass, lookAnglesAt } from '../../src/data/issPass.js'; +import { haversineKm, subsolarPoint } from './geo.js'; +import { bearingDeg } from './gazetteer.js'; + +const R = 6_371_000; +const D2R = Math.PI / 180; +const ISS_NORAD = '25544'; + +function elevationDeg(distM, altM) { + // Flat-earth elevation corrected for the curvature drop over distM. + const drop = (distM * distM) / (2 * R); + return Math.atan2(altM - drop, distM) / D2R; +} + +function sunElevation(lat, lon, ms) { + const s = subsolarPoint(ms); + const cosZ = + Math.sin(lat * D2R) * Math.sin(s.lat * D2R) + + Math.cos(lat * D2R) * Math.cos(s.lat * D2R) * Math.cos((lon - s.lon) * D2R); + return 90 - Math.acos(Math.max(-1, Math.min(1, cosZ))) / D2R; +} + +const satCache = { stamp: '', sats: [] }; +function satrecs(feeds) { + const groups = ['stations', 'visual']; + const stamp = groups.map((g) => feeds[g].updatedAt).join(':'); + if (stamp === satCache.stamp) return satCache.sats; + const seen = new Set(); + const sats = []; + for (const g of groups) + for (const e of feeds[g].data?.entries || []) { + const id = e.line1.slice(2, 7).trim(); + if (seen.has(id)) continue; + seen.add(id); + try { + sats.push({ + id, + name: e.name.trim(), + satrec: twoline2satrec(e.line1, e.line2), + }); + } catch { + /* malformed */ + } + } + satCache.stamp = stamp; + satCache.sats = sats; + return sats; +} + +export async function skyNow(feeds, { lon, lat }, { km = 50 } = {}) { + if (!Number.isFinite(lon) || !Number.isFinite(lat)) + throw new TypeError('skyNow needs lon and lat'); + const now = Date.now(); + // Aircraft: whatever the feeds hold near the person, plus a regional + // snapshot around them when nothing current covers the spot. + const lists = []; + const flights = feeds.flights.data; + if (flights?.records) lists.push(flights.records); + if (feeds.military.data?.records) lists.push(feeds.military.data.records); + for (const e of feeds.regionalFlights.entries?.() || []) + if (e.data?.records) lists.push(e.data.records); + const covered = + flights && + (!flights.regional || + (flights.anchor && + haversineKm(lat, lon, flights.anchor.lat, flights.anchor.lon) < 300)); + if (!covered) { + const key = `sky:${lat.toFixed(1)}:${lon.toFixed(1)}`; + const reg = await Promise.race([ + feeds.regionalFlights.get(key, { lat, lon }).catch(() => null), + new Promise((r) => setTimeout(() => r(null), 9000)), + ]); + if (reg?.records) lists.push(reg.records); + } + const seen = new Set(); + const aircraft = []; + for (const list of lists) + for (const r of list) { + if (seen.has(r.id) || r.onGround) continue; + if (Math.abs(r.lat - lat) > km / 100 + 0.2) continue; + const d = haversineKm(lat, lon, r.lat, r.lon); + if (d > km) continue; + seen.add(r.id); + aircraft.push({ + id: `${r.military ? 'military' : 'flights'}:${r.id}`, + title: r.callsign || r.id.toUpperCase(), + kind: r.military + ? 'military' + : r.helicopter + ? 'helicopter' + : 'aircraft', + lon: r.lon, + lat: r.lat, + altM: Math.round(r.altM ?? 0), + distanceKm: Math.round(d * 10) / 10, + elevationDeg: Math.round(elevationDeg(d * 1000, r.altM ?? 0) * 10) / 10, + azimuthDeg: Math.round(bearingDeg(lat, lon, r.lat, r.lon)), + headingDeg: r.heading ?? null, + speedMps: r.speed ?? null, + squawk: r.squawk || null, + }); + } + aircraft.sort((a, b) => b.elevationDeg - a.elevationDeg); + + // Satellites above the horizon. + // Cached elements answer at once; a cold catalog gets 4 s. + await Promise.race([ + Promise.allSettled([feeds.stations.get(), feeds.visual.get()]), + new Promise((r) => setTimeout(r, 4000)), + ]); + const satellites = []; + let iss = null; + for (const s of satrecs(feeds)) { + const look = lookAnglesAt(s.satrec, now, lat, lon); + if (!look) continue; + if (s.id === ISS_NORAD) iss = { s, look }; + if (look.elevDeg <= 0) continue; + const p = look.satECI; + satellites.push({ + id: `satellites:${s.id}`, + title: s.name, + norad: s.id, + altKm: p ? Math.round(Math.hypot(p.x, p.y, p.z) - 6371) : null, + elevationDeg: Math.round(look.elevDeg * 10) / 10, + azimuthDeg: Math.round(look.azDeg), + }); + } + satellites.sort((a, b) => b.elevationDeg - a.elevationDeg); + + const sunEl = sunElevation(lat, lon, now); + let issOut = { + visibleNow: false, + elevationDeg: null, + azimuthDeg: null, + nextPass: null, + }; + if (iss) { + const pass = findNextIssPass({ + satrec: iss.s.satrec, + latDeg: lat, + lonDeg: lon, + fromMs: now, + minElevDeg: 10, + horizonHours: 36, + }); + issOut = { + visibleNow: iss.look.elevDeg > 10 && sunEl < -6, + aboveHorizon: iss.look.elevDeg > 0, + elevationDeg: Math.round(iss.look.elevDeg * 10) / 10, + azimuthDeg: Math.round(iss.look.azDeg), + nextPass: pass + ? { + start: pass.riseMs, + max: pass.maxElevMs, + end: pass.setMs, + maxElevationDeg: Math.round(pass.maxElevDeg), + riseAzimuthDeg: Math.round(pass.riseAzDeg ?? 0), + visible: Boolean(pass.visible), + } + : null, + }; + } + return { + at: now, + observer: { lon, lat }, + sunElevationDeg: Math.round(sunEl * 10) / 10, + aircraft: aircraft.slice(0, 60), + satellites: satellites.slice(0, 40), + iss: issOut, + sources: ['OpenSky Network / adsb.lol (ODbL)', 'CelesTrak GP data, SGP4'], + }; +} diff --git a/mobile/globe/stage.js b/mobile/globe/stage.js new file mode 100644 index 000000000..99a2b4092 --- /dev/null +++ b/mobile/globe/stage.js @@ -0,0 +1,951 @@ +/** + * The Moment stage (DESIGN.md §12.4): draws one Moment on the globe, keyed to + * the clock. + * + * tracks a glyph per aircraft at its interpolated position, a bright + * 90-second trail, the whole flown path faint behind it, and a + * hairline drop line to the ground + * captures a 3D view frustum per witness capture, from the phone to the + * subject, appearing (with a flash) when the clock passes it + * subject a highlighted building (real massing when the Moment bundles + * it), an antenna beacon, a pulsing ring at the subject height + * camera a cinematic path keyed to time (Catmull-Rom through the keys), + * released the moment the person touches the globe + * + * Everything is primitives, never Entities. Positions update in place each + * frame; the long "flown path" polylines rebuild at most 4×/s. + */ +import * as Cesium from 'cesium'; +import { glyph } from './glyphs.js'; + +const D2R = Math.PI / 180; +const TRAIL_MS = 90_000; +const SCRATCH = new Cesium.Cartesian3(); + +const css = (c, a = 1) => Cesium.Color.fromCssColorString(c).withAlpha(a); + +/** Index of the last point with t <= ms (binary search), -1 before the start. */ +function indexAt(points, ms) { + let lo = 0; + let hi = points.length - 1; + if (!points.length || ms < points[0].t) return -1; + if (ms >= points[hi].t) return hi; + while (lo < hi) { + const mid = (lo + hi + 1) >> 1; + if (points[mid].t <= ms) lo = mid; + else hi = mid - 1; + } + return lo; +} + +/** Interpolated { lon, lat, altM, heading, speed } on a track at ms, or null. */ +export function trackStateAt(points, ms, { holdMs = 30_000 } = {}) { + const i = indexAt(points, ms); + if (i < 0) return null; + const a = points[i]; + const b = points[i + 1]; + if (!b) { + if (ms - a.t > holdMs) return null; + const p = points[i - 1] || a; + return { ...a, heading: headingOf(p, a), speed: speedOf(p, a) }; + } + if (b.t - a.t > 6 * 60_000) return null; + const f = (ms - a.t) / (b.t - a.t || 1); + // Heading and speed over a ~6-second baseline smooth out ADS-B jitter + // (on sparse live data: just the two fixes either side). + let j = i; + let k = i + 1; + while (j > 0 && a.t - points[j - 1].t <= 3000) j--; + while (k < points.length - 1 && points[k + 1].t - b.t <= 3000) k++; + return { + t: ms, + lon: a.lon + (b.lon - a.lon) * f, + lat: a.lat + (b.lat - a.lat) * f, + altM: a.altM + (b.altM - a.altM) * f, + heading: headingOf(points[j], points[k]), + speed: speedOf(points[j], points[k]), + }; +} + +function headingOf(a, b) { + const dx = (b.lon - a.lon) * Math.cos(a.lat * D2R); + const dy = b.lat - a.lat; + if (!dx && !dy) return 0; + return (Math.atan2(dx, dy) / D2R + 360) % 360; +} +function speedOf(a, b) { + const dt = (b.t - a.t) / 1000; + if (dt <= 0) return 0; + const dx = (b.lon - a.lon) * 111_320 * Math.cos(a.lat * D2R); + const dy = (b.lat - a.lat) * 110_574; + return Math.hypot(dx, dy) / dt; +} + +/* ── Camera path ──────────────────────────────────────────────── */ + +function catmull(p0, p1, p2, p3, f) { + const f2 = f * f; + const f3 = f2 * f; + return ( + 0.5 * + (2 * p1 + + (-p0 + p2) * f + + (2 * p0 - 5 * p1 + 4 * p2 - p3) * f2 + + (-p0 + 3 * p1 - 3 * p2 + p3) * f3) + ); +} + +/** Camera { lon, lat, height, heading, pitch } on a keyed path at ms. */ +export function cameraAt(path, ms) { + if (!path?.length) return null; + if (ms <= path[0].t) return { ...path[0] }; + if (ms >= path.at(-1).t) return { ...path.at(-1) }; + let i = 0; + while (i < path.length - 2 && path[i + 1].t <= ms) i++; + const k0 = path[Math.max(0, i - 1)]; + const k1 = path[i]; + const k2 = path[i + 1]; + const k3 = path[Math.min(path.length - 1, i + 2)]; + const raw = (ms - k1.t) / (k2.t - k1.t || 1); + // Unwrap headings around k1 so a 350° → 10° key pans the short way. + const un = (h) => k1.heading + (((h - k1.heading + 540) % 360) - 180); + const h0 = un(k0.heading); + const h2 = un(k2.heading); + const h3 = h2 + (((k3.heading - k2.heading + 540) % 360) - 180); + return { + lon: catmull(k0.lon, k1.lon, k2.lon, k3.lon, raw), + lat: catmull(k0.lat, k1.lat, k2.lat, k3.lat, raw), + height: catmull(k0.height, k1.height, k2.height, k3.height, raw), + heading: (catmull(h0, k1.heading, h2, h3, raw) + 360) % 360, + pitch: catmull(k0.pitch, k1.pitch, k2.pitch, k3.pitch, raw), + }; +} + +/* ── Frustum geometry ─────────────────────────────────────────── */ + +/** World-space apex and four far corners of a capture's view cone. */ +function frustumCorners(c, groundH, lengthM) { + const origin = Cesium.Cartesian3.fromDegrees( + c.lon, + c.lat, + groundH + (c.altM || 1.5), + ); + const enu = Cesium.Transforms.eastNorthUpToFixedFrame(origin); + const h = (c.headingDeg || 0) * D2R; + const p = (c.pitchDeg || 0) * D2R; + const d = [Math.sin(h) * Math.cos(p), Math.cos(h) * Math.cos(p), Math.sin(p)]; + const r = [Math.cos(h), -Math.sin(h), 0]; + const u = [ + r[1] * d[2] - r[2] * d[1], + r[2] * d[0] - r[0] * d[2], + r[0] * d[1] - r[1] * d[0], + ]; + // Portrait phone frame: fovDeg across the short side, 4:3. + const th = Math.tan(((c.fovDeg || 60) * D2R) / 2); + const tv = th * (4 / 3); + const corners = [ + [-1, -1], + [1, -1], + [1, 1], + [-1, 1], + ].map(([sx, sy]) => { + const local = new Cesium.Cartesian3( + lengthM * (d[0] + th * sx * r[0] + tv * sy * u[0]), + lengthM * (d[1] + th * sx * r[1] + tv * sy * u[1]), + lengthM * (d[2] + th * sx * r[2] + tv * sy * u[2]), + ); + return Cesium.Matrix4.multiplyByPoint(enu, local, new Cesium.Cartesian3()); + }); + return { origin, corners }; +} + +function frustumGeometry(origin, corners) { + const pts = [origin, ...corners]; + const values = new Float64Array(pts.length * 3); + pts.forEach((q, i) => { + values[i * 3] = q.x; + values[i * 3 + 1] = q.y; + values[i * 3 + 2] = q.z; + }); + return new Cesium.Geometry({ + attributes: { + position: new Cesium.GeometryAttribute({ + componentDatatype: Cesium.ComponentDatatype.DOUBLE, + componentsPerAttribute: 3, + values, + }), + }, + // Four sides; the far face is left open so the subject shows through. + indices: new Uint16Array([0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1]), + primitiveType: Cesium.PrimitiveType.TRIANGLES, + boundingSphere: Cesium.BoundingSphere.fromPoints(pts), + }); +} + +/* ── The subject building: stepped Art Deco massing ───────────── */ + +// Tiers as (fraction of the lot's long side, of its short side, from, to) +// in metres above the street, after the Empire State Building's setbacks. +const SUBJECT_TIERS = [ + [1.0, 1.0, 0, 25], + [0.8, 0.86, 25, 80], + [0.66, 0.78, 80, 122], + [0.5, 0.7, 122, 286], + [0.36, 0.52, 286, 320], +]; +const SUBJECT_MAST = [ + [10, 320, 352], + [7, 352, 373], + [4.5, 373, 381], +]; + +function subjectMassing(row, olon, olat, kx, ky, base) { + const xs = []; + const ys = []; + for (let i = 2; i + 1 < row.length; i += 2) { + xs.push(row[i]); + ys.push(row[i + 1]); + } + const n = xs.length; + const cx = xs.reduce((a, b) => a + b, 0) / n; + const cy = ys.reduce((a, b) => a + b, 0) / n; + let sxx = 0; + let syy = 0; + let sxy = 0; + for (let i = 0; i < n; i++) { + sxx += (xs[i] - cx) ** 2; + syy += (ys[i] - cy) ** 2; + sxy += (xs[i] - cx) * (ys[i] - cy); + } + const th = 0.5 * Math.atan2(2 * sxy, sxx - syy); + const ux = Math.cos(th); + const uy = Math.sin(th); + let umax = 0; + let vmax = 0; + for (let i = 0; i < n; i++) { + const dx = xs[i] - cx; + const dy = ys[i] - cy; + umax = Math.max(umax, Math.abs(dx * ux + dy * uy)); + vmax = Math.max(vmax, Math.abs(-dx * uy + dy * ux)); + } + const toDeg = (x, y) => [olon + x / kx, olat + y / ky]; + const rect = (fu, fv) => { + const out = []; + for (const [a, b] of [ + [-1, -1], + [1, -1], + [1, 1], + [-1, 1], + ]) { + const u = a * umax * fu; + const v = b * vmax * fv; + out.push(...toDeg(cx + u * ux - v * uy, cy + u * uy + v * ux)); + } + return out; + }; + const octagon = (r) => { + const out = []; + for (let k = 0; k < 8; k++) { + const a = th + (k * Math.PI) / 4 + Math.PI / 8; + out.push(...toDeg(cx + r * Math.cos(a), cy + r * Math.sin(a))); + } + return out; + }; + const tiers = [ + ...SUBJECT_TIERS.map(([fu, fv, a, b]) => [rect(fu, fv), a, b]), + ...SUBJECT_MAST.map(([r, a, b]) => [octagon(r), a, b]), + ]; + return tiers.map(([ring, from, to], i) => { + // The podium stays a deep amber; the tower brightens toward the mast. + const k = i === 0 ? -0.35 : i / (tiers.length - 1); + return new Cesium.GeometryInstance({ + id: { layer: 'moment', key: 'subject' }, + geometry: new Cesium.PolygonGeometry({ + polygonHierarchy: new Cesium.PolygonHierarchy( + Cesium.Cartesian3.fromDegreesArray(ring), + ), + height: base + (from ? 3 + from : 0), + extrudedHeight: base + 3 + to, + vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT, + }), + attributes: { + color: Cesium.ColorGeometryInstanceAttribute.fromColor( + new Cesium.Color( + 0.86 + 0.14 * k, + 0.72 + 0.22 * k, + 0.46 + 0.36 * k, + 1, + ), + ), + }, + }); + }); +} + +/* ── Stage ────────────────────────────────────────────────────── */ + +const TRACK_COLORS = ['#5EC8FF', '#FFD166', '#FF9F6B', '#9BE15D', '#C9A7FF']; + +export function createStage({ scene, requestRender, emit }) { + const root = scene.primitives.add(new Cesium.PrimitiveCollection()); + root.show = false; + let massing = null; // Primitive (buildings) + let massingKey = ''; + const lines = root.add(new Cesium.PolylineCollection()); + const glyphs = root.add(new Cesium.BillboardCollection()); + let coneRoot = root.add(new Cesium.PrimitiveCollection()); + + let moment = null; + let groundH = 0; + let altOffset = 0; + let tracks = []; + let captures = []; + let subject = null; + let lastPathRebuild = 0; + let cinematic = true; + let cameraTarget = null; + let framing = 6; + let lastT = 0; + + const toCart = (lon, lat, altM, out) => + Cesium.Cartesian3.fromDegrees(lon, lat, altM + altOffset, undefined, out); + + function clear() { + lines.removeAll(); + glyphs.removeAll(); + root.remove(coneRoot); + coneRoot = root.add(new Cesium.PrimitiveCollection()); + tracks = []; + captures = []; + subject = null; + } + + async function sampleGround(lon, lat) { + try { + const provider = scene.globe.terrainProvider; + if (!provider || provider instanceof Cesium.EllipsoidTerrainProvider) + return 0; + const [c] = await Promise.race([ + Cesium.sampleTerrainMostDetailed(provider, [ + Cesium.Cartographic.fromDegrees(lon, lat), + ]), + new Promise((r) => setTimeout(() => r([null]), 2500)), + ]); + return Number.isFinite(c?.height) ? c.height : 0; + } catch { + return 0; + } + } + + /** Real building massing ({ origin, b:[[roofM, groundM, x0,y0,…]] }). */ + function buildMassing(data, highlightBin) { + if (massing) { + root.remove(massing); + massing = null; + } + if (!data?.b?.length) return; + const [olon, olat] = data.origin; + const kx = 111_320 * Math.cos(olat * D2R); + const ky = 110_574; + const subjectGround = 15; + const instances = []; + const sub = moment?.subject; + for (const row of data.b) { + const [roof, gnd] = row; + const ring = []; + for (let i = 2; i + 1 < row.length; i += 2) + ring.push(olon + row[i] / kx, olat + row[i + 1] / ky); + if (ring.length < 6) continue; + // Is this the subject building? (closest footprint to the subject) + const cx = row[2] / kx + olon; + const cy = row[3] / ky + olat; + const isSubject = + sub && + roof > 300 && + Math.abs(cx - sub.lon) < 0.0012 && + Math.abs(cy - sub.lat) < 0.0012; + const base = groundH + (gnd - subjectGround) - 3; + if (isSubject) { + instances.push(...subjectMassing(row, olon, olat, kx, ky, base)); + continue; + } + // Height-graded massing: low blocks dark, towers catch the light. + const k = Math.min(1, roof / 300); + // A little per-building variation so the massing reads as a city. + const j = + ((((row[2] * 73856093) ^ (row[3] * 19349663)) >>> 0) % 1000) / 1000; + // Focus: the blocks around the subject catch a little more light, + // the city falls off into the dark with distance. + const dist = Math.hypot( + row[2] - (sub ? (sub.lon - olon) * kx : 0), + row[3] - (sub ? (sub.lat - olat) * ky : 0), + ); + const v = (0.9 + 0.2 * j) * (1.18 - 0.5 * Math.min(1, dist / 2200)); + const color = isSubject + ? css('#FFE3A3', 1) + : new Cesium.Color( + (0.1 + 0.2 * k) * v, + (0.13 + 0.24 * k) * v, + (0.19 + 0.3 * k) * v, + 1, + ); + try { + instances.push( + new Cesium.GeometryInstance({ + id: isSubject ? { layer: 'moment', key: 'subject' } : undefined, + geometry: new Cesium.PolygonGeometry({ + polygonHierarchy: new Cesium.PolygonHierarchy( + Cesium.Cartesian3.fromDegreesArray(ring), + ), + height: base, + extrudedHeight: base + 3 + roof, + vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT, + }), + attributes: { + color: Cesium.ColorGeometryInstanceAttribute.fromColor(color), + }, + }), + ); + } catch { + /* a degenerate footprint */ + } + } + void highlightBin; + massing = root.add( + new Cesium.Primitive({ + geometryInstances: instances, + appearance: new Cesium.PerInstanceColorAppearance({ + flat: false, + translucent: false, + closed: true, + }), + asynchronous: true, + shadows: Cesium.ShadowMode.DISABLED, + }), + ); + massing.readyPromise?.then?.(requestRender); + } + + function addSubject(s) { + if (!s) return; + const roof = s.roofM ?? s.altM ?? 0; + const top = s.antennaM ?? roof; + const base = toCart(s.lon, s.lat, groundH - altOffset); + // Antenna / marker mast: a glowing hairline from roof to tip. + if (top > roof + 5) + lines.add({ + positions: [ + Cesium.Cartesian3.fromDegrees(s.lon, s.lat, groundH + roof), + Cesium.Cartesian3.fromDegrees(s.lon, s.lat, groundH + top), + ], + width: 3, + material: Cesium.Material.fromType('Color', { + color: css('#FFE3A3', 0.95), + }), + }); + // A tall light column so the subject reads from 4 km out. + const column = lines.add({ + positions: [ + Cesium.Cartesian3.fromDegrees(s.lon, s.lat, groundH + top), + Cesium.Cartesian3.fromDegrees(s.lon, s.lat, groundH + top + 900), + ], + width: 8, + material: Cesium.Material.fromType('PolylineGlow', { + color: css('#FFD166', 0.5), + glowPower: 0.12, + taperPower: 0.25, + }), + }); + void base; + const ring = glyph('ring'); + const halo = glyph('dot'); + const beacon = glyphs.add({ + position: Cesium.Cartesian3.fromDegrees(s.lon, s.lat, groundH + top), + image: halo.image, + imageId: halo.imageId, + color: css('#FF4D4D'), + scale: 0.9, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + const pulse = glyphs.add({ + position: Cesium.Cartesian3.fromDegrees( + s.lon, + s.lat, + groundH + (s.altM ?? roof), + ), + image: ring.image, + imageId: ring.imageId, + color: css('#FFD166', 0.9), + scale: 1.2, + id: { layer: 'moment', key: 'subject' }, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + subject = { ...s, beacon, pulse, column, base }; + } + + function addTracks(list) { + list.forEach((tr, i) => { + if (!tr.points?.length) return; + const color = tr.color || TRACK_COLORS[i % TRACK_COLORS.length]; + const g = glyph(tr.kind === 'helicopter' ? 'heli' : 'plane'); + const bb = glyphs.add({ + position: Cesium.Cartesian3.ZERO, + image: g.image, + imageId: g.imageId, + color: css(color), + scale: tr.kind === 'helicopter' ? 0.62 : 0.55, + alignedAxis: Cesium.Cartesian3.UNIT_Z, + show: false, + id: { layer: 'moment', key: `track:${tr.id}` }, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + const halo = glyph('dot'); + const glow = glyphs.add({ + position: Cesium.Cartesian3.ZERO, + image: halo.image, + imageId: halo.imageId, + color: css(color, 0.55), + scale: 1.1, + show: false, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + const cart = tr.points.map((p) => + toCart(p.lon, p.lat, p.altM ?? 0, new Cesium.Cartesian3()), + ); + const path = lines.add({ + positions: [], + width: 1.6, + material: Cesium.Material.fromType('Color', { + color: css(color, 0.32), + }), + }); + const trail = lines.add({ + positions: [], + width: 5, + material: Cesium.Material.fromType('PolylineGlow', { + color: css(color, 0.95), + glowPower: 0.22, + taperPower: 0.55, + }), + }); + const drop = lines.add({ + positions: [], + width: 1, + material: Cesium.Material.fromType('Color', { + color: css(color, 0.35), + }), + }); + tracks.push({ + tr, + color, + bb, + glow, + cart, + path, + trail, + drop, + state: null, + }); + }); + } + + function addCaptures(list) { + const target = moment?.subject; + for (const c of list || []) { + const lengthM = Math.max( + 120, + (c.rangeM ?? + (target + ? Cesium.Cartesian3.distance( + Cesium.Cartesian3.fromDegrees(c.lon, c.lat), + Cesium.Cartesian3.fromDegrees(target.lon, target.lat), + ) + : 300)) * 0.9, + ); + const { origin, corners } = frustumCorners(c, groundH, lengthM); + const color = c.firstEyes ? '#FFD166' : '#FFC857'; + const fill = coneRoot.add( + new Cesium.Primitive({ + geometryInstances: new Cesium.GeometryInstance({ + id: { layer: 'moment', key: `capture:${c.id}` }, + geometry: frustumGeometry(origin, corners), + attributes: { + color: Cesium.ColorGeometryInstanceAttribute.fromColor( + css(color, c.firstEyes ? 0.14 : 0.07), + ), + }, + }), + appearance: new Cesium.PerInstanceColorAppearance({ + flat: true, + translucent: true, + closed: false, + renderState: { cull: { enabled: false } }, + }), + asynchronous: false, + }), + ); + fill.show = false; + const edgeMat = Cesium.Material.fromType('Color', { + color: css(color, c.firstEyes ? 0.95 : 0.6), + }); + const edges = []; + for (let k = 0; k < 4; k++) + edges.push( + lines.add({ + positions: [origin, corners[k]], + width: c.firstEyes ? 1.8 : 1.1, + material: edgeMat, + show: false, + }), + ); + edges.push( + lines.add({ + positions: [...corners, corners[0]], + width: c.firstEyes ? 2 : 1.2, + material: edgeMat, + show: false, + }), + ); + const g = glyph('witness'); + const pin = glyphs.add({ + position: origin, + image: g.image, + imageId: g.imageId, + color: css(color), + scale: c.firstEyes ? 0.7 : 0.56, + show: false, + id: { layer: 'moment', key: `capture:${c.id}` }, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + const fl = glyph('dot'); + const flash = glyphs.add({ + position: origin, + image: fl.image, + imageId: fl.imageId, + color: css('#FFFFFF', 0), + scale: 0.1, + show: false, + disableDepthTestDistance: Number.POSITIVE_INFINITY, + }); + captures.push({ + c, + fill, + edges, + edgeMat, + pin, + flash, + origin, + shownAt: 0, + }); + } + } + + function setCamera(t) { + if (!cinematic || !moment) return; + const follow = + moment.follow && tracks.find((x) => x.tr.id === moment.follow.trackId); + if (follow?.state) { + // Chase view: behind and above the aircraft, looking along its track. + const s = follow.state; + const range = moment.follow.rangeM ?? 18_000; + const up = moment.follow.heightM ?? 6_000; + const back = (s.heading + 180 + (moment.follow.offsetDeg ?? 25)) % 360; + const kx = 111_320 * Math.cos(s.lat * D2R); + const lon = s.lon + (Math.sin(back * D2R) * range) / kx; + const lat = s.lat + (Math.cos(back * D2R) * range) / 110_574; + scene.camera.setView({ + destination: Cesium.Cartesian3.fromDegrees(lon, lat, s.altM + up), + orientation: { + heading: ((back + 180) % 360) * D2R, + pitch: Math.atan2(-up, range), + roll: 0, + }, + }); + return; + } + if (!moment.cameraPath?.length) return; + const k = cameraAt(moment.cameraPath, t); + if (!k) return; + // Keys are framed for a landscape-ish view; a portrait phone has a + // narrower horizontal field, so pull back along the line of sight. + const aspect = canvas.clientWidth / Math.max(1, canvas.clientHeight); + const fit = Math.max(1, Math.min(1.6, 0.75 / Math.max(0.2, aspect))); + const sub = moment.subject || { lon: moment.lon, lat: moment.lat }; + const kxm = 111_320 * Math.cos(sub.lat * D2R); + const dx = (k.lon - sub.lon) * kxm; + const dy = (k.lat - sub.lat) * 110_574; + const horiz = Math.hypot(dx, dy); + const lookAlt = k.height + Math.tan(k.pitch * D2R) * horiz; + const lon = sub.lon + (dx * fit) / kxm; + const lat = sub.lat + (dy * fit) / 110_574; + const height = lookAlt + (k.height - lookAlt) * fit; + if (subject?.column) { + const far = Math.hypot(horiz * fit, height); + subject.column.material.uniforms.color.alpha = Math.max( + 0, + Math.min(0.5, (far - 2500) / 4000), + ); + } + scene.camera.setView({ + destination: Cesium.Cartesian3.fromDegrees(lon, lat, groundH + height), + orientation: { + heading: k.heading * D2R, + // Look a little below the subject so it sits in the upper half, + // clear of the shell's bottom sheet. + pitch: (k.pitch - framing) * D2R, + roll: 0, + }, + }); + } + + /** Move everything to time `t` (epoch ms). Returns true when drawn. */ + function update(t, { realNow = performance.now() } = {}) { + if (!moment) return false; + const rebuildPath = realNow - lastPathRebuild > 250; + if (rebuildPath) lastPathRebuild = realNow; + for (const k of tracks) { + const s = trackStateAt(k.tr.points, t); + k.state = s; + if (!s) { + k.bb.show = k.glow.show = false; + k.trail.positions = []; + k.drop.positions = []; + if (rebuildPath) { + const i = indexAt(k.tr.points, t); + k.path.positions = i > 0 ? k.cart.slice(0, i + 1) : []; + } + continue; + } + const pos = toCart(s.lon, s.lat, s.altM, new Cesium.Cartesian3()); + k.bb.position = pos; + k.glow.position = pos; + k.bb.rotation = -s.heading * D2R; + k.bb.show = k.glow.show = true; + const i = indexAt(k.tr.points, t); + // Bright trail: the last 90 s, ending exactly at the glyph. + let j = indexAt(k.tr.points, t - TRAIL_MS); + if (j < 0) j = 0; + const step = Math.max(1, Math.floor((i - j) / 90)); + const trail = []; + for (let q = j; q <= i; q += step) trail.push(k.cart[q]); + trail.push(pos); + k.trail.positions = trail.length > 1 ? trail : []; + if (rebuildPath) { + const stride = Math.max(1, Math.floor(i / 600)); + const path = []; + for (let q = 0; q <= i; q += stride) path.push(k.cart[q]); + path.push(pos); + k.path.positions = path.length > 1 ? path : []; + } + k.drop.positions = [ + pos, + Cesium.Cartesian3.fromDegrees( + s.lon, + s.lat, + groundH, + undefined, + SCRATCH, + ).clone(), + ]; + } + for (const k of captures) { + const on = t >= k.c.t; + if (on && !k.shownAt) k.shownAt = realNow; + if (!on) k.shownAt = 0; + k.fill.show = on; + for (const e of k.edges) e.show = on; + k.pin.show = on; + const age = on ? (realNow - k.shownAt) / 1000 : 9; + k.flash.show = on && age < 0.9; + if (k.flash.show) { + const f = age / 0.9; + k.flash.scale = 0.4 + 3.2 * f; + k.flash.color = css('#FFFFFF', 0.9 * (1 - f)); + } + } + if (subject) { + const ph = (realNow / 1000) % 1.6; + subject.pulse.scale = 1.0 + 0.6 * (ph / 1.6); + subject.pulse.color = css('#FFD166', 0.95 * (1 - ph / 1.6)); + subject.beacon.color = css( + '#FF4D4D', + (realNow / 1000) % 1.2 < 0.25 ? 1 : 0.25, + ); + } + setCamera(t); + lastT = t; + requestRender(); + return true; + } + + // The person takes the camera: stop flying the path until asked again. + const canvas = scene.canvas; + const release = () => { + if (!moment || !cinematic) return; + cinematic = false; + emit?.('moment', { + type: 'camera', + item: { cinematic: false }, + t: lastT, + momentId: moment.id, + }); + }; + canvas.addEventListener('pointerdown', release, { passive: true }); + canvas.addEventListener('wheel', release, { passive: true }); + + return { + async load(m, { buildings = null } = {}) { + clear(); + moment = m; + cinematic = true; + const s = m.subject || { lon: m.lon, lat: m.lat, altM: 0 }; + groundH = await sampleGround(s.lon, s.lat); + // Tracks are MSL; draw them relative to the sampled ground. + altOffset = Number.isFinite(m.groundMslM) ? groundH - m.groundMslM : 0; + const key = m.stage?.buildings || ''; + if (buildings && key !== massingKey) { + massingKey = key; + buildMassing(buildings, m.stage?.highlight); + } else if (!buildings && massing) { + root.remove(massing); + massing = null; + massingKey = ''; + } + if (massing) massing.show = true; + addSubject(m.subject); + addTracks(m.tracks || []); + addCaptures(m.captures || []); + cameraTarget = s; + root.show = true; + update(m.time.start); + }, + unload() { + clear(); + moment = null; + root.show = false; + if (massing) massing.show = false; + requestRender(); + }, + update, + get active() { + return Boolean(moment); + }, + get cinematic() { + return cinematic; + }, + /** Degrees the cinematic camera looks below its subject (0 = centred). */ + setFraming(deg) { + if (Number.isFinite(deg)) framing = deg; + setCamera(lastT); + }, + setCinematic(on) { + cinematic = Boolean(on); + if (cinematic) setCamera(lastT); + }, + groundHeight: () => groundH, + target: () => cameraTarget, + /** Label candidates: [{ id, title, detail?, lon, lat, altM, kind, score }]. */ + labels() { + if (!moment) return []; + const out = []; + for (const k of tracks) { + if (!k.state) continue; + out.push({ + id: `moment:${moment.id}:${k.tr.id}`, + kind: 'track', + title: k.tr.label, + detail: `${Math.round((k.state.altM * 3.28084) / 25) * 25} FT · ${Math.round(k.state.speed / 0.514444)} KT`, + lon: k.state.lon, + lat: k.state.lat, + altM: k.state.altM + altOffset, + score: -80, + }); + } + for (const k of captures) + if (lastT >= k.c.t) + out.push({ + id: `capture:${moment.id}:${k.c.id}`, + kind: 'capture', + title: `@${k.c.handle}`, + detail: k.c.firstEyes ? 'FIRST EYES · SEALED' : 'SEALED', + lon: k.c.lon, + lat: k.c.lat, + altM: groundH + (k.c.altM || 1.5), + score: k.c.firstEyes ? -70 : -40, + }); + if (subject) + out.push({ + id: `moment:${moment.id}:subject`, + kind: 'subject', + title: subject.label || moment.place, + lon: subject.lon, + lat: subject.lat, + altM: groundH + (subject.antennaM ?? subject.altM ?? 0), + score: -90, + }); + return out; + }, + /** Pick payload for a stage id key. */ + pick(key) { + if (!moment) return null; + if (key === 'subject') + return { + kind: 'subject', + id: `moment:${moment.id}:subject`, + title: moment.subject?.label || moment.place, + subtitle: moment.title, + lon: moment.subject?.lon ?? moment.lon, + lat: moment.subject?.lat ?? moment.lat, + meta: { layer: 'moment', momentId: moment.id }, + }; + const [type, id] = key.split(':'); + if (type === 'track') { + const k = tracks.find((x) => x.tr.id === id); + if (!k) return null; + const s = k.state || k.tr.points.at(-1); + return { + kind: 'track', + id: `moment:${moment.id}:${id}`, + title: k.tr.label, + subtitle: [k.tr.type, k.tr.operator].filter(Boolean).join(' · '), + lon: s.lon, + lat: s.lat, + meta: { + layer: 'moment', + momentId: moment.id, + trackId: id, + illustrative: Boolean(moment.illustrative), + altitudeM: s.altM, + }, + }; + } + if (type === 'capture') { + const k = captures.find((x) => x.c.id === id); + if (!k) return null; + return { + kind: 'capture', + id: `capture:${moment.id}:${id}`, + title: k.c.title, + subtitle: `@${k.c.handle} · ${k.c.place || ''}${k.c.sealed ? ' · Sealed' : ''}`, + lon: k.c.lon, + lat: k.c.lat, + meta: { + layer: 'moment', + momentId: moment.id, + captureId: id, + headingDeg: k.c.headingDeg, + fovDeg: k.c.fovDeg, + firstEyes: Boolean(k.c.firstEyes), + illustrative: Boolean(moment.illustrative), + }, + }; + } + return null; + }, + destroy() { + canvas.removeEventListener('pointerdown', release); + canvas.removeEventListener('wheel', release); + scene.primitives.remove(root); + }, + }; +} diff --git a/mobile/index.html b/mobile/index.html index 8a2c5c6f0..7cd2dbedb 100644 --- a/mobile/index.html +++ b/mobile/index.html @@ -39,11 +39,16 @@ + + + + + -
+
@@ -53,22 +58,22 @@
+ +
diff --git a/mobile/main.js b/mobile/main.js index f0fbff14e..2ba712aa0 100644 --- a/mobile/main.js +++ b/mobile/main.js @@ -1,8 +1,10 @@ /** - * God's Eye — mobile shell. - * Boots the five tabs, mounts the one persistent globe (lazy), and wires - * the feed, the card → world transition, the globe chrome, Capture, - * Threads and You together. + * God's Eye — mobile shell (DESIGN.md §12). + * Tabs: Today · Live · Capture · Rooms · You. Mounts the one persistent globe + * (lazy), paints Today from the last good snapshot before the globe is up, + * and wires the time machine, Moments, dossiers, search, watch and the + * director together. Rooms, You and room chat come from the social agent's + * mount points (ui/social.js) when present. */ import { @@ -28,17 +30,26 @@ import { createRealtime } from './ui/realtime.js'; import { createRooms } from './ui/rooms.js'; import { createAttach } from './ui/attach.js'; import { createLiveViewer } from './ui/liveViewer.js'; -import { BAND_COLOR, bandOf } from './ui/bands.js'; +import { createToday } from './ui/today.js'; +import { createWatch } from './ui/watch.js'; +import { createSkySheet } from './ui/skySheet.js'; +import { createDossier } from './ui/dossier.js'; +import { createMomentPlayer } from './ui/moment.js'; +import { createDirector } from './ui/director.js'; +import { social, callSocial } from './ui/socialBridge.js'; +import { PLACES } from './ui/shim3.js'; +import { distKm, llShort, fmtKm } from './ui/bands.js'; const app = $('#app'); const stage = $('#stage'); const views = { - now: $('#view-now'), - globe: $('#view-globe'), - threads: $('#view-threads'), + today: $('#view-today'), + live: $('#view-live'), + rooms: $('#view-rooms'), you: $('#view-you'), capture: $('#view-capture'), }; +const paneSheets = $('#pane-sheets'); applyMotionPref(); const isTwoPane = () => @@ -71,27 +82,56 @@ async function getSituations({ fresh = false } = {}) { ...live, ...places.filter((p) => !live.some((s) => String(s.id) === p.id)), ]; + saveSnapshot(live); } return situationsCache; } const situationById = (id) => situationsCache?.find((s) => String(s.id) === String(id)) || null; +/* ---------------- Instant first frame ---------------- */ +const SNAP_KEY = 'gev.sitcache.v1'; +function readSnapshot() { + try { + const j = JSON.parse(localStorage.getItem(SNAP_KEY) || 'null'); + if (Array.isArray(j?.list) && j.list.length) + return j.list.map((s) => ({ ...s, cached: true, capturedAt: j.at })); + } catch { + /* ignore */ + } + return null; +} +function saveSnapshot(list) { + if (!list?.length || list[0]?.cached) return; + try { + const slim = list.slice(0, 40).map((s) => { + const { media, ...rest } = s; + return media ? { ...rest, media: { ...media } } : rest; + }); + localStorage.setItem( + SNAP_KEY, + JSON.stringify({ at: Date.now(), list: slim }), + ); + } catch { + /* quota: the engine's own cache still covers us */ + } +} + /* ---------------- Tabs ---------------- */ -let current = 'now'; +let current = 'today'; const tabbar = createTabBar($('#tabbar'), { onSelect: (tab, { reselect }) => { if (reselect) { const v = views[tab]; if (v?.scrollTop > 0) v.scrollTo({ top: 0, behavior: reducedMotion() ? 'auto' : 'smooth' }); - else if (tab === 'globe') globe?.home(); + else if (tab === 'live') globe?.home(); return; } selectTab(tab); }, onSearch: () => search?.open(), - onAccessory: (s) => openSituation(s), + onAccessory: (s) => (s.entityId ? openEntity(s.entityId) : openSituation(s)), }); let capture = null; @@ -103,15 +143,10 @@ let search = null; let inspector = null; let narrative = null; let liveViewer = null; - -/** After posting, offer the way into the room. */ -function toastOpen(s, p) { - setTimeout(() => { - if (current !== 'capture') return; - const s2 = situationById(s.id) || s; - openSituation(s2, null, { tab: 'room', focusPost: p.id }); - }, 900); -} +let dossier = null; +let player = null; +let sky = null; +let lastCam = null; function applyTab(tab) { const prev = current; @@ -120,7 +155,7 @@ function applyTab(tab) { const two = isTwoPane(); for (const [id, el] of Object.entries(views)) { if (id === 'capture') el.hidden = tab !== 'capture'; - else if (id === 'globe') el.hidden = !(two && tab === 'globe'); + else if (id === 'live') el.hidden = !(two && tab === 'live'); else el.hidden = id !== tab && !(two && tab === 'capture' && id === prev); } tabbar.select(tab); @@ -131,14 +166,15 @@ function applyTab(tab) { if (prev === 'capture') capture?.leave(); updateGlobeActivity(); } - if (tab === 'you') you?.render(); - if (tab === 'threads') threads?.refresh?.(); - if (tab === 'globe' && two) chrome?.renderLeadView(); - if (tab !== 'globe') chrome?.hidePick(); + if (tab === 'you') you?.render?.(); + if (tab === 'rooms') threads?.refresh?.(); + if (tab === 'live' && two) chrome?.renderLeadView(); + if (tab !== 'live') chrome?.hidePick(); } function selectTab(tab) { if (tab === current) return; + if (player?.current) player.close(); if (world?.current && !isTwoPane()) world.close(); if (narrative?.active) narrative.stop(); const vt = document.startViewTransition && !reducedMotion(); @@ -162,7 +198,10 @@ function updateGlobeActivity() { const visible = document.visibilityState === 'visible' && current !== 'capture' && - (isTwoPane() || current === 'globe' || app.classList.contains('is-world')); + (isTwoPane() || + current === 'live' || + app.classList.contains('is-world') || + app.classList.contains('is-moment')); if (visible) globe.resume(); else pauseTimer = setTimeout(() => globe.pause(), 700); } @@ -194,11 +233,12 @@ function locate({ quiet = false } = {}) { acc: p.coords.accuracy, }; userLoc = loc; + watch?.setHome(loc); resolve(loc); }, () => { if (!quiet) - toast('Location unavailable — distances are hidden', { + toast('Location unavailable — using the demo home', { icon: icon('location'), }); resolve(null); @@ -209,10 +249,13 @@ function locate({ quiet = false } = {}) { } let userLoc = null; -/* ---------------- Feed ---------------- */ -const feed = createFeed(views.now, { +/* ---------------- Today: brief + feed ---------------- */ +const feed = createFeed(views.today, { getSituations: () => getSituations({ fresh: true }), - onOpen: (s, card) => openSituation(s, card), + onOpen: (s, card) => + s.momentId && /circling/.test(s.kind || '') + ? openMoment(s.momentId) + : openSituation(s, card), onOpenRoom: (s, card) => openSituation(s, card, { tab: 'room' }), onWitness: (w, card) => openWitness(w, card), onCapture: () => selectTab('capture'), @@ -223,6 +266,69 @@ const feed = createFeed(views.now, { rt, }); +// Globe-dependent pieces are created once it is up; until then, stubs. +const lazy = { + entity: (ref) => globeReady.then((g) => g.entity(ref)), + skyNow: (o) => globeReady.then((g) => g.skyNow(o)), + detections: () => globe?.detections() || [], + on: (e, f) => globeReady.then((g) => g.on(e, f)), + raw: null, +}; +const watch = createWatch({ + host: paneSheets, + globe: new Proxy(lazy, { + get: (t, k) => (globe && k in globe ? globe[k] : t[k]), + }), + getSituations: () => getSituations(), + onOpenSituation: (s) => openSituation(situationById(s.id) || s), + onOpenEntity: (id) => openEntity(id), +}); +const today = createToday(feed.briefSlot, { + getSituations: () => getSituations(), + watch, + getHome: () => watch.home(), + onOpenSituation: (id) => openSituationById(id), + onOpenEntity: (id) => openEntity(id), + onOpenMoment: (id) => openMoment(id), + onSky: () => sky?.open(), + onWatch: () => watch.open(), +}); + +// Paint now from the last good snapshot; hydrate live below. +const snap = readSnapshot(); +let primed = false; +if (snap) primed = feed.prime(snap); +if (snap) today.setSituations(snap); +const fetchJson = (url) => + fetch(url) + .then((r) => + r.ok && /json/.test(r.headers.get('content-type') || '') + ? r.json() + : null, + ) + .catch(() => null); +// No snapshot on this device yet: the bundled one (real data, see capturedAt). +if (!snap) + fetchJson('/mobile/demo/snapshot.json').then((j) => { + const list = Array.isArray(j) ? j : j?.situations; + if (!list?.length || situationsCache) return; + const at = j?.capturedAt || null; + const norm = list.map((s) => ({ + ...s, + family: String(s.family || 'infra').toLowerCase(), + cached: true, + capturedAt: s.capturedAt || at, + })); + if (feed.prime(norm)) { + primed = true; + today.setSituations(norm); + } + }); +// Today's Moment paints from the bundle before the globe is up. +fetchJson('/mobile/demo/moments/empire-state.json').then( + (m) => m?.tracks && today.setMoment(m), +); + // Distances appear by themselves when location was already granted. navigator.permissions ?.query({ name: 'geolocation' }) @@ -232,12 +338,78 @@ navigator.permissions }) .catch(() => {}); +/* ---------------- Navigation helpers ---------------- */ function openSituation(s, card = null, opts = {}) { - if (!world) return; - if (current === 'capture') applyTab('now'); + if (!world || !s) return; + if (player?.current) player.close(); + if (current === 'capture') applyTab('today'); if (narrative?.active) narrative.stop(); world.open(s, card, opts); } +async function openSituationById(id, opts = {}) { + await getSituations(); + const s = situationById(id); + if (!s) return false; + if (s.momentId && /circling/.test(s.kind || '')) { + openMoment(s.momentId); + return true; + } + if (dossier?.isOpen && !opts.keepDossier) dossier.close(); + openSituation(s, feed.cardFor(s.id)); + return true; +} +async function openEntity(ref, o = {}) { + await globeReady; + if (/^situation:/.test(String(ref)) && !o.asDossier) { + const ok = await openSituationById(String(ref).slice(10)); + if (ok) return; + } + if (/^moment:[^:]+$/.test(String(ref)) && !o.asDossier) + return openMoment(String(ref).slice(7)); + dossier.open(ref, o); +} +async function openMoment(id, o = {}) { + await globeReady; + if (world?.current) await world.close(); + dossier?.close(); + sky?.close(); + if (!isTwoPane() && current !== 'live' && current !== 'today') + applyTab('today'); + return player.open(id, o); +} + +/** Rooms: the social agent's lanes when present, else the situation room. */ +async function openRoom(target, { lane = 'live' } = {}) { + const r = await callSocial('openRoom', target, { lane }); + if (r.ok) return true; + let s = null; + if (target?.time && target?.tracks) { + await getSituations(); + s = situationsCache.find((x) => x.momentId === target.id) || null; + player?.close(); + } else if (target?.kind === 'situation' || target?.situation) + s = + target.situation || + situationById(String(target.id).replace(/^situation:/, '')); + else if (target?.id && situationById(target.id)) s = situationById(target.id); + else if (target?.links) { + const l = target.links.find((x) => x.kind === 'situation'); + if (l) s = situationById(l.id.replace(/^situation:/, '')); + if (!s && target.links.some((x) => x.kind === 'moment')) { + await getSituations(); + s = situationsCache.find((x) => x.momentId) || null; + } + } + if (!s) { + toast('No room for this yet · start one from Capture', { + icon: icon('rooms'), + }); + return false; + } + dossier?.close(); + openSituation(s, null, { tab: 'room' }); + return true; +} async function openWitness(w, card) { if (w.liveNow) { @@ -254,15 +426,130 @@ async function openWitness(w, card) { }); } -function refreshAccessory() { +/** The tab-bar accessory: the first followed thing, with its status. */ +async function refreshAccessory() { const followed = store.get('followed') || []; - const s = followed.map((id) => situationById(id)).find(Boolean) || null; - tabbar.setAccessory(s); + for (const id of followed) { + const s = situationById(id); + if (s) return tabbar.setAccessory(s); + if (!globe) continue; + const st = await watch + .statusOf(id, situationsCache || []) + .catch(() => null); + if (st) + return tabbar.setAccessory({ + title: st.title, + status: st.status, + family: + st.band === 'orbit' ? 'orbit' : st.band === 'sky' ? 'sky' : 'ground', + icon: st.icon, + entityId: id, + metrics: [], + }); + } + tabbar.setAccessory(null); +} + +/** Everything follows the clock: globe, open sheet, room posts. */ +function onClock(d) { + world?.setClock?.(d); + window.dispatchEvent( + new CustomEvent('gev:clock', { detail: { t: d ? +d : null } }), + ); +} + +/** Range select → a Moment from the recorder, opened at once. */ +async function clipMoment({ start, end }) { + const g = await globeReady; + const c = lastCam || { lon: -73.98, lat: 40.75, height: 400e3 }; + const radius = Math.max(15, Math.min(600, (c.height || 400e3) / 1000 / 1.5)); + const near = g + .contactsNear(c.lon, c.lat, radius) + .filter((x) => /aircraft|helicopter|military|ship|vessel/.test(x.kind)) + .slice(0, 6); + const tracks = ( + await Promise.all( + near.map(async (x) => { + const pts = (await g.trackOf(x.id)).filter( + (p) => p.t >= start - 30e3 && p.t <= end + 30e3, + ); + if (pts.length < 2) return null; + return { + id: String(x.id), + kind: x.kind, + label: x.title || String(x.id), + operator: + { + aircraft: 'Aircraft · ADS-B', + helicopter: 'Helicopter · ADS-B', + military: 'Military · ADS-B', + ship: 'Vessel · AIS', + vessel: 'Vessel · AIS', + }[x.kind] || x.kind, + points: pts.map((p) => ({ + t: p.t, + lon: p.lon, + lat: p.lat, + altM: p.altM ?? x.altM ?? 0, + })), + }; + }), + ) + ).filter(Boolean); + const evts = g.timeline({ from: start, to: end }); + let place = PLACES.map((p) => ({ p, d: distKm(c, p) })).sort( + (a, b) => a.d - b.d, + )[0]; + const placeName = + place && place.d < radius ? place.p.name : llShort(c.lat, c.lon, 2); + const m = { + id: `clip-${Math.round(start / 1000).toString(36)}`, + title: `Clip · ${placeName}`, + place: placeName, + lon: c.lon, + lat: c.lat, + time: { start, end }, + illustrative: false, + simulated: !!g.isStub, + cameraPath: [ + { + t: start, + lon: c.lon, + lat: c.lat, + height: Math.min(c.height || 400e3, 900e3), + }, + ], + tracks, + captures: [], + chat: [], + posts: evts.map((e) => ({ + t: e.t, + handle: 'Record', + kind: 'context', + text: e.title, + votes: { corroborate: 0, dispute: 0 }, + })), + sources: [ + { + name: g.isStub + ? 'Simulated recorder (offline stub)' + : 'On-device recorder', + detail: `${tracks.length} tracks · ${evts.length} events · ${new Date(start).toISOString().slice(11, 16)}–${new Date(end).toISOString().slice(11, 16)}Z`, + }, + ], + }; + g.addClip(m); + toast(`Moment clipped · ${tracks.length} tracks, ${evts.length} events`, { + icon: icon('film'), + }); + return openMoment(m, { speed: 60 }); } /* ---------------- Boot dependent modules ---------------- */ +let director = null; globeReady .then(async (g) => { + g.on('camera', (c) => c && (lastCam = c)); world = createWorld({ app, stage, @@ -280,15 +567,52 @@ globeReady }); world.on('open', (s) => feed.select(s.id)); world.on('close', () => feed.select(null)); + dossier = createDossier({ + globe: g, + host: paneSheets, + onOpenSituation: (id) => openSituationById(id), + onOpenMoment: (id) => openMoment(id), + onOpenRoom: (d) => openRoom(d), + onShowOnTime: (d, t) => showOnTime(d, t), + watch, + }); + player = createMomentPlayer({ + app, + globe: g, + isTwoPane, + onExit: () => { + chrome?.ribbon.goLive(); + updateGlobeActivity(); + }, + onOpenEntity: (id) => dossier.open(id), + onOpenRoom: (m) => openRoom(m, { lane: 'live' }), + }); + sky = createSkySheet({ + host: paneSheets, + globe: g, + getHome: () => watch.home(), + onOpenEntity: (id) => dossier.open(id), + }); chrome = createGlobeChrome({ chrome: $('#globe-chrome'), stage, - leadView: views.globe, + leadView: views.live, globe: g, - onOpenSituation: (s) => openSituation(s), + onOpenSituation: (s) => + s.momentId && /circling/.test(s.kind || '') + ? openMoment(s.momentId) + : openSituation(s), onThread: (s) => openThreadFor(s), getSituations, isTwoPane, + onClock, + onClip: (r) => clipMoment(r), + onPick: (p) => { + // Tapping any thing on the globe opens its dossier. + if (!p || p.kind === 'situation' || p.kind === 'pin') return false; + dossier.open(p, { detent: 'medium' }); + return true; + }, onPin: (p) => { const m = /^post:(.+)$/.exec(p.id || ''); if (!m) return false; @@ -306,62 +630,106 @@ globeReady ribbon: chrome.ribbon, getSituation: situationById, }); - threads = createThreads(views.threads, { - bindScroll: (el) => tabbar.bindScroll(el), - rooms, - rt, - getSituations, - onOpenRoom: (s) => openSituation(s, null, { tab: 'room' }), - onPlay: (thread) => { - if (world.current) world.close(); - narrative.play(thread); - }, - onShowOnGlobe: async (thread, o) => { - const s = situationById(thread.id); - if (s) await world.open(s); - else { - app.classList.add('is-world'); - g.resume(); - } - world.sheet.setDetent?.('peek'); - g.flyTo({ - lon: o.lon, - lat: o.lat, - height: 7000, - pitch: -40, - duration: 2, - }); - }, - }); inspector = createInspector(); - you = createYou(views.you, { - bindScroll: (el) => tabbar.bindScroll(el), - getSituations, - onOpenSituation: (s) => openSituation(s), - onVerify: (b) => inspector.open(b), - onCredits: () => chrome.openCredits(), - rooms, - rt, - onOpenRoom: (s, postId) => - openSituation(s, null, { tab: 'room', focusPost: postId }), - onLocate: () => locate(), - }); search = createSearch({ + host: $('#sheets'), getSituations, globe: g, - onOpenSituation: (s) => openSituation(s), - onPlace: (p) => { - selectTab('globe'); - g.flyTo({ lon: p.lon, lat: p.lat, height: 40e3 }); - }, + onOpenSituation: (id) => openSituationById(id), + onOpenEntity: (id) => openEntity(id, { asDossier: true }), + onOpenMoment: (id) => openMoment(id), onLayer: (id) => { g.setLayer(id, true); chrome.refreshDock(); - selectTab('globe'); + selectTab('live'); toast('Lens on', { icon: icon('layers') }); }, }); liveViewer = createLiveViewer({ rt, globe: g }); + + // Rooms and You: the social agent's tabs when present. + const ctx = { + globe: g, + rooms, + rt, + getSituations, + bindScroll: (el) => tabbar.bindScroll(el), + openSituation: (s, o) => openSituation(s, null, o), + openMoment, + openEntity, + openRoom, + openWatch: () => watch.open(), + watch, + selectTab, + getLocation: () => userLoc || watch.home(), + getTime: () => chrome?.ribbon?.time || null, + onVerify: (b) => inspector.open(b), + }; + Object.assign(ctx, { + store, + onCapture: (s, o) => captureFor(s, o), + onOpenSituation: (s) => openSituation(s), + onPlayMoment: (m) => openMoment(m), + onShowGlobe: (s) => { + // The Live lane watches the place: hearts rise from it on the globe. + if (!isTwoPane() && current !== 'live') { + if (world?.current) world.close(); + applyTab('live'); + } + const subj = s.moment?.subject; + const c = subj + ? { lon: subj.lon, lat: subj.lat - 0.004, height: 4200 } + : s.camera || {}; + g.flyTo({ + lon: c.lon ?? s.lon, + lat: c.lat ?? s.lat, + height: Math.max(2500, Math.min(c.height || 3000, 6000)), + pitch: -40, + duration: 1.8, + }); + }, + onCredits: () => chrome.openCredits(), + onLocate: () => locate(), + watch: { summary: () => watch.summary(), open: () => watch.open() }, + sheetHost: paneSheets, + }); + const sm = await social(); + try { + sm?.configureSocial?.(ctx); + } catch (err) { + console.warn('[social] configureSocial failed', err); + } + if (typeof sm?.mountRoomsTab === 'function') { + try { + threads = (await sm.mountRoomsTab(views.rooms, ctx)) || null; + } catch (err) { + console.warn('[social] mountRoomsTab failed', err); + } + } + if (!threads) threads = mountThreadsFallback(g); + let youMounted = false; + if (typeof sm?.mountYouTab === 'function') { + try { + you = (await sm.mountYouTab(views.you, ctx)) || { render() {} }; + youMounted = true; + } catch (err) { + console.warn('[social] mountYouTab failed', err); + } + } + if (!youMounted) + you = createYou(views.you, { + bindScroll: (el) => tabbar.bindScroll(el), + getSituations, + onOpenSituation: (s) => openSituation(s), + onVerify: (b) => inspector.open(b), + onCredits: () => chrome.openCredits(), + rooms, + rt, + onOpenRoom: (s, postId) => + openSituation(s, null, { tab: 'room', focusPost: postId }), + onLocate: () => locate(), + }); + const attach = createAttach({ rooms, globe: g, @@ -371,8 +739,14 @@ globeReady await getSituations(); feed.refreshSocial(); threads?.refresh?.(); - if (current === 'you') you.render(); - toastOpen(s, p); + if (current === 'you') you.render?.(); + setTimeout(() => { + if (current !== 'capture') return; + openSituation(situationById(s.id) || s, null, { + tab: 'room', + focusPost: p.id, + }); + }, 900); }, }); const { createCapture } = await import('./ui/capture.js'); @@ -383,7 +757,7 @@ globeReady getLocation: () => userLoc, onSealed: () => { feed.refreshSocial(); - if (current === 'you') you.render(); + if (current === 'you') you.render?.(); }, onVerify: (b) => inspector.open(b), }); @@ -420,27 +794,53 @@ globeReady true, ); - await feed.load(); + // Instant first frame, second chance: the engine's cached snapshot. + if (!primed) { + const cached = await Promise.race([ + g.situationsCached(), + new Promise((r) => setTimeout(() => r([]), 400)), + ]); + if (cached.length && feed.prime(cached)) { + primed = true; + today.setSituations(cached); + } + } + today.setGlobe(g); + await feed.load({ quiet: primed }); const sits = await getSituations(); - chrome.setPips( - sits.flatMap((s) => - (s.events || []).map((ev) => ({ - at: +new Date(ev.at), - label: ev.label, - color: BAND_COLOR[bandOf(s)], - })), - ), - ); + if (primed) feed.markUpdated(); + today.setSituations(sits); + const refreshTimeline = () => + chrome.setTimeline( + g.timeline({ + from: Date.now() - 24 * 3600e3, + to: Date.now() + 72 * 3600e3, + }), + ); + refreshTimeline(); + setTimeout(refreshTimeline, 1500); + setInterval(refreshTimeline, 60e3); + seedFollows(g); refreshAccessory(); store.on((k) => k === 'followed' && refreshAccessory()); + setInterval(refreshAccessory, 20e3); + watch + .evaluate({ quiet: true }) + .then(() => setTimeout(() => watch.evaluate(), 4000)); applyTab(current); + director = buildDirector(g); + director.bindTripleTap(feed.titleEl); - // Deep link: #s= - const m = /#s=([^&]+)/.exec(location.hash); - if (m) { - const s = situationById(decodeURIComponent(m[1])); + // Deep links: #s=, #m=, #e= + const hs = /#s=([^&]+)/.exec(location.hash); + if (hs) { + const s = situationById(decodeURIComponent(hs[1])); if (s) openSituation(s, feed.cardFor(s.id)); } + const hm = /#m=([^&]+)/.exec(location.hash); + if (hm) openMoment(decodeURIComponent(hm[1])); + const he = /#e=([^&]+)/.exec(location.hash); + if (he) openEntity(decodeURIComponent(he[1]), { asDossier: true }); if (g.isStub) console.info( '[mobile] running on the offline stub engine', @@ -452,7 +852,64 @@ globeReady toast('The globe could not start on this device'); }); -/** Reply with evidence: open Capture with this situation pre-attached. */ +function mountThreadsFallback(g) { + const th = createThreads(views.rooms, { + bindScroll: (el) => tabbar.bindScroll(el), + rooms, + rt, + getSituations, + onOpenRoom: (s) => openSituation(s, null, { tab: 'room' }), + onPlay: (thread) => { + if (world.current) world.close(); + narrative.play(thread); + }, + onShowOnGlobe: async (thread, o) => { + const s = situationById(thread.id); + if (s) await world.open(s); + else { + app.classList.add('is-world'); + g.resume(); + } + world.sheet.setDetent?.('peek'); + g.flyTo({ + lon: o.lon, + lat: o.lat, + height: 7000, + pitch: -40, + duration: 2, + }); + }, + }); + return th; +} + +/** Follow the ISS on a first run, so Today's watch and the accessory have life. */ +async function seedFollows(g) { + try { + if (localStorage.getItem('gev.seeded3')) return; + localStorage.setItem('gev.seeded3', '1'); + } catch { + return; + } + const iss = (await g.search('ISS')).find((r) => r.kind === 'satellite'); + if (iss && !store.isFollowed(iss.id)) store.toggleFollow(iss.id); +} + +/** "Show on time machine" from a dossier. */ +async function showOnTime(d, t) { + if (/^(moment|capture):/.test(d.id) && player) { + const mid = d.id.split(':')[1]; + dossier.close(); + return openMoment(mid, { at: t ?? null, speed: 10 }); + } + const ts = t ?? d.track?.[0]?.t ?? d.events?.[0]?.t ?? Date.now() - 3600e3; + if (!isTwoPane()) { + dossier.sheet.setDetent('medium'); + selectTab('live'); + } + chrome.ribbon.jump(ts, { play: t == null, speed: 60 }); +} + async function captureFor(s, opts = {}) { if (world?.current && !isTwoPane()) await world.close(); selectTab('capture'); @@ -460,11 +917,14 @@ async function captureFor(s, opts = {}) { } async function openThreadFor(s) { - if (!threads) return; + if (!threads?.openById) { + openSituation(s, null, { tab: 'room' }); + return; + } if (world?.current) await world.close(); const id = s.thread || (s.kind === 'reconstruction' ? s.id : threads.startDraft(s)); - selectTab('threads'); + selectTab('rooms'); await threads.openById(id); if (!s.thread && s.kind !== 'reconstruction') toast('Draft thread started · observation recorded', { @@ -472,11 +932,232 @@ async function openThreadFor(s) { }); } -applyTab('now'); +/* ---------------- Director (demo mode) ---------------- */ +function closeAll() { + player?.close(); + dossier?.close(); + sky?.close(); + search?.close?.(); + if (world?.current) world.close(); + if (narrative?.active) narrative.stop(); + chrome?.ribbon.goLive(); + document + .querySelectorAll('.sheet-layer:not([hidden]) .sheet-close') + .forEach((b) => b.click()); +} +const settle = (ms = 450) => new Promise((r) => setTimeout(r, ms)); -// Keyboard: Escape closes the world. +function buildDirector(g) { + const hero = () => g.momentOfTheDay(); + return createDirector({ + onReset: async () => { + closeAll(); + try { + localStorage.setItem('gev.lastVisit', String(Date.now() - 8 * 3600e3)); + } catch { + /* ignore */ + } + watch.reset(); + applyTab('today'); + views.today.scrollTo({ top: 0 }); + g.home(); + today.refresh(); + }, + beats: [ + { + title: 'Today', + note: 'The daily brief: since you last looked, today’s Moment, your sky', + icon: 'today', + run: async () => { + closeAll(); + applyTab('today'); + views.today.scrollTo({ top: 0, behavior: 'smooth' }); + }, + }, + { + title: 'Your sky now', + note: 'Everything above you this minute', + icon: 'dome', + run: async () => { + closeAll(); + applyTab('today'); + await settle(200); + sky.open(); + }, + }, + { + title: 'The Empire State Moment', + note: 'Opens at the police helicopter’s arrival, playing at 10×', + icon: 'film', + run: async () => { + closeAll(); + const m = await hero(); + const arrive = m.tracks?.[0]?.arriveAt ?? m.time.start + 150e3; + await openMoment(m, { at: arrive - 20e3, speed: 10 }); + }, + }, + { + title: 'The Live lane, with hearts', + note: 'Watch party: chat, presence, hearts rising from the city', + icon: 'rooms', + run: async () => { + closeAll(); + const m = await hero(); + const ok = (await callSocial('openRoom', m, { lane: 'live' })).ok; + if (!ok) await openRoom(m, { lane: 'live' }); + for (let i = 0; i < 6; i += 1) + setTimeout( + () => + g.react({ + lon: m.lon + (Math.random() - 0.5) * 0.02, + lat: m.lat + (Math.random() - 0.5) * 0.02, + kind: ['heart', 'fire', 'heart', 'eyes', 'heart', 'wow'][i], + count: 3, + }), + 300 + i * 260, + ); + }, + }, + { + title: 'Need eyes', + note: 'A room asks for coverage nearby; first eyes earn the byline', + icon: 'eyes', + run: async () => { + closeAll(); + const home = watch.home(); + const sm = await social(); + const reqs = + sm?.needEyesNear?.({ lon: home.lon, lat: home.lat }, 50) || []; + const open = reqs.find((x) => x.status === 'open') || reqs[0]; + const core = sm?.socialCore?.(); + if (open && core?.needs?.openDetail) { + if (!isTwoPane()) selectTab('capture'); + await settle(300); + core.needs.openDetail(open.id); + } else { + selectTab('capture'); + toast('Need eyes · is the 7th St bridge underwater? 1.2 km away', { + icon: icon('eyes'), + }); + } + }, + }, + { + title: 'Capture', + note: 'Look · Witness · Live · Upload, sealed on the device', + icon: 'viewfinder', + run: async () => { + closeAll(); + selectTab('capture'); + }, + }, + { + title: 'Dossier of a live aircraft', + note: 'Identity, live state, track, links and receipts', + icon: 'sky', + run: async () => { + closeAll(); + const home = watch.home(); + const s = await g.skyNow({ lon: home.lon, lat: home.lat }); + const ac = + s?.aircraft?.find((a) => a.kind === 'aircraft') || s?.aircraft?.[0]; + if (!isTwoPane()) applyTab('live'); + if (ac) await dossier.open(ac.id, { detent: 'large' }); + else { + const r = + (await g.search('aircraft'))[0] || (await g.search('A'))[0]; + if (r) await dossier.open(r.id, { detent: 'large' }); + } + }, + }, + { + title: 'Link graph', + note: 'Everything that aircraft touches, synchronized with the globe', + icon: 'graph', + run: async () => { + closeAll(); + if (!isTwoPane()) applyTab('live'); + const m = await hero(); + const tr = + m.tracks?.find((x) => /police/i.test(`${x.role} ${x.operator}`)) || + m.tracks?.[0]; + await dossier.open(`moment:${m.id}:${tr.id}`, { graph: true }); + }, + }, + { + title: 'Time machine: −3 h at 60×', + note: 'The recorder replays where everything actually was', + icon: 'clock', + run: async () => { + closeAll(); + selectTab('live'); + g.flyTo({ lon: -62, lat: 38, height: 4200e3, duration: 1.4 }); + await settle(450); + chrome.ribbon.jump(Date.now() - 3 * 3600e3, { + play: true, + speed: 60, + }); + }, + }, + { + title: 'Clip this Moment', + note: 'Select a range on the time machine and clip it', + icon: 'scissors', + run: async () => { + closeAll(); + selectTab('live'); + await g.flyTo({ + lon: -73.95, + lat: 40.72, + height: 260e3, + duration: 1.2, + }); + await settle(350); + const t0 = Date.now() - 50 * 60e3; + chrome.ribbon.jump(t0 + 9 * 60e3); + chrome.ribbon.selectRange(t0, t0 + 18 * 60e3); + }, + }, + { + title: 'An alert, calmly', + note: 'An iOS-style banner from one of your alert rules', + icon: 'bell', + run: async () => { + closeAll(); + applyTab('today'); + const s = (await getSituations()).find((x) => + /squawk/.test(x.kind || ''), + ); + const home = watch.home(); + const d = s ? distKm(home, s) : NaN; + watch.banner({ + title: s?.title || 'Squawk 7700', + body: `${s?.place || 'Emergency squawk'}${Number.isFinite(d) ? ` · ${fmtKm(d)} from ${home.label || home.name}` : ''} · your rule: any emergency squawk`, + band: 'sky', + onTap: () => s && openSituation(s), + }); + }, + }, + { + title: 'Search to dossier', + note: '“7700”, “ISS”, “Piccadilly”', + icon: 'search', + run: async () => { + closeAll(); + search.open('7700'); + }, + }, + ], + }); +} + +// Keyboard: Escape closes the topmost thing. document.addEventListener('keydown', (e) => { - if (e.key === 'Escape' && world?.current) world.close(); + if (e.key !== 'Escape') return; + if (document.querySelector('.sheet-layer.is-modal:not([hidden])')) return; + if (dossier?.isOpen) return dossier.close(); + if (player?.current) return; + if (world?.current) world.close(); }); window.__gev = { @@ -496,7 +1177,28 @@ window.__gev = { get capture() { return capture; }, + get dossier() { + return dossier; + }, + get player() { + return player; + }, + get director() { + return director; + }, + get sky() { + return sky; + }, + get search() { + return search; + }, + watch, + today, + feed, selectTab, openSituation, + openMoment, + openEntity, + clipMoment, contractReport, }; diff --git a/mobile/styles/dossier.css b/mobile/styles/dossier.css new file mode 100644 index 000000000..71ef564ba --- /dev/null +++ b/mobile/styles/dossier.css @@ -0,0 +1,794 @@ +/* ------------------------------------------------------------------ */ +/* Dossiers, link graph and universal search (DESIGN.md §12.1) */ +/* ------------------------------------------------------------------ */ + +.dossier-sheet { + --band-c: var(--ink-2); +} + +.dossier-sheet[data-band='orbit'] { + --band-c: var(--b-orbit); +} +.dossier-sheet[data-band='sky'] { + --band-c: var(--b-sky); +} +.dossier-sheet[data-band='ground'] { + --band-c: var(--b-ground); +} +.dossier-sheet[data-band='inside'] { + --band-c: var(--b-inside); +} + +.dossier-sheet::before { + content: ''; + position: absolute; + inset: 0 0 auto; + height: 120px; + background: radial-gradient( + 80% 100% at 20% 0, + color-mix(in srgb, var(--band-c) 16%, transparent), + transparent 70% + ); + pointer-events: none; +} + +.ds-head { + position: relative; + padding-bottom: 10px; +} + +.ds-back { + position: absolute; + left: -10px; + top: -6px; + width: 34px; + height: 34px; + color: var(--tint); + font-size: 1.05rem; +} + +.ds-back + .ds-kicker { + padding-left: 26px; +} + +.ds-kicker { + display: flex; + align-items: center; + flex-wrap: wrap; + gap: 6px; + color: var(--ink-3); + font-size: 0.5625rem; + min-height: 18px; + padding-right: 40px; +} + +.ds-kicker .bd { + width: 7px; + height: 7px; + border-radius: 2px; + background: var(--band-c); + box-shadow: 0 0 8px var(--band-c); +} + +.ds-kicker .live-tag { + display: inline-flex; + align-items: center; + gap: 4px; + color: #ff6b61; +} + +.ds-title-row { + display: flex; + align-items: center; + gap: 12px; + margin: 6px 0 10px; +} + +.ds-ic { + flex: none; + width: 44px; + height: 44px; + border-radius: 13px; + display: grid; + place-items: center; + font-size: 1.35rem; + color: var(--band-c); + background: color-mix(in srgb, var(--band-c) 15%, rgba(255, 255, 255, 0.03)); + box-shadow: inset 0 0 0 0.5px + color-mix(in srgb, var(--band-c) 40%, transparent); +} + +.ds-title-row .sheet-title { + font-family: var(--font-display); + margin: 0; + overflow-wrap: anywhere; +} + +.ds-skel { + width: 60%; + border-radius: 8px; + background: rgba(255, 255, 255, 0.08); +} + +.ds-seg { + display: flex; +} + +.ds-seg button { + flex: 1; + display: inline-flex; + align-items: center; + justify-content: center; + gap: 6px; +} + +.ds-seg .i { + font-size: 0.95rem; +} + +.ds-live { + display: grid; + grid-template-columns: repeat(auto-fit, minmax(84px, 1fr)); + gap: 8px; + padding-top: 4px; +} + +.ds-live div { + display: flex; + flex-direction: column; + gap: 3px; + padding: 10px 12px; + border-radius: 14px; + background: rgba(255, 255, 255, 0.05); +} + +.ds-live .tele { + color: var(--ink-3); + font-size: 0.5625rem; +} + +.ds-live b { + font-family: var(--font-display); + font-size: 1.3125rem; + font-weight: 700; + letter-spacing: -0.02em; + white-space: nowrap; +} + +.ds-live small { + margin-left: 3px; + color: var(--ink-3); + font-size: 0.6875rem; + font-weight: 600; +} + +.ds-updated { + display: flex; + align-items: center; + gap: 6px; + padding: 8px 2px 0; + color: var(--ink-3); + font-size: 0.5625rem; +} + +.ds-actions { + display: flex; + gap: 8px; + padding: 14px 0 4px; + overflow-x: auto; + scrollbar-width: none; +} + +.ds-act { + flex: 1 0 auto; + min-width: 70px; + display: flex; + flex-direction: column; + align-items: center; + gap: 5px; + padding: 10px 8px; + border-radius: 14px; + color: var(--tint); + background: rgba(163, 216, 255, 0.1); + font-size: var(--t-cap2); + font-weight: 600; + transition: + background var(--dur-1) linear, + transform var(--dur-1) var(--ease-out); +} + +.ds-act .i { + font-size: 1.25rem; +} + +.ds-act:hover { + background: rgba(163, 216, 255, 0.16); +} + +.ds-act:active { + transform: scale(0.96); +} + +.ds-act[aria-pressed='true'] { + color: #2a1a00; + background: var(--b-inside); +} + +.ds-act.primary { + color: #050607; + background: #fff; +} + +.ds-privacy { + display: flex; + gap: 10px; + margin-top: 12px; + padding: 10px 12px; + border-radius: 12px; + background: rgba(255, 255, 255, 0.04); + color: var(--ink-2); + font-size: var(--t-cap); +} + +.ds-block { + margin-top: 18px; +} + +.ds-h { + display: flex; + align-items: baseline; + gap: 8px; + margin: 0 0 8px; + font-size: var(--t-sub); + font-weight: 700; + letter-spacing: -0.01em; +} + +.ds-h .i { + align-self: center; + color: var(--ink-3); +} + +.ds-h small { + margin-left: auto; + color: var(--ink-3); + font-weight: 500; + font-size: var(--t-cap2); + text-align: right; +} + +.ds-track { + display: grid; + grid-template-columns: 1fr 96px; + gap: 8px; +} + +.ds-fig { + margin: 0; + padding: 10px 10px 6px; + border-radius: 14px; + background: rgba(255, 255, 255, 0.04); +} + +.ds-fig svg { + display: block; + width: 100%; + height: 70px; +} + +.ds-ground svg { + height: 70px; +} + +.ds-fig figcaption { + display: flex; + justify-content: space-between; + margin-top: 4px; + color: var(--ink-3); + font-size: 0.5rem; +} + +.ds-area { + fill: color-mix(in srgb, var(--band-c) 22%, transparent); +} + +.ds-line, +.ds-gline { + fill: none; + stroke: var(--band-c); + stroke-width: 1.6; + vector-effect: non-scaling-stroke; + stroke-linejoin: round; +} + +.ds-end { + fill: #fff; +} + +.ds-alt { + width: 100%; + height: 64px; + display: block; +} + +.ds-id { + display: grid; + grid-template-columns: auto 1fr; + gap: 7px 16px; + margin: 0; + padding: 12px 14px; + border-radius: 14px; + background: rgba(255, 255, 255, 0.04); + font-size: var(--t-foot); +} + +.ds-id dt { + color: var(--ink-3); +} + +.ds-id dd { + margin: 0; + text-align: right; + overflow-wrap: anywhere; +} + +.ds-events { + list-style: none; + margin: 0; + padding: 0 0 0 4px; + border-left: 1px solid var(--hairline-strong); +} + +.ds-events button { + position: relative; + display: grid; + grid-template-columns: 52px 1fr auto; + align-items: baseline; + gap: 8px; + width: 100%; + padding: 8px 6px 8px 14px; + text-align: left; + color: var(--ink); + font-size: var(--t-foot); + border-radius: 10px; +} + +.ds-events button:hover { + background: rgba(255, 255, 255, 0.04); +} + +.ds-events button::before { + content: ''; + position: absolute; + left: -8.5px; + top: 13px; + width: 8px; + height: 8px; + border-radius: 50%; + background: var(--band-c); + box-shadow: 0 0 0 3px var(--ground-1); +} + +.ds-events .tele { + color: var(--ink-3); + font-size: 0.625rem; +} + +.ds-events small { + color: var(--ink-4); + font-size: var(--t-cap2); +} + +.ds-links { + display: grid; + border-radius: 14px; + overflow: hidden; + background: rgba(255, 255, 255, 0.04); +} + +.ds-link { + position: relative; + display: flex; + align-items: center; + gap: 11px; + padding: 9px 12px; + text-align: left; + color: var(--ink); + --lc: var(--ink-2); +} + +.ds-link + .ds-link::before { + content: ''; + position: absolute; + top: 0; + left: 52px; + right: 0; + height: 0.5px; + background: var(--hairline); +} + +.ds-link:hover { + background: rgba(255, 255, 255, 0.04); +} + +.ds-link[data-band='orbit'] { + --lc: var(--b-orbit); +} +.ds-link[data-band='sky'] { + --lc: var(--b-sky); +} +.ds-link[data-band='ground'] { + --lc: var(--b-ground); +} +.ds-link[data-band='inside'] { + --lc: var(--b-inside); +} + +.ds-link-ic { + flex: none; + width: 30px; + height: 30px; + border-radius: 9px; + display: grid; + place-items: center; + color: var(--lc); + background: color-mix(in srgb, var(--lc) 14%, transparent); +} + +.ds-link-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 1px; +} + +.ds-link-main b { + font-size: var(--t-foot); + font-weight: 600; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.ds-link-main small { + color: var(--ink-3); + font-size: var(--t-cap2); +} + +.ds-link .chev { + color: var(--ink-4); +} + +.ds-receipts { + display: grid; + gap: 6px; +} + +.ds-rc { + display: flex; + align-items: center; + justify-content: space-between; + gap: 10px; + padding: 10px 12px; + border-radius: 12px; + background: rgba(255, 255, 255, 0.04); +} + +.ds-rc div { + display: flex; + flex-direction: column; + gap: 2px; + min-width: 0; +} + +.ds-rc b { + font-size: var(--t-foot); + font-weight: 600; +} + +.ds-rc small { + color: var(--ink-3); + font-size: var(--t-cap2); +} + +.ds-rc a { + color: var(--tint); +} + +.ds-hash { + flex: none; + padding: 6px 8px; + border-radius: 8px; + color: var(--b-inside); + background: rgba(235, 199, 119, 0.1); + font-size: 0.625rem; +} + +.ds-hash:hover { + background: rgba(235, 199, 119, 0.18); +} + +.ds-foot { + display: flex; + gap: 8px; + align-items: flex-start; + margin: 18px 0 0; + color: var(--ink-3); + font-size: var(--t-cap); + line-height: 1.4; +} + +.ds-foot .i { + flex: none; + margin-top: 1px; +} + +/* Link graph */ +.dossier-sheet[data-seg='graph'] .sheet-body { + display: flex; + flex-direction: column; + padding-bottom: calc(var(--safe-b) + 12px); +} + +.ds-graph { + flex: 1; + min-height: 320px; + position: relative; + border-radius: 18px; + background: + radial-gradient( + 70% 60% at 50% 50%, + rgba(163, 216, 255, 0.06), + transparent 70% + ), + rgba(255, 255, 255, 0.025); + box-shadow: inset 0 0 0 0.5px var(--hairline); + overflow: hidden; +} + +.lg { + position: absolute; + inset: 0; +} + +.lg-canvas { + position: absolute; + inset: 0; + width: 100%; + height: 100%; + touch-action: none; +} + +.lg-tip { + position: absolute; + left: 0; + top: 0; + padding: 4px 8px; + border-radius: 6px; + background: rgba(8, 10, 14, 0.92); + box-shadow: inset 0 0 0 0.5px var(--hairline-strong); + color: var(--ink); + font-size: 0.5625rem; + white-space: nowrap; + pointer-events: none; +} + +.lg-legend { + position: absolute; + left: 12px; + bottom: 10px; + display: flex; + gap: 10px; + color: var(--ink-3); + font-size: 0.5rem; + pointer-events: none; +} + +.lg-legend span { + display: inline-flex; + align-items: center; + gap: 4px; +} + +.lg-legend i { + width: 7px; + height: 7px; + border-radius: 50%; +} + +.lg-legend [data-band='orbit'] i { + background: var(--b-orbit); +} +.lg-legend [data-band='sky'] i { + background: var(--b-sky); +} +.lg-legend [data-band='ground'] i { + background: var(--b-ground); +} +.lg-legend [data-band='inside'] i { + background: var(--b-inside); +} + +.ds-graph-note { + flex: none; + margin: 8px 0 0; + color: var(--ink-3); + font-size: 0.5625rem; + text-align: center; +} + +/* ---------- Universal search ---------- */ +.search-sheet .sheet-head { + padding-top: 4px; +} + +.results-h { + display: flex; + align-items: baseline; + gap: 8px; + margin: 16px 2px 6px; + color: var(--ink-3); + font-size: var(--t-cap); + font-weight: 650; + text-transform: uppercase; + letter-spacing: 0.06em; +} + +.results-h small { + font-family: var(--mono); + font-weight: 500; +} + +.results-h .link-btn { + margin-left: auto; + color: var(--tint); + text-transform: none; + letter-spacing: 0; +} + +.sr-chips { + display: flex; + flex-wrap: wrap; + gap: 8px; +} + +.sr-chips .chip { + height: 34px; + padding: 0 13px; + font-size: var(--t-foot); + color: var(--ink); + background: rgba(255, 255, 255, 0.07); +} + +.sr-chips .chip:hover { + background: rgba(255, 255, 255, 0.12); +} + +.sr-chips .chip .i { + color: var(--ink-3); +} + +.sr-list { + display: grid; + border-radius: 16px; + overflow: hidden; + background: rgba(255, 255, 255, 0.04); +} + +.sr { + position: relative; + display: flex; + align-items: center; + gap: 12px; + padding: 10px 12px; + text-align: left; + color: var(--ink); + --sc: var(--ink-2); +} + +.sr + .sr::before { + content: ''; + position: absolute; + top: 0; + left: 56px; + right: 0; + height: 0.5px; + background: var(--hairline); +} + +.sr:hover, +.sr[aria-selected='true'] { + background: rgba(255, 255, 255, 0.06); +} + +.sr[data-band='orbit'] { + --sc: var(--b-orbit); +} +.sr[data-band='sky'] { + --sc: var(--b-sky); +} +.sr[data-band='ground'] { + --sc: var(--b-ground); +} +.sr[data-band='inside'] { + --sc: var(--b-inside); +} + +.sr-ic { + flex: none; + width: 34px; + height: 34px; + border-radius: 10px; + display: grid; + place-items: center; + font-size: 1.05rem; + color: var(--sc); + background: color-mix(in srgb, var(--sc) 14%, transparent); +} + +.sr-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 1px; +} + +.sr-main b { + font-size: var(--t-sub); + font-weight: 600; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.sr-main small { + color: var(--ink-3); + font-size: var(--t-cap); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.sr-tag { + flex: none; + color: var(--ink-4); + font-size: 0.5rem; + text-transform: uppercase; +} + +.sr-empty { + display: flex; + flex-direction: column; + gap: 4px; + padding: 40px 10px; + text-align: center; + color: var(--ink-3); +} + +.sr-empty b { + color: var(--ink); +} + +.sr-note { + display: flex; + gap: 8px; + align-items: flex-start; + margin: 18px 4px 0; + color: var(--ink-3); + font-size: var(--t-cap); + line-height: 1.4; +} + +.sr-note .i { + flex: none; + margin-top: 1px; +} + +/* Grid rows never grow wider than their list. */ +.sr-list, +.ds-links, +.ds-receipts { + grid-template-columns: minmax(0, 1fr); +} diff --git a/mobile/styles/feed.css b/mobile/styles/feed.css index a6c75a1fa..1adbe0990 100644 --- a/mobile/styles/feed.css +++ b/mobile/styles/feed.css @@ -2,7 +2,7 @@ /* Now feed: header, altitude filter, masonry + wide rows */ /* ------------------------------------------------------------------ */ -#view-now { +#view-today { background: var(--ground); } @@ -39,13 +39,13 @@ letter-spacing: 0.04em; } -#view-now .title-sub { +#view-today .title-sub { gap: 7px; color: var(--ink-3); font-size: 0.625rem; } -#view-now .title-sub .live-dot { +#view-today .title-sub .live-dot { --fam: var(--ink); width: 5px; height: 5px; @@ -83,11 +83,11 @@ transition: opacity var(--dur-1) linear; } -#view-now.is-scrolled .bandbar::before { +#view-today.is-scrolled .bandbar::before { opacity: 1; } -#view-now.is-scrolled .navbar::before { +#view-today.is-scrolled .navbar::before { border-bottom-color: transparent; } @@ -328,6 +328,6 @@ } /* The Near lens: the feed becomes a distance-ordered list around you. */ -#view-now.is-near .feed-count::after { +#view-today.is-near .feed-count::after { content: ' · nearest first'; } diff --git a/mobile/styles/layout.css b/mobile/styles/layout.css index b4a1d19cc..fd69ac28c 100644 --- a/mobile/styles/layout.css +++ b/mobile/styles/layout.css @@ -51,7 +51,7 @@ left: var(--stage-left); } - #view-globe { + #view-live { display: block; } @@ -115,6 +115,82 @@ .hero { border-radius: 0; } + + /* Dossier, watch and your-sky sheets live in the leading pane, so the + globe and the time machine stay live and in sync beside them. */ + .pane-sheets { + right: auto; + width: var(--lead-w); + z-index: 45; + } + + .pane-sheets .sheet { + left: 8px; + right: 8px; + width: auto; + margin: 0; + } + + .pane-sheets .sheet-scrim { + opacity: 0 !important; + } + + /* Moments: chat, record and captures take the leading pane. */ + .app.is-moment .lead { + visibility: hidden !important; + } + + .mp-stage { + left: var(--stage-left); + } + + .mp-side { + left: 0; + right: auto; + top: 0; + bottom: 0; + width: var(--lead-w); + height: auto; + border-radius: 0; + padding-top: calc(var(--safe-t) + 8px); + background: rgba(7, 9, 12, 0.94); + box-shadow: inset -0.5px 0 0 var(--hairline-strong); + } + + .mp-side-head { + padding: 10px 14px 8px; + } + + .mp-pane { + padding: 0 16px 14px; + } + + .mp-react { + bottom: calc(var(--safe-b) + 84px); + } + + .mp-pops { + width: 230px; + } + + .app.is-moment .gc-attr { + bottom: calc(var(--safe-b) + 80px); + } + + .mp-legend { + width: 250px; + } + + .mp-title { + font-size: 1.625rem; + } + + .banners { + left: auto; + right: 0; + width: min(440px, 100%); + justify-items: end; + } } /* Vertical hinge (book posture): split exactly at the fold. */ diff --git a/mobile/styles/moment.css b/mobile/styles/moment.css new file mode 100644 index 000000000..dc59c14b2 --- /dev/null +++ b/mobile/styles/moment.css @@ -0,0 +1,796 @@ +/* ------------------------------------------------------------------ */ +/* Moments player (DESIGN.md §12.4) */ +/* ------------------------------------------------------------------ */ + +/* The globe is the screen; everything else steps aside. */ +.app.is-moment .lead { + visibility: hidden; +} + +.app.is-moment .lead .view { + pointer-events: none; +} + +.app.is-moment .globe-chrome { + visibility: visible; +} + +.app.is-moment .gc-top, +.app.is-moment .gc-bottom, +.app.is-moment .alt-rail, +.app.is-moment .world-back, +.app.is-moment .pick-card, +.app.is-moment .lens-pop { + visibility: hidden; + pointer-events: none; +} + +.app.is-moment .tabbar { + transform: translateY(140%); + opacity: 0; + pointer-events: none; +} + +.app.is-moment .globe-veil { + background: + linear-gradient( + to bottom, + rgba(5, 7, 11, 0.75) 0, + rgba(5, 7, 11, 0) calc(var(--safe-t) + 200px) + ), + linear-gradient(to top, rgba(5, 7, 11, 0.85) 0, rgba(5, 7, 11, 0) 46%); +} + +.mp { + position: absolute; + inset: 0; + z-index: 40; + pointer-events: none; + opacity: 0; + transition: opacity 320ms var(--ease-out); +} + +.mp[hidden] { + display: none; +} + +.mp.in { + opacity: 1; +} + +.mp-stage { + position: absolute; + inset: 0; +} + +.mp-stage > *, +.mp-side { + pointer-events: auto; +} + +.mp-top { + position: absolute; + top: calc(var(--safe-t) + 10px); + left: calc(12px + var(--safe-l)); + right: calc(12px + var(--safe-r)); + display: flex; + align-items: flex-start; + gap: 10px; +} + +.mp-top .icon-btn { + flex: none; + width: 42px; + height: 42px; + font-size: 1.15rem; +} + +.mp-titles { + flex: 1; + min-width: 0; + padding-top: 1px; +} + +.mp-kicker { + display: flex; + align-items: center; + flex-wrap: wrap; + gap: 6px; + color: var(--b-inside); + font-size: 0.5625rem; + font-weight: 600; + letter-spacing: 0.1em; + text-shadow: 0 1px 8px rgba(0, 0, 0, 0.8); +} + +.mp-dot { + width: 6px; + height: 6px; + border-radius: 50%; + background: var(--b-inside); + box-shadow: 0 0 8px var(--b-inside); +} + +.mp-title { + margin: 3px 0 0; + font-family: var(--font-display); + font-size: 1.3125rem; + font-weight: 750; + letter-spacing: -0.03em; + line-height: 1.12; + text-wrap: balance; + text-shadow: 0 2px 16px rgba(0, 0, 0, 0.8); +} + +.mp-clock { + position: absolute; + top: calc(var(--safe-t) + 92px); + left: calc(14px + var(--safe-l)); + display: flex; + align-items: baseline; + gap: 8px; + text-shadow: 0 1px 10px rgba(0, 0, 0, 0.9); + pointer-events: none; +} + +.mp-utc { + font-size: 1.375rem; + font-weight: 700; + color: #fff; + letter-spacing: 0.02em; +} + +.mp-rel { + font-size: 0.6875rem; + color: var(--ink-2); +} + +/* Tracks legend */ +.mp-legend { + position: absolute; + top: calc(var(--safe-t) + 128px); + left: calc(10px + var(--safe-l)); + width: min(230px, 54vw); + padding: 5px; + border-radius: 16px; + display: grid; + gap: 1px; +} + +.mp-legend[hidden] { + display: none; +} + +.mp-tr { + display: flex; + align-items: center; + gap: 8px; + width: 100%; + padding: 6px 8px; + border-radius: 11px; + text-align: left; + color: var(--ink); + transition: + background var(--dur-1) linear, + opacity var(--dur-2) linear; +} + +.mp-tr:hover { + background: rgba(255, 255, 255, 0.07); +} + +.mp-tr.absent { + opacity: 0.4; +} + +.mp-tr .sw { + flex: none; + width: 4px; + height: 26px; + border-radius: 2px; + background: var(--c); + box-shadow: 0 0 10px var(--c); +} + +.mp-tr-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; +} + +.mp-tr-main b { + font-family: var(--mono); + font-size: 0.6875rem; + font-weight: 700; + color: var(--c); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.mp-tr-main small { + font-size: 0.625rem; + color: var(--ink-3); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.mp-tr-v { + flex: none; + display: flex; + flex-direction: column; + align-items: flex-end; + font-size: 0.5625rem; + color: var(--ink-3); +} + +.mp-tr-v b { + color: var(--ink); + font-size: 0.6875rem; +} + +/* Capture pops */ +.mp-pops { + position: absolute; + top: calc(var(--safe-t) + 128px); + right: calc(10px + var(--safe-r)); + width: min(196px, 42vw); + display: grid; + gap: 8px; + pointer-events: none; +} + +.mp-pops .mp-cap { + pointer-events: auto; +} + +.mp-cap { + display: flex; + flex-direction: column; + width: 100%; + overflow: hidden; + border-radius: 16px; + text-align: left; + color: var(--ink); + background: rgba(10, 12, 16, 0.86); + -webkit-backdrop-filter: blur(20px); + backdrop-filter: blur(20px); + box-shadow: + inset 0 0 0 0.5px rgba(235, 199, 119, 0.45), + 0 10px 30px rgba(0, 0, 0, 0.5); +} + +.mp-cap.first { + box-shadow: + inset 0 0 0 1px rgba(235, 199, 119, 0.85), + 0 0 24px rgba(235, 199, 119, 0.25), + 0 10px 30px rgba(0, 0, 0, 0.5); +} + +.mp-cap.pop { + animation: cap-pop 620ms var(--spring) both; +} + +.mp-cap.pop.settle { + transition: opacity 600ms linear; + opacity: 0.85; +} + +@keyframes cap-pop { + from { + opacity: 0; + transform: translateX(30px) scale(0.92); + } +} + +.cone-thumb { + position: relative; + display: block; + width: 100%; + overflow: hidden; + background: #0b0e14; +} + +.cone-thumb img, +.cone-thumb svg { + position: absolute; + inset: 0; + width: 100%; + height: 100%; +} + +.cone-thumb img { + object-fit: cover; + filter: saturate(0.5) brightness(0.7) contrast(1.1); +} + +.mp-cap-body { + display: flex; + flex-direction: column; + gap: 3px; + padding: 8px 10px 10px; +} + +.mp-cap-body .fe { + display: inline-flex; + align-items: center; + gap: 5px; + color: var(--b-inside); + font-size: 0.5625rem; + font-weight: 700; + letter-spacing: 0.1em; + --seal-ink: #2a1a00; +} + +.mp-cap-body .fe .i { + font-size: 0.85rem; +} + +.mp-cap-body b { + font-size: var(--t-cap); + font-weight: 650; + line-height: 1.25; +} + +.mp-cap-body small { + font-family: var(--mono); + font-size: 0.5625rem; + color: var(--ink-3); +} + +/* Reactions */ +.mp-react { + position: absolute; + right: calc(10px + var(--safe-r)); + bottom: calc(var(--safe-b) + 84px + 31vh); + display: flex; + flex-direction: column; + gap: 6px; +} + +.mp-react button { + width: 40px; + height: 40px; + border-radius: 50%; + font-size: 1.15rem; + background: rgba(10, 12, 16, 0.6); + -webkit-backdrop-filter: blur(16px); + backdrop-filter: blur(16px); + box-shadow: inset 0 0 0 0.5px var(--hairline-strong); +} + +.mp-react button:hover { + background: rgba(30, 34, 44, 0.8); +} + +/* Bottom: the Moment scrubber */ +.mp-bar { + position: absolute; + left: calc(8px + var(--safe-l)); + right: calc(8px + var(--safe-r)); + bottom: calc(var(--safe-b) + 10px); + height: 60px; + display: flex; + align-items: center; + gap: 8px; + padding: 0 8px; + border-radius: 20px; +} + +.mp-play { + flex: none; + width: 44px; + height: 44px; + border-radius: 50%; + display: grid; + place-items: center; + color: #050607; + background: #fff; + font-size: 1.1rem; +} + +.mp-play:active { + transform: scale(0.92); +} + +.mp-scrub { + position: relative; + flex: 1; + min-width: 0; + height: 46px; + cursor: pointer; + touch-action: none; +} + +.mp-scrub canvas { + position: absolute; + inset: 0; + width: 100%; + height: 100%; +} + +.mp-head { + position: absolute; + top: 6px; + bottom: 4px; + left: 0; + width: 2px; + margin-left: -1px; + border-radius: 1px; + background: #fff; + box-shadow: 0 0 10px rgba(255, 255, 255, 0.6); + pointer-events: none; +} + +.mp.scrubbing .mp-head { + width: 3px; + margin-left: -1.5px; +} + +.mp-speeds { + flex: none; + display: flex; + padding: 2px; + border-radius: 10px; + background: rgba(255, 255, 255, 0.06); +} + +.mp-speeds button { + min-width: 32px; + height: 30px; + border-radius: 8px; + font-family: var(--mono); + font-size: 0.625rem; + font-weight: 600; + color: var(--ink-3); +} + +.mp-speeds button[aria-checked='true'] { + color: #050607; + background: var(--ink); +} + +/* Side: chat · record · captures (bottom panel on a phone) */ +.mp-side { + position: absolute; + left: calc(8px + var(--safe-l)); + right: calc(8px + var(--safe-r)); + bottom: calc(var(--safe-b) + 78px); + height: 31vh; + min-height: 210px; + display: flex; + flex-direction: column; + border-radius: 22px; + overflow: hidden; + background: rgba(7, 9, 12, 0.7); +} + +.mp-side-head { + flex: none; + padding: 8px 8px 6px; +} + +.mp-seg { + display: flex; + width: 100%; +} + +.mp-seg button { + flex: 1; +} + +.mp-n { + color: var(--ink-3); + font-family: var(--mono); + font-size: 0.625rem; +} + +.mp-pane { + flex: 1; + min-height: 0; + overflow-y: auto; + overscroll-behavior: contain; + padding: 0 12px 10px; + scrollbar-width: thin; + -webkit-mask-image: linear-gradient(to bottom, transparent 0, #000 22px); + mask-image: linear-gradient(to bottom, transparent 0, #000 22px); +} + +.mp-pane[hidden] { + display: none; +} + +.mp-pane.has-ext .mp-chat { + display: none; +} + +.mp-chat { + display: flex; + flex-direction: column; + justify-content: flex-end; + min-height: 100%; + gap: 4px; + padding-top: 16px; +} + +.mp-msg { + font-size: var(--t-foot); + line-height: 1.35; + color: var(--ink-2); + overflow-wrap: anywhere; +} + +.mp-msg.in { + animation: msg-in 280ms var(--ease-out) both; +} + +@keyframes msg-in { + from { + opacity: 0; + transform: translateY(8px); + } +} + +.mp-who { + font-weight: 700; + color: var(--b-sky); +} + +.mp-msg.b-first-eyes .mp-who, +.mp-msg.b-witness .mp-who { + color: var(--b-inside); + text-shadow: 0 0 10px rgba(235, 199, 119, 0.55); +} + +.mp-msg.b-pilot .mp-who { + color: #9be15d; +} + +.mp-msg.b-mod .mp-who { + color: #ff9db0; +} + +.mp-badge { + display: inline-grid; + place-items: center; + width: 15px; + height: 15px; + margin-right: 4px; + border-radius: 4px; + vertical-align: -2px; + font-size: 0.65rem; + color: #2a1a00; + background: var(--b-inside); +} + +.mp-msg.b-pilot .mp-badge { + background: #9be15d; +} + +.mp-msg.b-local .mp-badge { + background: var(--b-sky); + color: #0a1a2a; +} + +.mp-msg.b-mod .mp-badge { + background: #ff9db0; +} + +.mp-txt { + color: var(--ink); +} + +.mp-record, +.mp-caps { + display: grid; + gap: 8px; + padding-top: 12px; +} + +.mp-caps { + grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); +} + +.mp-post { + padding: 10px 12px; + border-radius: 14px; + background: rgba(255, 255, 255, 0.05); + box-shadow: inset 0 0 0 0.5px var(--hairline); +} + +.mp-post.in { + animation: msg-in 380ms var(--spring) both; +} + +.mp-post header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 4px; +} + +.mp-pk { + display: inline-flex; + align-items: center; + gap: 5px; + font-size: var(--t-cap2); + font-weight: 700; + text-transform: uppercase; + letter-spacing: 0.05em; + color: var(--ink-2); +} + +.mp-post.k-witness .mp-pk { + color: var(--b-inside); +} + +.mp-post.k-correction .mp-pk { + color: #ffb547; +} + +.mp-post.k-question .mp-pk { + color: var(--b-sky); +} + +.mp-post.k-synthesis { + background: linear-gradient( + 135deg, + rgba(179, 157, 255, 0.14), + rgba(179, 157, 255, 0.04) + ); + box-shadow: inset 0 0 0 0.5px rgba(179, 157, 255, 0.35); +} + +.mp-post.k-synthesis .mp-pk { + color: var(--b-orbit); +} + +.mp-post header .tele { + font-size: 0.5625rem; + color: var(--ink-3); +} + +.mp-post p { + margin: 0; + font-size: var(--t-foot); + line-height: 1.4; +} + +.mp-post footer { + display: flex; + flex-wrap: wrap; + gap: 10px; + margin-top: 6px; + color: var(--ink-3); + font-size: 0.5625rem; +} + +.mp-post footer span, +.mp-post footer button { + display: inline-flex; + align-items: center; + gap: 4px; +} + +.mp-post footer button { + color: var(--b-inside); +} + +.mp-empty { + padding: 20px 6px; + color: var(--ink-3); + font-size: 0.625rem; + text-align: center; +} + +.mp-src { + flex: none; + margin: 0; + padding: 6px 14px 10px; + color: var(--ink-4); + font-size: 0.5rem; + line-height: 1.5; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.mp[data-illustrative='true'] .mp-src { + color: rgba(199, 180, 255, 0.6); +} + +/* Short phones: the side panel shrinks first */ +@media (max-height: 760px) { + .mp-side { + height: 26vh; + min-height: 170px; + } + .mp-react { + bottom: calc(var(--safe-b) + 84px + 26vh); + } +} + +/* The social chat overlay brings its own reactions. */ +.mp.has-ext .mp-react { + display: none; +} + +/* Attribution stays visible, out of the title's way. */ +.app.is-moment .gc-attr { + top: auto; + left: calc(14px + var(--safe-l)); + bottom: calc(var(--safe-b) + 86px + 31vh); +} + +@media (max-height: 760px) { + .app.is-moment .gc-attr { + bottom: calc(var(--safe-b) + 86px + 26vh); + } +} + +.mp-legend .mp-tr:nth-child(n + 5) { + display: none; +} + +.mp-more { + padding: 4px 10px 6px 20px; + color: var(--ink-3); + font-size: 0.5625rem; +} + +.mp-cap.settled { + opacity: 0.88; +} + +.mp-side-title { + display: none; +} + +.mp-pane.has-ext { + display: flex; + flex-direction: column; + justify-content: flex-end; +} + +.mp-pane.has-ext[hidden] { + display: none; +} + +@media (min-width: 600px) { + .mp-side-title { + display: block; + flex: none; + padding: 6px 18px 4px; + } + + .mp-st-k { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 6px; + color: var(--b-inside); + font-size: 0.5625rem; + letter-spacing: 0.08em; + } + + .mp-side-title h3 { + margin: 6px 0 4px; + font-family: var(--font-display); + font-size: 1.5rem; + font-weight: 750; + letter-spacing: -0.03em; + line-height: 1.1; + } + + .mp-st-s { + margin: 0; + color: var(--ink-3); + font-size: var(--t-foot); + } + + .mp-stage .mp-titles { + visibility: hidden; + } +} diff --git a/mobile/styles/sheet.css b/mobile/styles/sheet.css index 9310819f1..64f7d6f4e 100644 --- a/mobile/styles/sheet.css +++ b/mobile/styles/sheet.css @@ -543,3 +543,7 @@ display: block; margin-bottom: 4px; } + +.sheet:focus { + outline: none; +} diff --git a/mobile/styles/shell.css b/mobile/styles/shell.css index 35c9a0913..d3f58d176 100644 --- a/mobile/styles/shell.css +++ b/mobile/styles/shell.css @@ -91,22 +91,22 @@ } /* The Globe tab's leading view only exists on regular widths. */ -#view-globe { +#view-live { display: none; } /* Phone: the Globe tab and an open situation reveal the stage. */ -.app[data-tab='globe'] .lead, +.app[data-tab='live'] .lead, .app.is-world .lead { visibility: hidden; } -.app[data-tab='globe'] .lead .view, +.app[data-tab='live'] .lead .view, .app.is-world .lead .view { pointer-events: none; } -.app:not([data-tab='globe']):not(.is-world) .globe-chrome { +.app:not([data-tab='live']):not(.is-world) .globe-chrome { visibility: hidden; } diff --git a/mobile/styles/timemachine.css b/mobile/styles/timemachine.css new file mode 100644 index 000000000..4f63cd20c --- /dev/null +++ b/mobile/styles/timemachine.css @@ -0,0 +1,285 @@ +/* ------------------------------------------------------------------ */ +/* Time machine (DESIGN.md §12.5) */ +/* ------------------------------------------------------------------ */ + +.ribbon.tm { + display: flex; + flex-direction: column; + align-items: stretch; + gap: 0; + height: auto; + padding: 6px 6px 4px; + border-radius: 20px; + background: rgba(7, 9, 12, 0.78); + -webkit-backdrop-filter: blur(24px) saturate(1.5); + backdrop-filter: blur(24px) saturate(1.5); + box-shadow: + inset 0 0.5px 0 rgba(255, 255, 255, 0.2), + inset 0 0 0 0.5px var(--hairline-strong), + 0 12px 40px rgba(0, 0, 0, 0.45); +} + +.tm-row { + display: flex; + align-items: center; + gap: 6px; + min-height: 40px; +} + +.tm-play { + flex: none; + width: 40px; + height: 40px; + border-radius: 50%; + display: grid; + place-items: center; + color: #050607; + background: #f4f7fb; + font-size: 1.05rem; + transition: + transform var(--dur-1) var(--ease-out), + background var(--dur-2) linear; +} + +.tm-play:hover { + background: #fff; +} + +.tm-play:active { + transform: scale(0.92); +} + +.ribbon.tm.is-playing .tm-play { + background: var(--b-sky); +} + +.tm-read { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + line-height: 1.1; + padding-left: 4px; +} + +.tm-delta { + font-family: var(--mono); + font-size: 1.0625rem; + font-weight: 700; + letter-spacing: 0.02em; + white-space: nowrap; + color: var(--ink); +} + +.ribbon.tm.is-live .tm-delta { + color: #ff6b61; +} + +.ribbon.tm[data-future='true'] .tm-delta { + color: var(--b-orbit); +} + +.tm-abs { + font-family: var(--mono); + font-size: 0.6875rem; + font-weight: 500; + color: var(--ink-3); + letter-spacing: 0.05em; + white-space: nowrap; +} + +.tm-speeds { + flex: none; + display: flex; + padding: 2px; + border-radius: 10px; + background: rgba(255, 255, 255, 0.06); +} + +.tm-speeds button { + min-width: 34px; + height: 30px; + padding: 0 4px; + border-radius: 8px; + font-family: var(--mono); + font-size: 0.6875rem; + font-weight: 600; + color: var(--ink-3); + transition: + background var(--dur-1) linear, + color var(--dur-1) linear; +} + +.tm-speeds button:hover { + color: var(--ink); +} + +.tm-speeds button[aria-checked='true'] { + color: #050607; + background: var(--ink); +} + +.tm-clip.icon-btn { + flex: none; + width: 34px; + height: 34px; + font-size: 1.05rem; + color: var(--ink-2); + background: rgba(255, 255, 255, 0.06); +} + +.tm-clip[aria-pressed='true'] { + color: #2a1a00; + background: var(--b-inside); +} + +.ribbon.tm .tm-now { + height: 34px; + padding: 0 10px; + border-radius: 10px; +} + +.tm-track.rb-track { + flex: none; + height: 52px; + margin: 2px 0 0; + border-radius: 12px; + cursor: grab; +} + +.ribbon.tm.scrubbing .tm-track { + cursor: grabbing; +} + +.ribbon.tm.is-clipping .tm-track { + cursor: crosshair; +} + +.tm-head.rb-head { + top: 4px; + bottom: 4px; + width: 2px; + margin-left: -1px; + background: #fff; + box-shadow: 0 0 12px rgba(255, 255, 255, 0.55); +} + +.tm-head i { + position: absolute; + top: -2px; + left: 50%; + width: 9px; + height: 6px; + margin-left: -4.5px; + background: inherit; + clip-path: polygon(0 0, 100% 0, 50% 100%); +} + +.ribbon.tm.is-live .tm-head { + background: #ff453a; + box-shadow: 0 0 12px rgba(255, 69, 58, 0.7); +} + +.ribbon.tm.is-playing .tm-head { + background: var(--b-sky); + box-shadow: 0 0 14px rgba(163, 216, 255, 0.8); + animation: none; +} + +.tm-callout { + position: absolute; + left: 50%; + bottom: calc(100% + 6px); + transform: translateX(-50%); + max-width: 82%; + padding: 5px 9px; + border-radius: 8px; + background: rgba(8, 10, 14, 0.92); + box-shadow: inset 0 0 0 0.5px var(--hairline-strong); + color: var(--ink); + font-size: 0.6875rem; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + border-left: 3px solid var(--c, #fff); + pointer-events: none; + animation: tm-pop 260ms var(--spring) both; +} + +@keyframes tm-pop { + from { + opacity: 0; + transform: translate(-50%, 6px) scale(0.96); + } +} + +.tm-cliprow { + display: flex; + align-items: center; + gap: 8px; + padding: 6px 2px 2px; +} + +.tm-cliprow[hidden] { + display: none; +} + +.tm-cliplen { + flex: 1; + min-width: 0; + color: var(--ink-2); + font-size: 0.6875rem; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.tm-cliplen b { + color: var(--b-inside); +} + +.tm-cliprow .pill-btn { + height: 34px; + padding: 0 12px; + font-size: var(--t-foot); +} + +.tm-clipgo.pill-btn.primary { + background: var(--b-inside); + color: #2a1a00; +} + +.tm-clipgo:disabled { + opacity: 0.4; +} + +.ribbon.tm.custom .tm-speeds, +.ribbon.tm.custom .tm-clip, +.ribbon.tm.custom .tm-play { + display: none; +} + +@media (max-width: 380px) { + .tm-speeds button { + min-width: 28px; + } + .tm-delta { + font-size: 0.9375rem; + } +} + +@media (hover: hover) { + .tm-track:hover { + background: rgba(255, 255, 255, 0.02); + } +} + +/* The tab-bar accessory takes a row above the tab bar: chrome sits above it. */ +:root.has-accessory { + --chrome-bottom: calc(var(--tabbar-h) + var(--tabbar-gap) + 66px); +} + +.tm-cliplen { + white-space: normal; + line-height: 1.35; +} diff --git a/mobile/styles/today.css b/mobile/styles/today.css new file mode 100644 index 000000000..608f07f72 --- /dev/null +++ b/mobile/styles/today.css @@ -0,0 +1,806 @@ +/* ------------------------------------------------------------------ */ +/* Today: the daily brief (DESIGN.md §12.3) */ +/* ------------------------------------------------------------------ */ + +/* Shared honesty labels */ +.tag-ill, +.tag-real { + display: inline-flex; + align-items: center; + height: 17px; + padding: 0 6px; + border-radius: 5px; + font-family: var(--mono); + font-size: 0.5625rem; + font-weight: 600; + letter-spacing: 0.08em; + text-transform: uppercase; + vertical-align: middle; +} + +.tag-ill { + color: #e9d8ff; + background: rgba(179, 157, 255, 0.18); + box-shadow: inset 0 0 0 0.5px rgba(179, 157, 255, 0.45); +} + +.tag-real { + color: #c9f7d6; + background: rgba(48, 209, 88, 0.16); + box-shadow: inset 0 0 0 0.5px rgba(48, 209, 88, 0.4); +} + +.glass-card { + border-radius: 20px; + background: linear-gradient( + 180deg, + rgba(255, 255, 255, 0.055), + rgba(255, 255, 255, 0.025) + ); + box-shadow: + inset 0 0.5px 0 rgba(255, 255, 255, 0.14), + inset 0 0 0 0.5px var(--hairline); +} + +/* Header: date kicker, greeting, UTC */ +.today-hero { + align-items: flex-end; + flex-wrap: wrap; + row-gap: 0; +} + +.today-date { + flex-basis: 100%; + padding: 0 calc(var(--gutter) + var(--safe-r)) 2px + calc(var(--gutter) + var(--safe-l)); + margin-top: -4px; + color: var(--b-sky); + font-size: 0.6875rem; + font-weight: 600; + letter-spacing: 0.1em; +} + +.today-title { + display: flex; + flex-wrap: wrap; + align-items: baseline; + column-gap: 10px; + margin: 0; + cursor: default; + user-select: none; + -webkit-user-select: none; +} + +.today-time { + color: var(--ink-3); + font-weight: 600; +} + +.today-hero .feed-clock b { + font-size: 0.6875rem; + color: var(--ink-3); + font-weight: 500; +} + +.fresh-chip { + height: 28px; + display: inline-flex; + align-items: center; + gap: 6px; + padding: 0 10px; + border-radius: 14px; + color: #c9f7d6; + background: rgba(48, 209, 88, 0.14); + box-shadow: inset 0 0 0 0.5px rgba(48, 209, 88, 0.35); + font-size: 0.625rem; + white-space: nowrap; +} + +.fresh-chip[hidden] { + display: none; +} + +.fresh-chip.in { + animation: fresh-in 4.2s var(--ease-out) both; +} + +@keyframes fresh-in { + 0% { + opacity: 0; + transform: translateY(-6px) scale(0.96); + } + 8%, + 86% { + opacity: 1; + transform: none; + } + 100% { + opacity: 0; + } +} + +/* The brief */ +.brief { + display: grid; + gap: 12px; + padding: 16px calc(12px + var(--safe-r)) 6px calc(12px + var(--safe-l)); +} + +.bf-h { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: 8px; + padding: 13px 16px 6px; +} + +.bf-h h3 { + margin: 0; + font-family: var(--font-display); + font-size: var(--t-headline); + font-weight: 700; + letter-spacing: -0.02em; +} + +.bf-h .tele { + color: var(--ink-3); + font-size: 0.625rem; +} + +.bf-h .chev { + color: var(--ink-3); + font-size: 0.9rem; +} + +.bf-rows, +[data-tonight], +[data-watch] { + display: grid; + padding: 0 4px 6px; +} + +.bf-row { + position: relative; + display: flex; + align-items: center; + gap: 11px; + width: 100%; + min-height: 52px; + padding: 8px 12px; + border-radius: 14px; + text-align: left; + color: var(--ink); + transition: background var(--dur-1) linear; +} + +button.bf-row:hover { + background: rgba(255, 255, 255, 0.05); +} + +button.bf-row:active { + background: rgba(255, 255, 255, 0.08); +} + +.bf-row + .bf-row::before { + content: ''; + position: absolute; + top: 0; + left: 34px; + right: 12px; + height: 0.5px; + background: var(--hairline); +} + +.bf-row .bd { + flex: none; + width: 9px; + height: 9px; + border-radius: 3px; + background: var(--band, var(--ink-3)); + box-shadow: 0 0 10px var(--band, transparent); +} + +.bf-row[data-band='orbit'] { + --band: var(--b-orbit); +} +.bf-row[data-band='sky'] { + --band: var(--b-sky); +} +.bf-row[data-band='ground'] { + --band: var(--b-ground); +} +.bf-row[data-band='inside'] { + --band: var(--b-inside); +} + +.bf-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 2px; +} + +.bf-main b { + font-size: var(--t-sub); + font-weight: 600; + letter-spacing: -0.01em; + line-height: 1.25; + display: -webkit-box; + -webkit-line-clamp: 2; + -webkit-box-orient: vertical; + overflow: hidden; +} + +.bf-main small { + color: var(--ink-3); + font-size: var(--t-cap); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.bf-when { + flex: none; + color: var(--ink-3); + font-size: 0.5625rem; +} + +.bf-ic { + flex: none; + width: 30px; + height: 30px; + border-radius: 9px; + display: grid; + place-items: center; + font-size: 1rem; + color: var(--band, var(--ink-2)); + background: color-mix(in srgb, var(--band, #fff) 14%, transparent); +} + +.bf-ok { + color: var(--ok); +} + +.bf-row .chev { + color: var(--ink-4); +} + +.bf-add { + color: var(--tint); + font-size: var(--t-foot); +} + +.bf-add .i { + font-size: 1.05rem; +} + +.bf-calm { + display: flex; + align-items: center; + gap: 10px; + padding: 10px 14px 12px; + color: var(--ink-2); + font-size: var(--t-foot); +} + +.bf-calm .i { + color: var(--ok); +} + +.bf-ph i { + width: 9px; + height: 9px; + border-radius: 3px; + background: rgba(255, 255, 255, 0.1); +} + +.bf-ph span { + flex: 1; + height: 12px; + border-radius: 6px; + background: linear-gradient( + 90deg, + rgba(255, 255, 255, 0.05), + rgba(255, 255, 255, 0.1), + rgba(255, 255, 255, 0.05) + ); + background-size: 200% 100%; + animation: shimmer 1.4s linear infinite; +} + +@keyframes shimmer { + to { + background-position: -200% 0; + } +} + +/* Today's Moment: plays inline */ +.bf-moment { + position: relative; + display: block; + width: 100%; + aspect-ratio: 16 / 11; + border-radius: 22px; + overflow: hidden; + text-align: left; + color: #fff; + background: radial-gradient(120% 90% at 50% 30%, #18243a, #07090d); + box-shadow: + inset 0 0 0 0.5px rgba(255, 255, 255, 0.16), + 0 18px 40px rgba(0, 0, 0, 0.45); + isolation: isolate; + transition: transform var(--dur-2) var(--spring); +} + +.bf-moment:active { + transform: scale(0.985); +} + +.bf-mimg, +.bf-mcanvas, +.bf-mshade { + position: absolute; + inset: 0; + width: 100%; + height: 100%; +} + +.bf-mimg { + object-fit: cover; + opacity: 0; + filter: saturate(0.6) brightness(0.62) contrast(1.1); + transition: opacity 600ms linear; +} + +.bf-mimg.loaded { + opacity: 1; +} + +.bf-mshade { + background: + linear-gradient(180deg, rgba(5, 7, 11, 0.7) 0, rgba(5, 7, 11, 0) 34%), + linear-gradient(0deg, rgba(5, 7, 11, 0.92) 0, rgba(5, 7, 11, 0) 52%); + pointer-events: none; +} + +.bf-mtop { + position: absolute; + top: 14px; + left: 16px; + right: 16px; + display: flex; + align-items: center; + gap: 8px; + font-size: 0.625rem; +} + +.bf-mk { + color: var(--b-inside); + font-weight: 700; + letter-spacing: 0.12em; +} + +.bf-mbody { + position: absolute; + left: 16px; + right: 72px; + bottom: 16px; + display: flex; + flex-direction: column; + gap: 4px; +} + +.bf-mtitle { + font-family: var(--font-display); + font-size: 1.5rem; + font-weight: 750; + line-height: 1.08; + letter-spacing: -0.03em; + text-wrap: balance; +} + +.bf-msub { + color: rgba(255, 255, 255, 0.7); + font-size: var(--t-cap); + line-height: 1.3; +} + +.bf-mplay { + position: absolute; + right: 16px; + bottom: 18px; + width: 48px; + height: 48px; + border-radius: 50%; + display: grid; + place-items: center; + font-size: 1.2rem; + color: #050607; + background: #fff; + box-shadow: 0 6px 20px rgba(0, 0, 0, 0.45); + transition: transform var(--dur-2) var(--spring); +} + +.bf-moment:hover .bf-mplay { + transform: scale(1.06); +} + +.bf-mclock { + position: absolute; + top: 36px; + left: 16px; + color: rgba(255, 255, 255, 0.6); + font-size: 0.5625rem; +} + +.bf-moment:not(.ready) .bf-mplay { + opacity: 0.4; +} + +/* Your sky now (a button) + Overhead tonight */ +.bf-sky { + display: flex; + align-items: center; + gap: 14px; + width: 100%; + padding: 12px 14px 12px 12px; + text-align: left; + color: var(--ink); + transition: + background var(--dur-1) linear, + transform var(--dur-2) var(--spring); +} + +.bf-sky:hover { + background: rgba(255, 255, 255, 0.06); +} + +.bf-sky:active { + transform: scale(0.99); +} + +.bf-dome { + flex: none; + width: 92px; + height: 92px; + display: grid; + place-items: center; +} + +.bf-dome .dome { + width: 92px; + height: 92px; +} + +.bf-skytxt { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 4px; +} + +.bf-skyk { + display: inline-flex; + align-items: center; + gap: 6px; + color: var(--b-sky); + font-size: 0.5625rem; + font-weight: 600; + letter-spacing: 0.1em; +} + +.bf-skyk .live-dot { + --fam: var(--b-sky); + width: 5px; + height: 5px; +} + +.bf-skyh { + font-family: var(--font-display); + font-size: 1.0625rem; + font-weight: 700; + letter-spacing: -0.02em; + line-height: 1.2; + text-wrap: balance; +} + +.bf-skytxt small { + color: var(--ink-3); + font-size: var(--t-cap); + line-height: 1.3; +} + +.bf-sky > .chev { + flex: none; + color: var(--ink-4); +} + +.bf-tonight .bf-when { + color: var(--b-orbit); + font-size: 0.625rem; + font-weight: 600; +} + +/* Sections below the brief */ +.feed-section-h { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: 8px; + padding: 22px calc(var(--gutter) + var(--safe-r)) 0 + calc(var(--gutter) + var(--safe-l)); +} + +.feed-section-h h2 { + margin: 0; + font-family: var(--font-display); + font-size: var(--t-title3); + font-weight: 750; + letter-spacing: -0.025em; +} + +.feed-section-h .tele { + color: var(--ink-3); + font-size: 0.5625rem; +} + +#view-today .bandbar { + margin-top: 6px; +} + +/* Sky dome (shared by the widget and the sheet) */ +.dome .dm-ring { + fill: none; + stroke: rgba(255, 255, 255, 0.1); + stroke-width: 0.8; +} + +.dome .dm-horizon { + fill: none; + stroke: rgba(163, 216, 255, 0.35); + stroke-width: 1; +} + +.dome .dm-card { + fill: var(--ink-3); + font: 600 10px var(--mono); + text-anchor: middle; +} + +.dome .dm-card.n { + fill: #ff6b61; +} + +.dome .dm-el { + fill: var(--ink-4); + font: 500 8px var(--mono); +} + +.dome .dm-ac path { + fill: var(--b-sky); + stroke: #050607; + stroke-width: 0.8; +} + +.dome .dm-sat rect { + fill: var(--b-orbit); +} + +.dome .dm-iss circle { + fill: #fff; +} + +.dome .dm-iss .ring { + fill: none; + stroke: #fff; + stroke-opacity: 0.5; +} + +.dome .dm-iss text { + fill: #fff; + font: 700 9px var(--mono); +} + +.dome .dm-you { + fill: var(--b-inside); +} + +/* Your sky now sheet */ +.sky-kicker { + display: flex; + align-items: center; + gap: 6px; + color: var(--ink-3); + font-size: 0.625rem; + padding-top: 2px; +} + +.sky-top { + display: grid; + grid-template-columns: minmax(0, 1fr); + justify-items: center; + gap: 10px; + padding: 8px 0 4px; +} + +.sky-dome .dome { + width: min(300px, 78vw); + height: auto; + filter: drop-shadow(0 18px 40px rgba(0, 0, 0, 0.5)); +} + +.sky-count { + display: grid; + grid-template-columns: repeat(3, 1fr); + width: 100%; + max-width: 420px; + gap: 8px; +} + +.sky-count div { + display: flex; + flex-direction: column; + align-items: center; + gap: 2px; + padding: 10px 4px; + border-radius: 14px; + background: rgba(255, 255, 255, 0.05); +} + +.sky-count b { + font-family: var(--font-display); + font-size: 1.375rem; + font-weight: 750; + letter-spacing: -0.02em; +} + +.sky-count span { + color: var(--ink-3); + font-size: var(--t-cap2); +} + +.sky-iss { + display: flex; + gap: 12px; + align-items: center; + margin: 12px 0 4px; + padding: 12px 14px; + border-radius: 16px; + background: linear-gradient( + 135deg, + rgba(179, 157, 255, 0.18), + rgba(179, 157, 255, 0.05) + ); + box-shadow: inset 0 0 0 0.5px rgba(179, 157, 255, 0.35); +} + +.sky-iss > .i { + flex: none; + font-size: 1.4rem; + color: var(--b-orbit); +} + +.sky-iss div { + display: flex; + flex-direction: column; + gap: 2px; +} + +.sky-iss b { + font-size: var(--t-sub); +} + +.sky-iss span { + color: var(--ink-2); + font-size: var(--t-cap); +} + +.sky-row { + display: flex; + align-items: center; + gap: 12px; + width: 100%; + min-height: 54px; + padding: 8px 14px; + text-align: left; + color: var(--ink); + position: relative; +} + +.sky-row + .sky-row::before { + content: ''; + position: absolute; + top: 0; + left: 54px; + right: 0; + height: 0.5px; + background: var(--hairline); +} + +.sky-row:hover { + background: rgba(255, 255, 255, 0.04); +} + +.sky-ic { + flex: none; + width: 30px; + height: 30px; + border-radius: 9px; + display: grid; + place-items: center; + font-size: 1rem; +} + +.sky-row[data-band='sky'] .sky-ic { + color: var(--b-sky); + background: rgba(163, 216, 255, 0.12); +} + +.sky-row[data-band='orbit'] .sky-ic { + color: var(--b-orbit); + background: rgba(179, 157, 255, 0.12); +} + +.sky-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 2px; +} + +.sky-main b { + font-family: var(--mono); + font-size: var(--t-foot); + font-weight: 600; +} + +.sky-main small { + color: var(--ink-3); + font-size: var(--t-cap); +} + +.sky-el { + flex: none; + display: flex; + flex-direction: column; + align-items: flex-end; + color: var(--ink-3); + font-size: 0.5rem; +} + +.sky-el b { + color: var(--ink); + font-size: 0.875rem; +} + +.section-h small { + font-family: var(--mono); +} + +@media (min-width: 600px) { + .bf-mtitle { + font-size: 1.375rem; + } +} + +.bf-rows, +[data-tonight], +[data-watch], +.brief { + grid-template-columns: minmax(0, 1fr); +} + +/* UTC rides on the date row, right-aligned; never wraps under the title. */ +.today-hero { + position: relative; +} + +.today-hero .feed-clock { + position: absolute; + top: -4px; + right: calc(var(--gutter) + var(--safe-r)); + padding: 0; +} diff --git a/mobile/styles/watch.css b/mobile/styles/watch.css new file mode 100644 index 000000000..269ab6999 --- /dev/null +++ b/mobile/styles/watch.css @@ -0,0 +1,327 @@ +/* ------------------------------------------------------------------ */ +/* Watch & alerts, banners, director, pane sheets */ +/* ------------------------------------------------------------------ */ + +/* Pane sheets: the whole screen on a phone (above the tab bar). */ +.pane-sheets { + z-index: 58; +} + +/* Rules as sentences with chips */ +.rules { + display: grid; + gap: 8px; +} + +.rule { + position: relative; + display: grid; + grid-template-columns: auto 1fr auto; + grid-template-rows: auto auto; + align-items: center; + column-gap: 12px; + padding: 12px 14px; + border-radius: 16px; + background: rgba(255, 255, 255, 0.045); + box-shadow: inset 0 0 0 0.5px var(--hairline); + --rc: var(--ink-2); +} + +.rule[data-band='orbit'] { + --rc: var(--b-orbit); +} +.rule[data-band='sky'] { + --rc: var(--b-sky); +} +.rule[data-band='ground'] { + --rc: var(--b-ground); +} + +.rule .bd { + grid-row: 1 / span 2; + width: 4px; + height: 100%; + min-height: 34px; + border-radius: 2px; + background: var(--rc); +} + +.rule p { + margin: 0; + font-size: var(--t-sub); + line-height: 1.9; + color: var(--ink-2); +} + +.rule .switch { + grid-row: 1 / span 2; + grid-column: 3; +} + +.rule-state { + grid-column: 2; + color: var(--ink-3); + font-size: 0.5625rem; +} + +.rule-chip { + display: inline-flex; + align-items: center; + gap: 3px; + height: 28px; + padding: 0 6px 0 10px; + border-radius: 8px; + color: var(--ink); + font-weight: 600; + background: color-mix(in srgb, var(--rc) 18%, rgba(255, 255, 255, 0.04)); + box-shadow: inset 0 0 0 0.5px color-mix(in srgb, var(--rc) 45%, transparent); + vertical-align: baseline; + transition: background var(--dur-1) linear; +} + +.rule-chip:hover { + background: color-mix(in srgb, var(--rc) 28%, rgba(255, 255, 255, 0.04)); +} + +.rule-chip .i { + font-size: 0.7rem; + color: var(--ink-3); +} + +.new-rule { + margin-top: 10px; +} + +.row-add { + color: var(--tint); + gap: 10px; +} + +.row-icon[data-band='orbit'] { + color: var(--b-orbit); +} +.row-icon[data-band='sky'] { + color: var(--b-sky); +} +.row-icon[data-band='ground'] { + color: var(--b-ground); +} + +/* iOS-style notification banners */ +.banners { + position: absolute; + top: calc(var(--safe-t) + 8px); + left: 0; + right: 0; + z-index: 80; + display: grid; + justify-items: center; + gap: 8px; + padding: 0 10px; + pointer-events: none; +} + +.banner { + pointer-events: auto; + width: min(420px, 100%); + display: flex; + align-items: flex-start; + gap: 11px; + padding: 12px 14px; + border-radius: 22px; + text-align: left; + color: var(--ink); + background: rgba(28, 32, 40, 0.78); + -webkit-backdrop-filter: blur(30px) saturate(1.8); + backdrop-filter: blur(30px) saturate(1.8); + box-shadow: + inset 0 0.5px 0 rgba(255, 255, 255, 0.25), + inset 0 0 0 0.5px rgba(255, 255, 255, 0.08), + 0 16px 40px rgba(0, 0, 0, 0.5); + touch-action: none; + animation: banner-in 560ms var(--spring) both; + transition: + transform 260ms var(--ease-out), + opacity 260ms linear; + --bc: var(--b-sky); +} + +.banner[data-band='orbit'] { + --bc: var(--b-orbit); +} +.banner[data-band='ground'] { + --bc: var(--b-ground); +} +.banner[data-band='inside'] { + --bc: var(--b-inside); +} + +.banner.out { + opacity: 0; + transform: translateY(-40px) scale(0.96); +} + +@keyframes banner-in { + from { + opacity: 0; + transform: translateY(-60px) scale(0.94); + } +} + +.bn-app { + flex: none; + width: 38px; + height: 38px; + border-radius: 10px; + display: grid; + place-items: center; + font-size: 1.3rem; + color: #050607; + background: linear-gradient(145deg, #ffe3a3, var(--b-inside)); + box-shadow: inset 0 0 0 0.5px rgba(255, 255, 255, 0.4); +} + +.bn-main { + flex: 1; + min-width: 0; + display: flex; + flex-direction: column; + gap: 1px; +} + +.bn-top { + display: flex; + justify-content: space-between; + color: var(--ink-3); + font-size: var(--t-cap2); + letter-spacing: 0.02em; +} + +.bn-top b { + font-weight: 600; +} + +.bn-title { + display: flex; + align-items: center; + gap: 5px; + font-size: var(--t-sub); + font-weight: 650; +} + +.bn-title .i { + flex: none; + color: var(--bc); + font-size: 0.95rem; +} + +.bn-body { + color: var(--ink-2); + font-size: var(--t-foot); + line-height: 1.3; +} + +/* Director */ +.dir-kicker { + display: flex; + align-items: center; + gap: 6px; + color: #ff9db0; + font-size: 0.625rem; + padding-top: 2px; +} + +.dir-beats { + list-style: none; + margin: 6px 0 0; + padding: 0; + display: grid; + gap: 6px; +} + +.dir-beat { + display: flex; + align-items: center; + gap: 12px; + width: 100%; + padding: 10px 12px; + border-radius: 14px; + text-align: left; + color: var(--ink); + background: rgba(255, 255, 255, 0.04); + transition: background var(--dur-1) linear; +} + +.dir-beat:hover { + background: rgba(255, 255, 255, 0.08); +} + +.dir-beat.done { + box-shadow: inset 0 0 0 1px rgba(255, 157, 176, 0.5); +} + +.dir-n { + flex: none; + width: 28px; + height: 28px; + border-radius: 8px; + display: grid; + place-items: center; + font-family: var(--mono); + font-size: 0.75rem; + font-weight: 700; + color: #050607; + background: var(--ink); +} + +.dir-main { + flex: 1; + display: flex; + flex-direction: column; + gap: 2px; +} + +.dir-main b { + font-size: var(--t-sub); + font-weight: 650; +} + +.dir-main small { + color: var(--ink-3); + font-size: var(--t-cap); +} + +.dir-beat > .i { + color: var(--ink-3); +} + +.dir-foot { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 10px; + justify-content: space-between; + margin-top: 16px; +} + +.dir-foot .tele { + color: var(--ink-4); + font-size: 0.5rem; +} + +/* Brief "as of" chip on an open situation */ +.brief-asof { + display: inline-flex; + align-items: center; + gap: 5px; + margin-top: 8px; + padding: 4px 8px; + border-radius: 7px; + color: var(--b-sky); + background: rgba(163, 216, 255, 0.1); + font-size: 0.5625rem; +} + +.brief-asof[hidden] { + display: none; +} diff --git a/mobile/ui/director.js b/mobile/ui/director.js new file mode 100644 index 000000000..7f70cc355 --- /dev/null +++ b/mobile/ui/director.js @@ -0,0 +1,104 @@ +/** + * Director (DESIGN.md §12.8): a presenter menu for demos. Press "." (or + * triple-tap the Today title) to open it; each beat sets up its state + * deterministically so the demo never depends on luck. Number keys 1–9 jump + * straight to a beat while the menu is closed and the director is armed. + */ + +import { icon } from './icons.js'; +import { esc, haptic, toast } from './dom.js'; +import { createSheet } from './sheet.js'; + +export function createDirector({ beats, onReset }) { + const sheet = createSheet({ + label: 'Director', + detents: ['large'], + modal: true, + dismissible: true, + closeButton: true, + className: 'director-sheet', + heights: { large: (H) => Math.min(Math.round(H * 0.9), 820) }, + }); + let armed = false; + let current = -1; + + function render() { + sheet.head.innerHTML = `
${icon('director')}DIRECTOR · DEMO MODE

The story, beat by beat

Each beat sets its own state. Keys 1–9 jump; “.” reopens this menu.
`; + sheet.body.innerHTML = `
    ${beats + .map( + ( + b, + i, + ) => `
    2. `, + ) + .join('')}
+
Real data shows its source and age · illustrative content is labelled
`; + } + + async function run(i) { + const b = beats[i]; + if (!b) return; + current = i; + armed = true; + haptic('medium'); + if (sheet.isOpen) sheet.close(); + try { + await b.run(); + } catch (err) { + console.error('[director] beat failed', err); + toast(`Beat “${b.title}” could not be set up`, { icon: icon('info') }); + } + } + + sheet.body.addEventListener('click', async (e) => { + const b = e.target.closest('[data-beat]'); + if (b) return run(Number(b.dataset.beat)); + if (e.target.closest('[data-reset]')) { + sheet.close(); + current = -1; + await onReset?.(); + toast('Demo reset', { icon: icon('refresh') }); + } + }); + + document.addEventListener('keydown', (e) => { + if (e.target.closest?.('input, textarea, [contenteditable]')) return; + if (e.metaKey || e.ctrlKey || e.altKey) return; + if (e.key === '.') { + e.preventDefault(); + if (sheet.isOpen) sheet.close(); + else open(); + return; + } + if (armed && /^[1-9]$/.test(e.key) && !sheet.isOpen) run(Number(e.key) - 1); + }); + + function open() { + armed = true; + render(); + sheet.open('large'); + } + + /** Triple-tap (or triple-click) on an element opens the director. */ + function bindTripleTap(el) { + let taps = []; + el.addEventListener('pointerup', () => { + const n = performance.now(); + taps = [...taps.filter((t) => n - t < 650), n]; + if (taps.length >= 3) { + taps = []; + open(); + } + }); + } + + return { + open, + run, + bindTripleTap, + get isOpen() { + return sheet.isOpen; + }, + }; +} diff --git a/mobile/ui/dossier.js b/mobile/ui/dossier.js new file mode 100644 index 000000000..06d4b44e4 --- /dev/null +++ b/mobile/ui/dossier.js @@ -0,0 +1,473 @@ +/** + * Dossiers (DESIGN.md §12.1): every object has identity, live state, a track + * history, events, links and receipts. Tapping any entity anywhere (a globe + * pick, a search result, a track in a Moment, a node in the link graph) + * opens one. The Graph segment shows globe.graph(ref); globe, time machine + * and graph share one selection. + */ + +import { icon } from './icons.js'; +import { + $, + $$, + esc, + ago, + fmtNum, + haptic, + toast, + store, + sparkPath, +} from './dom.js'; +import { createSheet } from './sheet.js'; +import { createLinkGraph } from './linkGraph.js'; +import { BAND_NAME, utc, llShort, mgrs, cardinal } from './bands.js'; +import { bandOfKind } from './shim3.js'; + +export const KIND_ICON = { + aircraft: 'sky', + helicopter: 'heli', + military: 'sky', + satellite: 'satellite', + station: 'satellite', + vessel: 'sea', + quake: 'hazards', + fire: 'flame', + camera: 'video', + situation: 'now', + place: 'pin', + moment: 'film', + track: 'scope', + capture: 'seal', +}; +export const KIND_NAME = { + aircraft: 'Aircraft', + helicopter: 'Helicopter', + military: 'Military aircraft', + satellite: 'Satellite', + vessel: 'Vessel', + quake: 'Earthquake', + camera: 'Public camera', + situation: 'Situation', + place: 'Place', + moment: 'Moment', + track: 'Track', + capture: 'Sealed capture', +}; + +const ID_LABEL = { + icao24: 'ICAO 24-bit', + callsign: 'Callsign', + registration: 'Registration', + norad: 'NORAD ID', + mmsi: 'MMSI', +}; + +const cap = (x) => (x ? `${x[0].toUpperCase()}${x.slice(1)}` : x); + +function liveRows(d) { + const L = d.live; + if (!L) return []; + const rows = []; + if (Number.isFinite(L.altM) && L.altM > 0) + rows.push([ + 'Altitude', + L.altM > 100e3 + ? fmtNum(Math.round(L.altM / 1000)) + : fmtNum(Math.round((L.altM * 3.28084) / 10) * 10), + L.altM > 100e3 ? 'km' : 'ft', + ]); + if (Number.isFinite(L.speed) && L.speed > 0) + rows.push( + d.kind === 'satellite' + ? ['Speed', (L.speed / 1000).toFixed(2), 'km/s'] + : ['Speed', fmtNum(Math.round(L.speed * 1.94384)), 'kt'], + ); + if (Number.isFinite(L.heading)) + rows.push([ + 'Heading', + `${Math.round(((L.heading % 360) + 360) % 360)}°`, + cardinal(L.heading), + ]); + if (L.squawk) rows.push(['Squawk', L.squawk, '']); + if (!rows.length && Number.isFinite(L.lat)) + rows.push(['Position', llShort(L.lat, L.lon, 3), '']); + return rows.slice(0, 4); +} + +/** Altitude profile (area) + ground track (polyline), both from real points. */ +function trackHtml(d) { + const tr = (d.track || []).filter((p) => Number.isFinite(p.t)); + if (tr.length < 3) return ''; + if (Number.isFinite(tr[0].v)) { + const W = 300; + const H = 64; + const path = sparkPath( + tr.map((p) => p.v), + W, + H, + 3, + ); + return `

History${tr.length} samples · ${esc(ago(tr[0].t))} → now

+
`; + } + const W = 300; + const H = 70; + const alts = tr.map((p) => (Number.isFinite(p.altM) ? p.altM : 0)); + const hi = Math.max(...alts); + const lo = Math.min(0, ...alts); + const t0 = tr[0].t; + const t1 = tr[tr.length - 1].t; + const px = (t) => 3 + ((t - t0) / Math.max(1, t1 - t0)) * (W - 6); + const py = (a) => H - 4 - ((a - lo) / Math.max(1, hi - lo)) * (H - 14); + const line = tr + .map( + (p, i) => + `${i ? 'L' : 'M'}${px(p.t).toFixed(1)} ${py(alts[i]).toFixed(1)}`, + ) + .join(''); + // Ground track, equirectangular around its centre. + const lons = tr.map((p) => p.lon); + const lats = tr.map((p) => p.lat); + const cl = Math.cos( + ((Math.min(...lats) + Math.max(...lats)) / 2) * (Math.PI / 180), + ); + const spanX = (Math.max(...lons) - Math.min(...lons)) * cl || 1e-6; + const spanY = Math.max(...lats) - Math.min(...lats) || 1e-6; + const S = 84; + const k = (S - 12) / Math.max(spanX, spanY); + const gx = (lon) => + S / 2 + (lon - (Math.min(...lons) + Math.max(...lons)) / 2) * cl * k; + const gy = (lat) => + S / 2 - (lat - (Math.min(...lats) + Math.max(...lats)) / 2) * k; + const g = tr + .map( + (p, i) => + `${i ? 'L' : 'M'}${gx(p.lon).toFixed(1)} ${gy(p.lat).toFixed(1)}`, + ) + .join(''); + const last = tr[tr.length - 1]; + const isOrbit = d.kind === 'satellite'; + return `

Track${tr.length} points · ${esc(utc(t0, { seconds: false }))} → ${esc(utc(t1, { seconds: false }))}

+
+
+ + +
${isOrbit ? 'ALT' : 'ALT PROFILE'}${esc(isOrbit ? `${fmtNum(Math.round(hi / 1000))} KM` : `${fmtNum(Math.round((hi * 3.28084) / 10) * 10)} FT MAX`)}
+
+
GROUND
+
`; +} + +export function createDossier({ + globe, + host, + onOpenSituation, + onOpenMoment, + onOpenRoom, + onShowOnTime, + watch, +}) { + const sheet = createSheet({ + host, + label: 'Dossier', + detents: ['medium', 'large'], + dismissible: true, + closeButton: true, + className: 'dossier-sheet', + heights: { + medium: (H) => Math.min(Math.round(H * 0.56), 560), + large: (H) => Math.round(H * 0.93), + }, + }); + let stack = []; + let d = null; + let seg = 'dossier'; + let graph = null; + let refreshTimer = 0; + let token = 0; + + sheet.on('close', () => { + clearInterval(refreshTimer); + graph?.destroy(); + graph = null; + globe.select(null); + stack = []; + d = null; + }); + + function headHtml() { + const band = bandOfKind(d.kind); + const status = d.illustrative + ? 'Illustrative' + : d.live && Date.now() - (d.live.updatedAt || 0) < 5 * 60e3 + ? 'Live' + : 'Recorded'; + return `
+ ${stack.length > 1 ? `` : ''} +
${esc(KIND_NAME[d.kind] || d.kind)}·${esc(BAND_NAME[band])}${status}
+
${icon(KIND_ICON[d.kind] || 'scope')}

${esc(d.title)}

${esc(d.subtitle || '')}
+
+ + +
`; + } + + function followKey() { + return d.kind === 'situation' ? d.id.replace(/^situation:/, '') : d.id; + } + + function bodyHtml() { + const rows = liveRows(d); + const followed = store.isFollowed(followKey()); + const ident = Object.entries(d.identity || {}).filter( + ([, v]) => v != null && v !== '', + ); + const L = d.live; + const isMoment = d.kind === 'moment'; + return ` + ${ + rows.length + ? `
${rows.map(([k, v, u]) => `
${esc(k)}${esc(v)}${esc(u)}
`).join('')}
+
${L?.updatedAt ? `UPDATED ${esc(ago(L.updatedAt).toUpperCase())}` : ''}${Number.isFinite(L?.lat) ? ` · ${esc(mgrs(L.lat, L.lon, 4) || llShort(L.lat, L.lon, 3))}` : ''}
` + : '' + } +
+ ${isMoment ? `` : ''} + + + + +
+ ${d.privacy ? `
${icon('lock')}Owner privacy (${esc(String(d.privacy).toUpperCase())}) Identity is limited to what the transponder broadcasts. We never name aircraft on privacy lists.
` : ''} + ${trackHtml(d)} + ${ident.length ? `

Identity

${ident.map(([k, v]) => `
${esc(ID_LABEL[k] || cap(k))}
${esc(v)}
`).join('')}
` : ''} + ${ + d.events?.length + ? `

Eventstap to see it on the time machine

    ${d.events + .slice(-8) + .map( + (e) => + `
    2. `, + ) + .join('')}
` + : '' + } + ${ + d.links?.length + ? `

Links${d.links.length} · things, places and events only

${d.links + .slice(0, 12) + .map( + (l) => + ``, + ) + .join('')}
` + : '' + } +

${icon('receipt')}Receiptsevery fact keeps its source

${( + d.sources || [] + ) + .map( + (s) => + `
${esc(s.name)}${esc(s.fetchedAt ? `fetched ${ago(s.fetchedAt)}` : '')}${s.url ? ` · ${esc(new URL(s.url, location.href).hostname)}` : ''}
`, + ) + .join('')}
+

${icon('lock')}We track things that broadcast publicly, public infrastructure and events. Never people: no person search, no faces.

`; + } + + async function show(ref, { push = true, detent } = {}) { + const my = ++token; + if (!sheet.isOpen) { + sheet.head.innerHTML = `
Opening dossier…

 

`; + sheet.body.innerHTML = ''; + sheet.open(detent || 'medium'); + } + const res = await globe.entity(ref); + if (my !== token) return; + if (!res) { + sheet.close(); + toast('No dossier for that yet', { icon: icon('info') }); + return; + } + d = res; + if (push) stack.push({ ref: d.id, title: d.title }); + render(); + if (detent) sheet.setDetent(detent); + sync(); + clearInterval(refreshTimer); + if (d.live && !d.illustrative) + refreshTimer = setInterval(async () => { + if (!sheet.isOpen || seg !== 'dossier') return; + const nd = await globe.entity(d.id); + if (!nd || nd.id !== d?.id) return; + d = { ...nd, links: d.links }; + const live = $('.ds-live', sheet.body); + if (live) + live.innerHTML = liveRows(d) + .map( + ([k, v, u]) => + `
${esc(k)}${esc(v)}${esc(u)}
`, + ) + .join(''); + $$('[data-ago]', sheet.body).forEach((el) => { + el.dataset.ago = d.live?.updatedAt; + el.textContent = ago(d.live?.updatedAt).toUpperCase(); + }); + }, 5000); + } + + function render() { + sheet.sheet.dataset.band = bandOfKind(d.kind); + sheet.sheet.dataset.seg = seg; + sheet.head.innerHTML = headHtml(); + graph?.destroy(); + graph = null; + if (seg === 'graph') { + sheet.body.innerHTML = + '

Drag a node · tap one to open its dossier

'; + graph = createLinkGraph($('.ds-graph', sheet.body), { + onOpen: (n) => { + haptic('light'); + seg = 'dossier'; + show(n.id); + }, + onSelect: (n) => selectOnGlobe(n), + }); + graph.set(globe.graph(d.id), d.id); + if (sheet.detent !== 'large') sheet.setDetent('large'); + } else { + sheet.body.innerHTML = bodyHtml(); + sheet.body.scrollTop = 0; + } + } + + /** One selection: the globe follows the dossier. */ + function sync() { + const L = d.live; + if (!L || !Number.isFinite(L.lat)) return; + // Historical (Moment) things are shown by the Moment player, not live. + if (d.illustrative && d.kind !== 'moment') return; + const raw = String(d.id).replace(/^[a-z]+:/, ''); + globe.select(raw); + const height = { + satellite: 2600e3, + aircraft: 60e3, + military: 80e3, + helicopter: 4000, + vessel: 30e3, + place: 6000, + capture: 2500, + moment: 3500, + camera: 3000, + quake: 400e3, + }[d.kind]; + if (height) + globe.flyTo({ + lon: L.lon, + lat: L.lat, + height, + pitch: -55, + duration: 1.8, + }); + } + function selectOnGlobe(n) { + globe.select(String(n.id).replace(/^[a-z]+:/, '')); + } + + sheet.head.addEventListener('click', (e) => { + const s = e.target.closest('[data-seg]'); + if (s && s.dataset.seg !== seg) { + haptic('tick'); + seg = s.dataset.seg; + render(); + return; + } + if (e.target.closest('.ds-back')) { + stack.pop(); + const prev = stack[stack.length - 1]; + if (prev) show(prev.ref, { push: false }); + } + }); + + sheet.body.addEventListener('click', async (e) => { + const link = e.target.closest('[data-link]'); + if (link) { + haptic('light'); + const id = link.dataset.link; + if (/^situation:/.test(id) && onOpenSituation) { + const ok = await onOpenSituation(id.replace(/^situation:/, ''), { + fromDossier: true, + }); + if (ok) return; + } + return show(id); + } + const ev = e.target.closest('[data-t]'); + if (ev) { + haptic('tick'); + onShowOnTime?.(d, Number(ev.dataset.t)); + return; + } + const hash = e.target.closest('[data-hash]'); + if (hash) { + try { + await navigator.clipboard.writeText(hash.dataset.hash); + toast('Hash copied', { icon: icon('receipt') }); + } catch { + toast(hash.dataset.hash.slice(0, 32), { icon: icon('receipt') }); + } + return; + } + const act = e.target.closest('[data-ds]')?.dataset.ds; + if (!act || !d) return; + haptic('light'); + if (act === 'follow') { + const on = store.toggleFollow(followKey()); + watch?.noteFollow?.(d, on); + toast(on ? `Following ${d.title}` : 'Unfollowed', { + icon: icon(on ? 'starFill' : 'star'), + }); + render(); + } else if (act === 'alert') watch?.ruleFor(d); + else if (act === 'room') onOpenRoom?.(d); + else if (act === 'time') onShowOnTime?.(d); + else if (act === 'play') onOpenMoment?.(d.id.replace(/^moment:/, '')); + }); + + // Picks on the globe highlight the same node in the graph. + globe.on('pick', (p) => { + if (!graph || !p) return; + const id = [ + ...[ + `flights:${p.id}`, + `military:${p.id}`, + `satellites:${p.id}`, + `vessels:${p.id}`, + `situation:${p.id}`, + String(p.id), + ], + ].find((x) => graph.has(x)); + if (id) graph.select(id); + }); + + return { + open: (ref, o = {}) => { + seg = o.graph ? 'graph' : 'dossier'; + stack = []; + return show(ref, { detent: o.detent || (o.graph ? 'large' : 'medium') }); + }, + close: () => sheet.close(), + get isOpen() { + return sheet.isOpen; + }, + get current() { + return d; + }, + sheet, + }; +} diff --git a/mobile/ui/feed.js b/mobile/ui/feed.js index 2be5bc270..e22af663e 100644 --- a/mobile/ui/feed.js +++ b/mobile/ui/feed.js @@ -110,16 +110,19 @@ export function createFeed( }, ) { view.innerHTML = ` -
Now -
+
Today +
-
-

Now

- +
+
+

Your world

+
Acquiring the planet…
+
+

Around the world

LIVE · EVERY BAND
${BANDS.map((b) => ``).join('')} @@ -150,16 +153,24 @@ export function createFeed( const now = new Date(); const u = utc(now); const hd = $('[data-utc]', view); - if (hd) hd.textContent = `${u} UTC`.replace('Z UTC', ' UTC'); + if (hd) hd.textContent = u; const dt = $('[data-date]', view); if (dt) dt.textContent = now .toLocaleDateString('en-GB', { - weekday: 'short', - day: '2-digit', - month: 'short', + weekday: 'long', + day: 'numeric', + month: 'long', }) .toUpperCase(); + const lt = $('[data-localtime]', view); + if (lt) { + const txt = now.toLocaleTimeString('en-US', { + hour: 'numeric', + minute: '2-digit', + }); + if (lt.textContent !== txt) lt.textContent = txt; + } if (view.hidden) return; $$('[data-clock]', fbody).forEach((el) => (el.textContent = u)); $$('[data-since]', fbody).forEach((el) => { @@ -206,7 +217,12 @@ export function createFeed( s, archetype: archetypeOf(s), band: bandOf(s), - prio: (s.severity || 0) * 10 - i * 0.6 + (s.live ? 2 : 0), + prio: + (s.severity || 0) * 10 - + i * 0.6 + + (s.live ? 2 : 0) + + // Detections from real data (circling, emergency squawks) lead. + (/circling|squawk|quake-cluster/.test(s.kind || '') ? 60 : 0), })); // The street is the most Citizen-like card: one live eye right after // the two most severe situations. @@ -214,6 +230,9 @@ export function createFeed( const eye = ranked.find((x) => x.archetype === 'eye'); if (eye && ranked[1] && ranked.indexOf(eye) > 2) eye.prio = ranked[1].prio - 0.1; + // A detection is the first card: never shuffled away by diversity. + for (const it of items) + if (/circling|squawk|quake-cluster/.test(it.s.kind || '')) it.lead = true; return items; } @@ -294,7 +313,9 @@ export function createFeed( let list = [...items, ...roomItems, ...wit]; if (band !== 'all') list = list.filter((x) => x.band === band); list.sort((a, b) => b.prio - a.prio); - return near ? list : diversify(list); + if (near) return list; + const lead = list.filter((x) => x.lead); + return [...lead, ...diversify(list.filter((x) => !x.lead))]; } /* ---------- layout ---------- */ @@ -763,8 +784,32 @@ export function createFeed( if (loc) globe.setViewer?.({ lon: loc.lon, lat: loc.lat }); } + /** Instant first frame: paint cached situations before the live call. */ + function prime(list) { + if (!Array.isArray(list) || !list.length || all.length) return false; + all = list; + render(); + count.textContent = `${count.textContent} · last good snapshot`; + return true; + } + let freshTimer = 0; + function markUpdated() { + const chip = $('.fresh-chip', view); + chip.textContent = 'Updated just now'; + chip.hidden = false; + chip.classList.remove('in'); + void chip.offsetWidth; + chip.classList.add('in'); + clearTimeout(freshTimer); + freshTimer = setTimeout(() => (chip.hidden = true), 4200); + } + return { load, + prime, + markUpdated, + briefSlot: $('.brief-slot', view), + titleEl: $('.today-title', view), refresh, render, refreshSocial: socialChanged, diff --git a/mobile/ui/globeChrome.js b/mobile/ui/globeChrome.js index 31e4d9abb..38acfaa97 100644 --- a/mobile/ui/globeChrome.js +++ b/mobile/ui/globeChrome.js @@ -19,7 +19,7 @@ import { import { createSheet } from './sheet.js'; import { createTimeRibbon } from './timeRibbon.js'; import { createEyeViewer } from './eyeViewer.js'; -import { BAND_NAME, llShort, mgrs } from './bands.js'; +import { BAND_NAME, BAND_COLOR, llShort, mgrs } from './bands.js'; /** Altitude → band: where the virtual sensor is. */ const bandAt = (h) => (h > 100e3 ? 'orbit' : h > 2500 ? 'sky' : 'ground'); @@ -79,6 +79,10 @@ export function createGlobeChrome({ getSituations, isTwoPane, onPin, + onClock, + onClip, + onTimelineEvent, + onPick, }) { const eyeViewer = createEyeViewer({ globe, @@ -174,7 +178,22 @@ export function createGlobeChrome({ const ribbon = createTimeRibbon(bottom, { getWindow: () => globe.timeWindow(), - onTime: (d) => globe.setTime(d), + onTime: (d) => { + // A playing Moment owns the clock until it closes. + if (globe.activeMoment()) return; + globe.setTime(d); + onClock?.(d); + }, + playback: globe.playback, + getHistory: () => globe.history(), + onClip: (r) => onClip?.(r), + onPip: (p) => onTimelineEvent?.(p.ev || p), + }); + // While the planet plays, the time machine (and everything else) follows. + globe.on('playback', (st) => { + if (!st || globe.activeMoment()) return; + ribbon.onPlayback(st); + onClock?.(ribbon.time); }); /* ---------- HTML labels (engine draws none; ≤ 40, DESIGN.md §5) ---------- */ @@ -588,6 +607,7 @@ export function createGlobeChrome({ if (onPin?.(p)) return; if (p.pinKind === 'eye') return nearestEye(p.lon, p.lat, p.title, 1); } + if (onPick?.(p)) return; if (p.kind === 'situation') { const s = (await getSituations()).find( (x) => String(x.id) === String(p.id), @@ -731,6 +751,17 @@ export function createGlobeChrome({ basePips = p || []; ribbon.setPips([...basePips, ...extraPips]); }, + /** Timeline events (globe.timeline()) become band-coloured pips. */ + setTimeline(evts) { + basePips = (evts || []).map((ev) => ({ + at: ev.t, + label: ev.title, + color: BAND_COLOR[ev.band] || '#fff', + severity: ev.severity || 0, + ev, + })); + ribbon.setPips([...basePips, ...extraPips]); + }, /** Room posts anchored in time (cleared with []). */ setExtraPips(p) { extraPips = p || []; diff --git a/mobile/ui/globeHost.js b/mobile/ui/globeHost.js index 6fb42b001..9ecb5521b 100644 --- a/mobile/ui/globeHost.js +++ b/mobile/ui/globeHost.js @@ -7,6 +7,8 @@ * the shell down; mismatches are collected in `contractReport` for the lead. */ +import { installRound3 } from './shim3.js'; + const REQUIRED = [ 'flyTo', 'home', @@ -38,6 +40,28 @@ const ROUND_TWO = [ 'eyeFrameUrl', ]; +/** Round-three additions (mobile/globe/API.md, "Round three"), optional. */ +const ROUND_THREE = [ + 'history', + 'trackOf', + 'timeline', + 'detections', + 'moments', + 'moment', + 'momentOfTheDay', + 'playMoment', + 'exitMoment', + 'activeMoment', + 'seekMoment', + 'entity', + 'search', + 'graph', + 'react', + 'attentionHeat', + 'skyNow', + 'cachedThumbnail', +]; + export const contractReport = { engine: 'none', missing: [], @@ -166,6 +190,71 @@ function guard(engine, kind) { }, project: (lon, lat, alt) => call('project', null, lon, lat, alt), time: () => call('time', null), + + /* ---- round three (API.md); the shell fills gaps with shim3.js ---- */ + situationsCached: async () => { + const v = await asyncCall('situations', [], { cached: true }); + return Array.isArray(v) ? v.map(normSituation) : []; + }, + cachedThumbnail: (s) => call('cachedThumbnail', null, s), + history: () => call('history', null), + trackOf: (id) => asyncCall('trackOf', [], id), + playback: { + play: (o) => { + try { + engine.playback?.play?.(o); + } catch (err) { + note(`playback.play(): ${err?.message || err}`); + } + }, + stop: () => { + try { + engine.playback?.stop?.(); + } catch (err) { + note(`playback.stop(): ${err?.message || err}`); + } + }, + state: () => { + try { + return ( + engine.playback?.state?.() || { playing: false, speed: 1, t: null } + ); + } catch { + return { playing: false, speed: 1, t: null }; + } + }, + }, + timeline: (o) => { + const v = call('timeline', [], o); + return Array.isArray(v) ? v : []; + }, + detections: () => { + const v = call('detections', []); + return Array.isArray(v) ? v.map(normSituation) : []; + }, + moments: async () => { + const v = await asyncCall('moments', []); + return Array.isArray(v) ? v : []; + }, + moment: (id) => asyncCall('moment', null, id), + momentOfTheDay: () => asyncCall('momentOfTheDay', null), + playMoment: (m, o) => asyncCall('playMoment', null, m, o), + exitMoment: () => call('exitMoment', undefined), + activeMoment: () => call('activeMoment', null), + seekMoment: (t) => call('seekMoment', undefined, t), + entity: (ref) => asyncCall('entity', null, ref), + search: async (q) => { + const v = await asyncCall('search', [], q); + return Array.isArray(v) ? v : []; + }, + graph: (ref) => { + const v = call('graph', null, ref); + return v && Array.isArray(v.nodes) ? v : { nodes: [], edges: [] }; + }, + react: (o) => call('react', undefined, o), + attentionHeat: (p) => call('attentionHeat', undefined, p), + skyNow: (o) => asyncCall('skyNow', null, o), + addClip: (m) => call('_addClip', undefined, m), }; } @@ -196,6 +285,15 @@ export async function mountGlobe(container, opts = {}) { opts.quality === 'battery' ? 'low' : opts.quality || 'auto'; const engine = await create(container, { quality }); contractReport.engine = 'cesium'; + contractReport.roundThree = Object.fromEntries( + ROUND_THREE.map((m) => [ + m, + typeof engine?.[m] === 'function' ? 'native' : 'shim', + ]), + ); + contractReport.roundThree.playback = + typeof engine?.playback?.play === 'function' ? 'native' : 'shim'; + installRound3(engine, { kind: 'cesium' }); contractReport.missing = REQUIRED.filter( (m) => typeof engine?.[m] !== 'function', ); @@ -222,6 +320,7 @@ export async function mountGlobe(container, opts = {}) { quality: opts.quality || 'auto', }); contractReport.engine = 'stub'; + contractReport.roundThree = 'stub (shim3 + native stub recorder)'; contractReport.roundTwo = Object.fromEntries( ROUND_TWO.map((m) => [m, typeof engine?.[m] === 'function']), ); diff --git a/mobile/ui/globeStub.js b/mobile/ui/globeStub.js index e2b4c20f3..cc949c8c1 100644 --- a/mobile/ui/globeStub.js +++ b/mobile/ui/globeStub.js @@ -14,12 +14,13 @@ import { camFrameUrl, } from './stubSituations.js'; import { stubThumbnail } from './stubCompositor.js'; +import { installRound3 } from './shim3.js'; const R_EARTH = 6371008.8; const D2R = Math.PI / 180; const R2D = 180 / Math.PI; const FOV_HALF = Math.tan(20 * D2R); -const MIN_H = 60e3; +const MIN_H = 1500; const MAX_H = 42000e3; const HOME = { lon: 20, lat: 18, height: 15500e3 }; @@ -719,7 +720,18 @@ export async function createGlobe(container, options = {}) { const radiusPx = (height = cam.height) => { const d = R_EARTH + height; const tanT = R_EARTH / Math.sqrt(d * d - R_EARTH * R_EARTH); - return (tanT / FOV_HALF) * (Math.min(W, H) / 2) * 1.05; + const half = Math.min(W, H) / 2; + const sil = (tanT / FOV_HALF) * half * 1.05; + // Close in, the silhouette fit under-zooms badly (a 2.5 km camera saw + // 200 km). Blend toward the true nadir scale below 1,000 km so a city + // block reads at street altitude (Moments orbit at 400–700 m). + const nadir = (R_EARTH / (Math.max(1, height) * FOV_HALF)) * half; + if (nadir <= sil) return sil; + const k = Math.min( + 1, + Math.max(0, Math.log(1000e3 / height) / Math.log(1000e3 / 30e3)), + ); + return sil * (nadir / sil) ** k; }; function basis() { const lo = cam.lon * D2R; @@ -1041,7 +1053,17 @@ export async function createGlobe(container, options = {}) { } drawWeather(ts); drawPins(ts); + for (const fn of hooks) { + try { + fn(ctx, { project, t, ts, W, H, cam }); + } catch (err) { + console.warn('[stub] overlay hook failed', err); + hooks.delete(fn); + } + } } + /** Round three: shell overlays (Moment trails, reactions) draw here. */ + const hooks = new Set(); /* ---------- weather (simulated look of the engine's weather family) ---------- */ const wx = (() => { @@ -1658,12 +1680,85 @@ export async function createGlobe(container, options = {}) { } return out; }, + /* ---- round three (API.md): native stub pieces; the rest via shim3 ---- */ + _hook(fn) { + hooks.add(fn); + kick(); + return () => hooks.delete(fn); + }, + history() { + const n = Date.now(); + const pts = contacts.length * 720; + return { + start: n - 6 * 3600e3, + end: n, + entities: contacts.length, + points: pts, + }; + }, + async trackOf(id) { + const raw = String(id).replace(/^[a-z]+:/, ''); + const c = contacts.find((x) => String(x.id) === raw); + if (!c) return []; + const t = Math.max(now(), Date.now()); + const out = []; + const probe = { ...c, base: c.base, orbit: c.orbit }; + // The simulated recorder: six hours at one point a minute. + for (let i = 360; i >= 0; i -= 1) { + const ti = t - i * 60e3; + propagate(probe, t0, ti); + out.push({ + t: ti, + lon: probe.lon, + lat: probe.lat, + altM: + c.kind === 'satellite' + ? c.altM + : Math.max(0, (c.altM || 0) + Math.sin(i / 9) * 90), + headingDeg: probe.headingDeg, + speed: c.speed, + }); + } + propagate(c, t0, t); + return out; + }, + /** Next ISS pass over a point: sampled every 30 s for 24 h, el > 10°. */ + _issPass(lon, lat) { + const iss = contacts.find((c) => c.id === 'iss'); + if (!iss) return null; + const probe = { ...iss }; + const Re = R_EARTH; + const elev = (ti) => { + propagate(probe, t0, ti); + const d = haversine(lon, lat, probe.lon, probe.lat); + const th = d / Re; + return ( + Math.atan2(Math.cos(th) - Re / (Re + iss.altM), Math.sin(th)) * R2D + ); + }; + const start = Date.now(); + let pass = null; + for (let ti = start; ti < start + 24 * 3600e3; ti += 30e3) { + const e = elev(ti); + if (e > 10 && !pass) pass = { start: ti, max: ti, maxElevationDeg: e }; + else if (pass && e > 10 && e > pass.maxElevationDeg) { + pass.max = ti; + pass.maxElevationDeg = e; + } else if (pass && e <= 10) { + pass.end = ti; + break; + } + } + if (pass) pass.maxElevationDeg = Math.round(pass.maxElevationDeg); + return pass; + }, destroy() { api.pause(); ro.disconnect(); root.remove(); }, }; + installRound3(api, { kind: 'stub', historyHours: 6 }); kick(); setTimeout( () => diff --git a/mobile/ui/icons.js b/mobile/ui/icons.js index 8b703355e..95cd8e9e0 100644 --- a/mobile/ui/icons.js +++ b/mobile/ui/icons.js @@ -95,6 +95,19 @@ const P = { sendUp: ``, dot: ``, hand: ``, + today: ``, + rooms: ``, + bell: ``, + graph: ``, + dome: ``, + heli: ``, + satellite: ``, + building: ``, + film: ``, + scissors: ``, + receipt: ``, + director: ``, + forward: ``, }; /** diff --git a/mobile/ui/linkGraph.js b/mobile/ui/linkGraph.js new file mode 100644 index 000000000..b15afe82f --- /dev/null +++ b/mobile/ui/linkGraph.js @@ -0,0 +1,360 @@ +/** + * Link graph (DESIGN.md §12.1): a hand-written force-directed graph of + * globe.graph(ref), ≤ 40 nodes, on one canvas. Nodes are coloured by + * altitude band, the root is larger, edges carry their relation on hover. + * Drag a node to pull the graph; tap a node to open its dossier. Selection + * is shared with the globe through `select(id)`. + */ + +import { BAND_COLOR } from './bands.js'; +import { bandOfKind } from './shim3.js'; +import { reducedMotion } from './dom.js'; + +const KIND_GLYPH = { + aircraft: '✈', + helicopter: 'H', + military: '✈', + satellite: '◆', + vessel: '⛴', + quake: '◎', + camera: '◉', + situation: '!', + place: '⌖', + moment: '▶', + track: '·', + capture: '◐', +}; + +export function createLinkGraph(host, { onOpen, onSelect } = {}) { + const wrap = document.createElement('div'); + wrap.className = 'lg'; + wrap.innerHTML = `
OrbitSkyGroundInside
`; + host.appendChild(wrap); + const canvas = wrap.querySelector('canvas'); + const tip = wrap.querySelector('.lg-tip'); + const ctx = canvas.getContext('2d'); + let W = 0; + let H = 0; + let dpr = 1; + let nodes = []; + let edges = []; + let rootId = null; + let selected = null; + let hover = null; + let alpha = 1; + let raf = 0; + let dragN = null; + let destroyed = false; + + function resize() { + const r = wrap.getBoundingClientRect(); + dpr = Math.min(2, window.devicePixelRatio || 1); + W = r.width; + H = r.height; + canvas.width = Math.round(W * dpr); + canvas.height = Math.round(H * dpr); + kick(0.3); + } + const ro = new ResizeObserver(resize); + ro.observe(wrap); + + function set(graph, root) { + rootId = root; + const prev = new Map(nodes.map((n) => [n.id, n])); + const deg = new Map(); + for (const e of graph.edges) { + deg.set(e.from, (deg.get(e.from) || 0) + 1); + deg.set(e.to, (deg.get(e.to) || 0) + 1); + } + nodes = graph.nodes.slice(0, 40).map((n, i) => { + const p = prev.get(n.id); + const a = (i / Math.max(1, graph.nodes.length)) * Math.PI * 2; + const isRoot = n.id === root; + return { + ...n, + band: bandOfKind(n.kind), + r: isRoot ? 15 : 7 + Math.min(5, (deg.get(n.id) || 1) * 0.9), + x: p?.x ?? (isRoot ? 0 : Math.cos(a) * 90), + y: p?.y ?? (isRoot ? 0 : Math.sin(a) * 90), + vx: 0, + vy: 0, + root: isRoot, + }; + }); + const idx = new Map(nodes.map((n, i) => [n.id, i])); + edges = graph.edges + .filter((e) => idx.has(e.from) && idx.has(e.to)) + .map((e) => ({ + ...e, + a: nodes[idx.get(e.from)], + b: nodes[idx.get(e.to)], + })); + kick(1); + } + + function kick(a = 0.6) { + alpha = Math.max(alpha, a); + if (!raf && !destroyed) raf = requestAnimationFrame(tick); + } + + function step() { + const k = 1; + // Repulsion + for (let i = 0; i < nodes.length; i += 1) { + const a = nodes[i]; + for (let j = i + 1; j < nodes.length; j += 1) { + const b = nodes[j]; + let dx = b.x - a.x; + let dy = b.y - a.y; + let d2 = dx * dx + dy * dy; + if (d2 < 0.01) { + dx = Math.random() - 0.5; + dy = Math.random() - 0.5; + d2 = 0.5; + } + const f = (4200 * k) / d2; + const d = Math.sqrt(d2); + a.vx -= (dx / d) * f; + a.vy -= (dy / d) * f; + b.vx += (dx / d) * f; + b.vy += (dy / d) * f; + } + } + // Springs + for (const e of edges) { + const dx = e.b.x - e.a.x; + const dy = e.b.y - e.a.y; + const d = Math.max(0.01, Math.hypot(dx, dy)); + const rest = e.a.root || e.b.root ? 120 : 80; + const f = (d - rest) * 0.035; + e.a.vx += (dx / d) * f; + e.a.vy += (dy / d) * f; + e.b.vx -= (dx / d) * f; + e.b.vy -= (dy / d) * f; + } + for (const n of nodes) { + // Gravity to the centre; the root is pinned there. + n.vx -= n.x * 0.012; + n.vy -= n.y * 0.012; + if (n.root && n !== dragN) { + n.x *= 0.8; + n.y *= 0.8; + n.vx = 0; + n.vy = 0; + continue; + } + if (n === dragN) continue; + n.vx *= 0.62; + n.vy *= 0.62; + n.x += n.vx * alpha; + n.y += n.vy * alpha; + } + } + + function view() { + // Fit the graph into the canvas with padding. + let minX = -60; + let maxX = 60; + let minY = -60; + let maxY = 60; + for (const n of nodes) { + minX = Math.min(minX, n.x - n.r); + maxX = Math.max(maxX, n.x + n.r); + minY = Math.min(minY, n.y - n.r); + maxY = Math.max(maxY, n.y + n.r); + } + const pad = 46; + const s = Math.min( + 2.2, + (W - pad * 2) / (maxX - minX), + (H - pad * 2) / (maxY - minY), + ); + return { + s, + cx: W / 2 - ((minX + maxX) / 2) * s, + cy: H / 2 - ((minY + maxY) / 2) * s, + }; + } + let V = { s: 1, cx: 0, cy: 0 }; + const sx = (n) => V.cx + n.x * V.s; + const sy = (n) => V.cy + n.y * V.s; + + function draw() { + ctx.setTransform(dpr, 0, 0, dpr, 0, 0); + ctx.clearRect(0, 0, W, H); + V = view(); + const focus = hover || selected || rootId; + const relFocus = hover || selected; + const near = new Set(); + if (focus) + for (const e of edges) { + if (e.a.id === focus) near.add(e.b.id); + if (e.b.id === focus) near.add(e.a.id); + } + // Edges + for (const e of edges) { + const hot = focus && (e.a.id === focus || e.b.id === focus); + ctx.strokeStyle = hot + ? 'rgba(255,255,255,0.7)' + : 'rgba(255,255,255,0.16)'; + ctx.lineWidth = hot ? 1.4 : 1; + ctx.beginPath(); + ctx.moveTo(sx(e.a), sy(e.a)); + ctx.lineTo(sx(e.b), sy(e.b)); + ctx.stroke(); + if (hot && e.relation && relFocus) { + const mx = (sx(e.a) + sx(e.b)) / 2; + const my = (sy(e.a) + sy(e.b)) / 2; + ctx.font = '600 9px "JetBrains Mono", ui-monospace, monospace'; + const w = ctx.measureText(e.relation.toUpperCase()).width; + ctx.fillStyle = 'rgba(8,10,14,0.85)'; + ctx.fillRect(mx - w / 2 - 4, my - 7, w + 8, 14); + ctx.fillStyle = 'rgba(255,255,255,0.75)'; + ctx.textAlign = 'center'; + ctx.fillText(e.relation.toUpperCase(), mx, my + 3); + } + } + // Nodes + for (const n of nodes) { + const x = sx(n); + const y = sy(n); + const col = BAND_COLOR[n.band] || '#fff'; + const dim = focus && focus !== n.id && !near.has(n.id) && !n.root; + ctx.globalAlpha = dim ? 0.35 : 1; + if (n.id === selected || n.root) { + ctx.fillStyle = `${col}33`; + ctx.beginPath(); + ctx.arc(x, y, n.r + 7, 0, Math.PI * 2); + ctx.fill(); + } + ctx.fillStyle = n.root ? col : '#0b0d11'; + ctx.strokeStyle = col; + ctx.lineWidth = n.root ? 0 : 2; + ctx.beginPath(); + ctx.arc(x, y, n.r, 0, Math.PI * 2); + ctx.fill(); + if (!n.root) ctx.stroke(); + ctx.fillStyle = n.root ? '#0b0d11' : col; + ctx.font = `700 ${n.root ? 13 : 9}px system-ui, sans-serif`; + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(KIND_GLYPH[n.kind] || '•', x, y + 0.5); + ctx.textBaseline = 'alphabetic'; + const showLabel = + n.root || n.id === focus || near.has(n.id) || nodes.length <= 14; + if (showLabel) { + const short = n.root ? n.title : String(n.title).split(' · ')[0]; + const label = short.length > 22 ? `${short.slice(0, 21)}…` : short; + ctx.font = `${n.root ? 650 : 550} ${n.root ? 12 : 10.5}px system-ui, sans-serif`; + ctx.fillStyle = n.root ? '#fff' : 'rgba(235,241,250,0.85)'; + ctx.fillText(label, x, y + n.r + 13); + } + ctx.globalAlpha = 1; + } + } + + function tick() { + raf = 0; + if (destroyed) return; + const steps = reducedMotion() ? 60 : alpha > 0.4 ? 6 : 2; + for (let i = 0; i < steps && alpha > 0.01; i += 1) { + step(); + alpha *= reducedMotion() ? 0.92 : 0.985; + } + draw(); + if (alpha > 0.01 || dragN) raf = requestAnimationFrame(tick); + } + + function hit(e) { + const r = canvas.getBoundingClientRect(); + const px = e.clientX - r.left; + const py = e.clientY - r.top; + let best = null; + let bd = 22; + for (const n of nodes) { + const d = Math.hypot(sx(n) - px, sy(n) - py) - n.r; + if (d < bd) { + bd = d; + best = n; + } + } + return { n: best, px, py }; + } + + let down = null; + canvas.addEventListener('pointerdown', (e) => { + const { n, px, py } = hit(e); + down = { n, px, py, moved: false }; + if (n) { + dragN = n; + canvas.setPointerCapture(e.pointerId); + } + }); + canvas.addEventListener('pointermove', (e) => { + if (down?.n) { + const r = canvas.getBoundingClientRect(); + const px = e.clientX - r.left; + const py = e.clientY - r.top; + if (Math.hypot(px - down.px, py - down.py) > 4) down.moved = true; + if (down.moved) { + down.n.x = (px - V.cx) / V.s; + down.n.y = (py - V.cy) / V.s; + kick(0.4); + } + return; + } + if (e.pointerType === 'mouse') { + const { n } = hit(e); + const id = n?.id || null; + if (id !== hover) { + hover = id; + canvas.style.cursor = id ? 'pointer' : 'default'; + if (n) { + tip.hidden = false; + tip.textContent = `${n.kind.toUpperCase()} · ${n.title}`; + tip.style.transform = `translate(${Math.round(sx(n))}px, ${Math.round(sy(n) - n.r - 30)}px) translateX(-50%)`; + } else tip.hidden = true; + draw(); + } + } + }); + const up = () => { + if (!down) return; + const d = down; + down = null; + dragN = null; + if (d.n && !d.moved) { + selected = d.n.id; + draw(); + onSelect?.(d.n); + if (!d.n.root) onOpen?.(d.n); + } + }; + canvas.addEventListener('pointerup', up); + canvas.addEventListener('pointercancel', up); + canvas.addEventListener('pointerleave', () => { + if (hover) { + hover = null; + tip.hidden = true; + draw(); + } + }); + + return { + set, + select(id) { + selected = id; + draw(); + }, + has: (id) => nodes.some((n) => n.id === id), + get size() { + return nodes.length; + }, + destroy() { + destroyed = true; + cancelAnimationFrame(raf); + ro.disconnect(); + wrap.remove(); + }, + }; +} diff --git a/mobile/ui/moment.js b/mobile/ui/moment.js new file mode 100644 index 000000000..12d6e0a4e --- /dev/null +++ b/mobile/ui/moment.js @@ -0,0 +1,704 @@ +/** + * The Moments player (DESIGN.md §12.4): a cinematic, full-screen replay of a + * 4D reconstruction. The globe plays the Moment (globe.playMoment); a scrubber + * covers just the Moment's window; captures pop in at their times with their + * First-eyes byline, seal and view cone; the chat replays beside it (the + * social agent's chatOverlay when present); record posts appear as they were + * made; a legend reads each track's callsign, operator, altitude and speed. + * + * On a phone it is an overlay on the globe; on a tablet the chat, captures and + * record move to the leading pane and the globe keeps the trailing pane. + */ + +import { icon } from './icons.js'; +import { + $, + $$, + h, + esc, + haptic, + toast, + clamp, + esriThumb, + reducedMotion, + emitter, +} from './dom.js'; +import { utc, fmtKm } from './bands.js'; +import { trackAt } from './stubMoments.js'; +import { social } from './socialBridge.js'; + +const TRACK_COL = [ + '#a3d8ff', + '#ffd27a', + '#ff9db0', + '#9be15d', + '#b39dff', + '#7cf0d0', +]; +const SPEEDS = [1, 10, 30, 60]; + +const KIND = { + witness: ['witness', 'Witness'], + context: ['context', 'Context'], + question: ['question', 'Question'], + correction: ['correction', 'Correction'], + prediction: ['prediction', 'Prediction'], + synthesis: ['sparkles', 'Clerk · synthesis'], +}; + +const BADGE = { + 'first-eyes': ['First eyes', 'seal'], + witness: ['Was there', 'witness'], + pilot: ['Pilot', 'sky'], + local: ['Local', 'pin'], + mod: ['Mod', 'checkmark'], +}; + +const at = (h) => + !h || h.startsWith('@') || h === 'Clerk' || h === 'Record' ? h : `@${h}`; + +/** The engine's Moment and the shell's share one shape after this. */ +export function normMoment(m) { + const subject = m.subject || { lon: m.lon, lat: m.lat }; + const R = 6371008.8; + const dist = (a) => { + const dLat = ((subject.lat - a.lat) * Math.PI) / 180; + const dLon = ((subject.lon - a.lon) * Math.PI) / 180; + const x = + Math.sin(dLat / 2) ** 2 + + Math.cos((a.lat * Math.PI) / 180) * + Math.cos((subject.lat * Math.PI) / 180) * + Math.sin(dLon / 2) ** 2; + return 2 * R * Math.asin(Math.min(1, Math.sqrt(x))); + }; + return { + ...m, + subject, + tracks: (m.tracks || []).map((tr) => ({ + ...tr, + arriveAt: tr.arriveAt ?? tr.points?.find((p) => dist(p) < 900)?.t, + })), + captures: (m.captures || []).map((c) => ({ + ...c, + handle: at(c.handle), + where: c.where || c.place || '', + media: c.media || c.kind || 'photo', + live: c.live || c.kind === 'live', + distanceM: c.distanceM ?? c.rangeM ?? Math.round(dist(c)), + })), + chat: (m.chat || []).map((c) => ({ ...c, handle: at(c.handle) })), + posts: (m.posts || []).map((p) => ({ + ...p, + handle: at(p.handle), + votes: + typeof p.votes === 'number' + ? { corroborate: p.votes, dispute: 0 } + : p.votes || { corroborate: 0, dispute: 0 }, + })), + }; +} + +/** A capture's thumbnail: the place, with its view cone toward the subject. */ +export function coneThumb(c, m, { w = 168, hgt = 120 } = {}) { + const span = 0.006; + const mPerPx = (span * 111320 * (hgt / w)) / hgt; + const len = clamp((c.distanceM || 250) / mPerPx, 26, w * 0.7); + const a = ((c.headingDeg || 0) - 90) * (Math.PI / 180); + const f = ((c.fovDeg || 52) / 2) * (Math.PI / 180); + const cx = w / 2; + const cy = hgt / 2; + const p1 = [cx + len * Math.cos(a - f), cy + len * Math.sin(a - f)]; + const p2 = [cx + len * Math.cos(a + f), cy + len * Math.sin(a + f)]; + const tx = cx + len * 0.92 * Math.cos(a); + const ty = cy + len * 0.92 * Math.sin(a); + return ` + + `; +} + +export function createMomentPlayer({ + app, + globe, + onExit, + onOpenEntity, + onOpenRoom, + isTwoPane, +}) { + const ev = emitter(); + const el = h(``); + app.appendChild(el); + const legend = $('.mp-legend', el); + const pops = $('.mp-pops', el); + const scrub = $('.mp-scrub', el); + const canvas = $('canvas', scrub); + const sctx = canvas.getContext('2d'); + const chatEl = $('.mp-chat', el); + const recEl = $('.mp-record', el); + const capsEl = $('.mp-caps', el); + + let m = null; + let raf = 0; + let t = 0; + let speed = 30; + let shown = { chat: 0, posts: 0, caps: 0 }; + let ext = null; // social chatOverlay + let seg = 'chat'; + let wasPlaying = false; + let reactCooldown = 0; + let offOwn = null; + + /* ---------- rendering pieces ---------- */ + const rel = (ms) => { + const s = Math.max(0, Math.round((ms - m.time.start) / 1000)); + return `+${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`; + }; + + function legendHtml() { + return (m.tracks || []) + .map( + ( + tr, + i, + ) => ``, + ) + .join(''); + } + + function capCard(c, { pop = false } = {}) { + const fe = c.firstEyes; + return ``; + } + + function chatHtml(c) { + const b = c.badge && BADGE[c.badge]; + return `
${b ? `${icon(b[1])}` : ''}${esc(c.handle)} ${esc(c.text)}
`; + } + + function postHtml(p) { + const k = KIND[p.kind] || KIND.context; + return `
${icon(k[0])}${esc(k[1])}${esc(utc(p.t, { seconds: false }))}
+

${esc(p.handle)} ${esc(p.text)}

+ ${p.kind !== 'synthesis' ? `
${icon('agree')}${p.votes?.corroborate ?? 0} corroborate${icon('dispute')}${p.votes?.dispute ?? 0} dispute${p.captureId ? `` : ''}
` : '
AI synthesis · cites 5 captures and 37 messages
'}
`; + } + + function drawScrub() { + const r = scrub.getBoundingClientRect(); + const dpr = Math.min(2, window.devicePixelRatio || 1); + const W = r.width; + const H = r.height; + if (canvas.width !== Math.round(W * dpr)) { + canvas.width = Math.round(W * dpr); + canvas.height = Math.round(H * dpr); + } + sctx.setTransform(dpr, 0, 0, dpr, 0, 0); + sctx.clearRect(0, 0, W, H); + const s = m.time.start; + const e = m.time.end; + const x = (ms) => 6 + ((ms - s) / (e - s)) * (W - 12); + const mid = H / 2 + 6; + // Chat density (a quiet histogram). + const bins = new Array(60).fill(0); + for (const c of m.chat || []) + bins[Math.min(59, Math.floor(((c.t - s) / (e - s)) * 60))] += 1; + const peak = Math.max(1, ...bins); + sctx.fillStyle = 'rgba(255,255,255,0.12)'; + bins.forEach((b, i) => { + const bh = (b / peak) * 12; + sctx.fillRect( + 6 + (i / 60) * (W - 12), + mid - 6 - bh, + (W - 12) / 60 - 1, + bh, + ); + }); + // Track and progress + sctx.fillStyle = 'rgba(255,255,255,0.14)'; + sctx.fillRect(6, mid - 1.5, W - 12, 3); + sctx.fillStyle = '#fff'; + sctx.fillRect(6, mid - 1.5, x(t) - 6, 3); + // Arrivals, captures and posts + // Beats (the story's chapters), else arrivals. + const beats = m.beats?.length + ? m.beats.map((b) => b.t) + : (m.tracks || []).map((tr) => tr.arriveAt).filter(Boolean); + for (const bt of beats) { + sctx.fillStyle = + bt <= t ? 'rgba(163,216,255,0.95)' : 'rgba(163,216,255,0.4)'; + sctx.fillRect(x(bt) - 1, mid - 9, 2, 18); + } + for (const p of m.posts || []) { + sctx.fillStyle = + p.t <= t ? 'rgba(255,255,255,0.9)' : 'rgba(255,255,255,0.35)'; + sctx.beginPath(); + sctx.arc(x(p.t), mid + 9, 2, 0, Math.PI * 2); + sctx.fill(); + } + for (const c of m.captures || []) { + sctx.fillStyle = c.t <= t ? '#ebc777' : 'rgba(235,199,119,0.4)'; + sctx.beginPath(); + sctx.arc(x(c.t), mid, c.firstEyes ? 5 : 3.6, 0, Math.PI * 2); + sctx.fill(); + sctx.strokeStyle = '#08090b'; + sctx.lineWidth = 1.2; + sctx.stroke(); + } + $('.mp-head', el).style.transform = `translateX(${x(t)}px)`; + } + + /* ---------- the clock ---------- */ + function sync(force = false) { + const nc = (m.chat || []).filter((c) => c.t <= t).length; + const np = (m.posts || []).filter((p) => p.t <= t).length; + const caps = (m.captures || []).filter((c) => c.t <= t); + const nk = caps.length; + // Seeking back re-renders; playing forward appends with a pop. + // The social overlay replays the raw chat by the clock itself. + if (ext) { + try { + ext.setTime?.(t); + } catch { + /* ignore */ + } + } + if (force || nc < shown.chat) { + chatEl.innerHTML = + (m.chat || []) + .filter((c) => c.t <= t) + .slice(-40) + .map(chatHtml) + .join('') || + `

${(m.chat || []).length ? 'The chat starts as the Moment does' : 'No chat was recorded in this window'}

`; + } else + for (const c of (m.chat || []).slice(shown.chat, nc)) { + chatEl.querySelector('.mp-empty')?.remove(); + chatEl.insertAdjacentHTML('beforeend', chatHtml(c)); + const last = chatEl.lastElementChild; + last.classList.add('in'); + while (chatEl.children.length > 60) chatEl.firstElementChild.remove(); + // Reactions in chat rise from the city on the globe. + const k = /❤️|🙏|♥/.test(c.text) + ? 'heart' + : /🔥/.test(c.text) + ? 'fire' + : /👀/.test(c.text) + ? 'eyes' + : /😮|wild|wow/i.test(c.text) + ? 'wow' + : null; + if (k) burst(k, 4); + } + if (force || np < shown.posts) + recEl.innerHTML = + (m.posts || []) + .filter((p) => p.t <= t) + .map(postHtml) + .reverse() + .join('') || emptyRec(); + else + for (const p of (m.posts || []).slice(shown.posts, np)) { + recEl.querySelector('.mp-empty')?.remove(); + recEl.insertAdjacentHTML('afterbegin', postHtml(p)); + recEl.firstElementChild.classList.add('in'); + } + if (force || nk < shown.caps) { + capsEl.innerHTML = + caps + .map((c) => capCard(c)) + .reverse() + .join('') || + '

Captures appear here at the moment they were sealed

'; + // After a seek, the latest capture stays pinned (settled) for context. + pops.innerHTML = caps.length + ? capCard(caps[caps.length - 1]).replace( + 'class="mp-cap ', + 'class="mp-cap settled ', + ) + : ''; + } else + for (const c of caps.slice(shown.caps)) { + capsEl.querySelector('.mp-empty')?.remove(); + capsEl.insertAdjacentHTML('afterbegin', capCard(c)); + popCapture(c); + } + if (nc !== shown.chat && seg === 'chat') { + const pane = chatEl.parentElement; + pane.scrollTop = pane.scrollHeight; + } + shown = { chat: nc, posts: np, caps: nk }; + $('[data-n="chat"]', el).textContent = nc ? ` ${nc}` : ''; + $('[data-n="record"]', el).textContent = np ? ` ${np}` : ''; + $('[data-n="captures"]', el).textContent = nk ? ` ${nk}` : ''; + // Legend: live per-track readouts. + (m.tracks || []).forEach((tr) => { + const row = legend.querySelector(`[data-track="${CSS.escape(tr.id)}"]`); + if (!row) return; + const p = trackAt(tr, t); + row.classList.toggle('absent', !p); + $('[data-alt]', row).textContent = p + ? `${Math.round((p.altM * 3.28084) / 10) * 10} FT` + : '—'; + $('[data-spd]', row).textContent = !p + ? 'NOT YET' + : p.speedMps + ? `${Math.round(p.speedMps * 1.94384)} KT` + : 'LANDED'; + }); + $('.mp-utc', el).textContent = utc(t); + $('.mp-rel', el).textContent = `${rel(t)} / ${rel(m.time.end)}`; + drawScrub(); + } + + const emptyRec = () => + '

Record posts appear as they were made

'; + + function popCapture(c) { + const card = h(capCard(c, { pop: true })); + pops.prepend(card); + haptic(c.firstEyes ? 'seal' : 'light'); + while (pops.children.length > (isTwoPane() ? 3 : 1)) + pops.lastElementChild.remove(); + setTimeout(() => card.classList.add('settle'), 4200); + } + + function burst(kind, count = 3) { + const now = performance.now(); + if (now - reactCooldown < 200) return; + reactCooldown = now; + const jitter = () => (Math.random() - 0.5) * 0.01; + globe.react({ + lon: (m.lon ?? 0) + jitter(), + lat: (m.lat ?? 0) + jitter(), + kind, + count, + }); + } + + function loop() { + raf = 0; + if (!m) return; + const a = globe.activeMoment(); + const st = globe.playback.state(); + const nt = Number.isFinite(a?.t) ? a.t : Number.isFinite(st?.t) ? st.t : t; + if (nt !== t) { + t = clamp(nt, m.time.start, m.time.end); + sync(); + } + setPlayingUi(!!(a?.playing ?? st?.playing)); + raf = requestAnimationFrame(loop); + } + + function setPlayingUi(p) { + if (el.classList.contains('playing') === p) return; + el.classList.toggle('playing', p); + $('.mp-play', el).innerHTML = icon(p ? 'pause' : 'play'); + $('.mp-play', el).setAttribute('aria-label', p ? 'Pause' : 'Play'); + } + + /* ---------- open / close ---------- */ + async function open( + idOrMoment, + { at: atT = null, speed: s = null, autoplay = true } = {}, + ) { + const raw = + typeof idOrMoment === 'string' + ? await globe.moment(idOrMoment) + : idOrMoment; + const mm = raw ? normMoment(raw) : null; + if (!mm) { + toast('That Moment is not available', { icon: icon('film') }); + return null; + } + m = mm; + speed = + s ?? (SPEEDS.includes(m.recommendedSpeed) ? m.recommendedSpeed : 30); + $$('[data-speed]', el).forEach((b) => + b.setAttribute('aria-checked', String(Number(b.dataset.speed) === speed)), + ); + el.dataset.illustrative = String(!!m.illustrative); + $('.mp-kicker', el).innerHTML = + `MOMENT · ${esc(m.place || '')}${m.simulated ? ' Simulated' : m.illustrative ? ' Illustrative' : ' Recorded'}`; + $('.mp-title', el).textContent = m.title; + $('.mp-side-title h3', el).textContent = m.title; + $('.mp-st-k', el).innerHTML = $('.mp-kicker', el).innerHTML; + $('.mp-st-s', el).textContent = + `${Math.round((m.time.end - m.time.start) / 60e3)} min · ${(m.tracks || []).length} tracks · ${(m.captures || []).length} sealed captures · ${(m.posts || []).length} posts on the record`; + legend.innerHTML = legendHtml(); + const extra = (m.tracks || []).length - 4; + if (extra > 0) + legend.insertAdjacentHTML( + 'beforeend', + `
+${extra} more tracks on the globe
`, + ); + legend.hidden = !(m.tracks || []).length; + $('.mp-src', el).textContent = (m.sources || []) + .map((x) => `${x.name}${x.detail ? ` — ${x.detail}` : ''}`) + .join(' · '); + shown = { chat: 0, posts: 0, caps: 0 }; + chatEl.innerHTML = ''; + recEl.innerHTML = emptyRec(); + capsEl.innerHTML = ''; + pops.innerHTML = ''; + // The social agent's chat replay, when it exists. + ext = null; + const sm = await social(); + // Your own sealed captures posted into this Moment join its timeline. + const addOwn = (list) => { + for (const c of list || []) { + const id = String(c.id).split(':').pop(); + if (m.captures.some((x) => x.id === id)) continue; + m.captures.push( + normMoment({ + ...m, + captures: [ + { + ...c, + id, + t: clamp(+c.t || m.time.end, m.time.start, m.time.end), + self: true, + title: c.title || 'Your sealed capture', + }, + ], + }).captures[0], + ); + } + m.captures.sort((a, b) => a.t - b.t); + }; + try { + addOwn(await sm?.momentCaptures?.(m.id)); + } catch { + /* optional */ + } + offOwn?.(); + offOwn = + sm?.onSocial?.('moment-capture', (e) => { + if (!m || e?.momentId !== m.id) return; + addOwn([e.capture]); + sync(true); + }) || null; + const slot = $('.mp-pane[data-pane="chat"]', el); + slot.classList.remove('has-ext'); + el.classList.remove('has-ext'); + $('.mp-ext', slot)?.remove(); + // Clips carry no chat: the overlay would only invent one. + if (typeof sm?.chatOverlay === 'function' && (m.chat || []).length) { + try { + const host = h('
'); + slot.prepend(host); + ext = sm.chatOverlay(host, { moment: raw, globe, getTime: () => t }); + ext?.setMoment?.({ ...raw, chat: [] }); + slot.classList.add('has-ext'); + el.classList.add('has-ext'); + } catch (err) { + console.warn( + '[moment] chatOverlay failed; using the built-in replay', + err, + ); + ext = null; + } + } + el.hidden = false; + app.classList.add('is-moment'); + void el.offsetWidth; + el.classList.add('in'); + t = atT ?? m.time.start; + await globe.playMoment(raw, { speed, camera: true, autoplay: false }); + if (atT != null) globe.seekMoment(atT); + sync(true); + if (autoplay) globe.playback.play({ speed }); + cancelAnimationFrame(raf); + raf = requestAnimationFrame(loop); + ev.emit('open', m); + return m; + } + + function close() { + if (!m) return; + cancelAnimationFrame(raf); + raf = 0; + globe.exitMoment(); + offOwn?.(); + offOwn = null; + const was = m; + m = null; + el.classList.remove('in'); + app.classList.remove('is-moment'); + setTimeout( + () => { + if (!m) el.hidden = true; + }, + reducedMotion() ? 0 : 320, + ); + ev.emit('close', was); + onExit?.(was); + } + + /* ---------- input ---------- */ + $('.mp-back', el).addEventListener('click', () => { + haptic('tick'); + close(); + }); + $('.mp-room', el).addEventListener('click', () => m && onOpenRoom?.(m)); + $('.mp-play', el).addEventListener('click', () => { + haptic('tick'); + const st = globe.playback.state(); + if (st.playing) globe.playback.stop(); + else globe.playback.play({ speed }); + }); + $('.mp-speeds', el).addEventListener('click', (e) => { + const b = e.target.closest('[data-speed]'); + if (!b) return; + haptic('tick'); + speed = Number(b.dataset.speed); + $$('[data-speed]', el).forEach((x) => + x.setAttribute('aria-checked', String(x === b)), + ); + if (globe.playback.state().playing) globe.playback.play({ speed }); + }); + $('.mp-react', el).addEventListener('click', (e) => { + const b = e.target.closest('[data-react]'); + if (!b || !m) return; + haptic('light'); + reactCooldown = 0; + burst(b.dataset.react, 3); + b.animate( + [ + { transform: 'scale(1)' }, + { transform: 'scale(1.35)' }, + { transform: 'scale(1)' }, + ], + { duration: 320, easing: 'cubic-bezier(.32,1.25,.4,1)' }, + ); + }); + const seekTo = (clientX) => { + const r = scrub.getBoundingClientRect(); + const k = clamp((clientX - r.left - 6) / (r.width - 12), 0, 1); + const ms = m.time.start + k * (m.time.end - m.time.start); + globe.seekMoment(ms); + t = ms; + sync(true); + }; + let dragging = false; + scrub.addEventListener('pointerdown', (e) => { + if (!m) return; + scrub.setPointerCapture(e.pointerId); + dragging = true; + wasPlaying = globe.playback.state().playing; + globe.playback.stop(); + el.classList.add('scrubbing'); + seekTo(e.clientX); + }); + scrub.addEventListener('pointermove', (e) => dragging && seekTo(e.clientX)); + const up = () => { + if (!dragging) return; + dragging = false; + el.classList.remove('scrubbing'); + if (wasPlaying) globe.playback.play({ speed }); + }; + scrub.addEventListener('pointerup', up); + scrub.addEventListener('pointercancel', up); + scrub.addEventListener('keydown', (e) => { + if (!m) return; + const step = e.shiftKey ? 60e3 : 10e3; + if (e.key === 'ArrowRight') + globe.seekMoment(Math.min(m.time.end, t + step)); + else if (e.key === 'ArrowLeft') + globe.seekMoment(Math.max(m.time.start, t - step)); + else if (e.key === ' ') $('.mp-play', el).click(); + else return; + e.preventDefault(); + t = globe.activeMoment()?.t ?? t; + sync(true); + }); + $('.mp-seg', el).addEventListener('click', (e) => { + const b = e.target.closest('[data-seg]'); + if (!b) return; + haptic('tick'); + seg = b.dataset.seg; + $$('[data-seg]', el).forEach((x) => + x.setAttribute('aria-selected', String(x === b)), + ); + $$('.mp-pane', el).forEach((p) => (p.hidden = p.dataset.pane !== seg)); + }); + el.addEventListener('click', (e) => { + const tr = e.target.closest('[data-track]'); + if (tr && m) return onOpenEntity?.(`moment:${m.id}:${tr.dataset.track}`); + const c = e.target.closest('[data-cap]'); + if (c && m) return onOpenEntity?.(`capture:${m.id}:${c.dataset.cap}`); + }); + document.addEventListener('keydown', (e) => { + if (!m || e.target.closest?.('input, textarea')) return; + if ( + e.key === 'Escape' && + !document.querySelector( + '.sheet-layer:not([hidden]) .sheet[aria-modal="true"]', + ) + ) + close(); + }); + new ResizeObserver(() => m && drawScrub()).observe(scrub); + + return { + open, + close, + on: ev.on, + get current() { + return m; + }, + get time() { + return t; + }, + /** Deterministic setup for the director. */ + seek(ms, { play = false } = {}) { + if (!m) return; + globe.seekMoment(ms); + t = ms; + sync(true); + if (play) globe.playback.play({ speed }); + else globe.playback.stop(); + }, + setSeg(s) { + $(`[data-seg="${s}"]`, el)?.click(); + }, + }; +} diff --git a/mobile/ui/search.js b/mobile/ui/search.js index 501439668..61d7e1ff3 100644 --- a/mobile/ui/search.js +++ b/mobile/ui/search.js @@ -1,84 +1,200 @@ -/** Search: situations, layers and places (OpenStreetMap Nominatim via /api/geocode). */ +/** + * Universal search (DESIGN.md §12.1, §12.7): instant results from + * globe.search(), grouped into Things, Situations, Places and Moments, plus + * lenses. Search leads to dossiers, not to a list of pins. Recent searches + * and suggestions ("7700", "ISS", "Piccadilly") fill the empty state. + */ import { icon, FAMILY_ICON } from './icons.js'; -import { $, esc, haptic } from './dom.js'; +import { $, $$, esc, haptic } from './dom.js'; import { createSheet } from './sheet.js'; +import { bandOfKind } from './shim3.js'; +import { KIND_ICON, KIND_NAME } from './dossier.js'; +import { bandOf } from './bands.js'; -const PLACES = [ - { name: 'Kathmandu', sub: 'Nepal', lon: 85.324, lat: 27.7172 }, - { name: 'Strait of Hormuz', sub: 'Persian Gulf', lon: 56.4, lat: 26.5 }, - { name: 'Panama Canal', sub: 'Panama', lon: -79.68, lat: 9.08 }, - { name: 'Heathrow', sub: 'London, UK', lon: -0.4543, lat: 51.47 }, - { name: 'Cape Canaveral', sub: 'Florida, US', lon: -80.6, lat: 28.47 }, - { name: 'Mount Etna', sub: 'Sicily, Italy', lon: 14.995, lat: 37.751 }, +const RECENT_KEY = 'gev.search.recent'; +const SUGGEST = [ + '7700', + 'ISS', + 'Piccadilly', + 'Empire State', + 'M6', + 'Starlink', + 'helicopter', +]; +const THING = new Set([ + 'aircraft', + 'helicopter', + 'military', + 'satellite', + 'vessel', + 'quake', + 'camera', + 'track', + 'capture', +]); +const GROUPS = [ + ['things', 'Things'], + ['situations', 'Situations'], + ['places', 'Places'], + ['moments', 'Moments'], + ['lenses', 'Lenses'], ]; +function recent() { + try { + return JSON.parse(localStorage.getItem(RECENT_KEY) || '[]'); + } catch { + return []; + } +} +function remember(q) { + const list = [ + q, + ...recent().filter((x) => x.toLowerCase() !== q.toLowerCase()), + ].slice(0, 6); + try { + localStorage.setItem(RECENT_KEY, JSON.stringify(list)); + } catch { + /* ignore */ + } +} + export function createSearch({ + host, getSituations, globe, onOpenSituation, - onPlace, + onOpenEntity, + onOpenMoment, onLayer, }) { const sheet = createSheet({ + host, label: 'Search', detents: ['large'], modal: true, dismissible: true, className: 'search-sheet', - heights: { large: (H) => Math.round(H * 0.92) }, + heights: { large: (H) => Math.round(H * 0.93) }, }); - sheet.head.innerHTML = ``; + sheet.head.innerHTML = ``; const input = $('input', sheet.head); let timer = 0; let geo = []; + let items = []; + let seq = 0; + let cursor = -1; - function match(q, ...fields) { - const s = fields.join(' ').toLowerCase(); - return q - .toLowerCase() - .split(/\s+/) - .filter(Boolean) - .every((w) => s.includes(w)); + function row(r, i) { + const band = + r.kind === 'situation' ? r.band || 'ground' : bandOfKind(r.kind); + const ic = + r.kind === 'lens' + ? FAMILY_ICON[r.family] || 'layers' + : KIND_ICON[r.kind] || 'scope'; + const tag = + r.kind === 'lens' ? (r.on ? 'On' : 'Off') : KIND_NAME[r.kind] || r.kind; + return ``; + } + + function emptyState() { + const rec = recent(); + sheet.body.innerHTML = ` + ${rec.length ? `
Recent
${rec.map((q) => ``).join('')}
` : ''} +
Try
+
${SUGGEST.map((q) => ``).join('')}
+
Live now
+

${icon('lock')}Search finds things that broadcast publicly (transponders, AIS, orbital elements), places and events. It never finds people.

`; + getSituations().then((sits) => { + const live = $('[data-live]', sheet.body); + if (!live) return; + items = sits.slice(0, 5).map((s) => ({ + id: `situation:${s.id}`, + kind: 'situation', + title: s.title, + subtitle: s.place, + band: bandOf(s), + })); + live.innerHTML = items.map(row).join(''); + }); } async function render() { const q = input.value.trim(); - const sits = await getSituations(); - const s = q - ? sits.filter((x) => match(q, x.title, x.place, x.kind, x.family)) - : sits.slice(0, 5); - const layers = q - ? globe - .layers() - .filter((l) => match(q, l.name, l.family)) - .slice(0, 8) - : []; - const places = q - ? PLACES.filter((p) => match(q, p.name, p.sub)) - : PLACES.slice(0, 4); - sheet.body.innerHTML = ` -
${q ? 'Situations' : 'Live now'}
- ${s.map((x) => ``).join('') || '

No situations match.

'} - ${layers.length ? `
Lenses
${layers.map((l) => ``).join('')}` : ''} -
Places
- ${[...places, ...geo].map((p, i) => ``).join('')} - ${q.length >= 3 ? '

Press search to look up places · © OpenStreetMap contributors

' : ''}`; - sheet.body._places = [...places, ...geo]; + cursor = -1; + if (!q) return emptyState(); + const my = ++seq; + const res = await globe.search(q); + if (my !== seq) return; + const sits = await getSituations().catch(() => []); + const ql = q.toLowerCase(); + const lenses = globe + .layers() + .filter((l) => `${l.name} ${l.family}`.toLowerCase().includes(ql)) + .slice(0, 4) + .map((l) => ({ + id: l.id, + kind: 'lens', + title: l.name, + subtitle: `${l.family} lens${l.count != null ? ` · ${l.count}` : ''}`, + family: l.family, + on: l.on, + })); + const grouped = { + things: [], + situations: [], + places: [], + moments: [], + lenses, + }; + for (const r of res) { + if (r.kind === 'situation') { + const s = sits.find((x) => `situation:${x.id}` === r.id); + grouped.situations.push({ + ...r, + band: r.band || (s ? bandOf(s) : 'ground'), + }); + } else if (r.kind === 'place') grouped.places.push(r); + else if (r.kind === 'moment') grouped.moments.push(r); + else if (THING.has(r.kind)) grouped.things.push(r); + } + for (const g of geo) grouped.places.push(g); + items = []; + const html = GROUPS.map(([k, label]) => { + const list = grouped[k].slice(0, k === 'things' ? 8 : 5); + if (!list.length) return ''; + const rows = list.map((r) => { + items.push(r); + return row(r, items.length - 1); + }); + return `
${label}${grouped[k].length}
${rows.join('')}
`; + }).join(''); + sheet.body.innerHTML = + html || + `
No matches for “${esc(q)}”Press return to look it up as a place.
`; + if (q.length >= 3 && !geo.length) + sheet.body.insertAdjacentHTML( + 'beforeend', + `

Return looks “${esc(q)}” up as a place · © OpenStreetMap contributors

`, + ); } async function geocode() { const q = input.value.trim(); if (q.length < 3) return; + remember(q); try { const r = await fetch(`/api/geocode?q=${encodeURIComponent(q)}`); if (!r.ok) throw new Error(String(r.status)); const j = await r.json(); geo = (j.results || []) .slice(0, 5) - .map((x) => ({ - name: x.formatted_address?.split(',')[0] || x.name || q, - sub: x.formatted_address || '', + .map((x, i) => ({ + id: `geo:${i}`, + kind: 'place', + title: x.formatted_address?.split(',')[0] || x.name || q, + subtitle: x.formatted_address || '', lat: Number(x.geometry?.location?.lat ?? x.lat), lon: Number(x.geometry?.location?.lng ?? x.lon), })) @@ -89,51 +205,85 @@ export function createSearch({ render(); } + function choose(r) { + if (!r) return; + haptic('light'); + const q = input.value.trim(); + if (q) remember(q); + sheet.close(); + setTimeout(() => { + if (r.kind === 'lens') onLayer(r.id); + else if (r.kind === 'situation') + onOpenSituation(r.id.replace(/^situation:/, '')); + else if (r.kind === 'moment') onOpenMoment(r.id.replace(/^moment:/, '')); + else if (/^geo:/.test(r.id)) + globe.flyTo({ lon: r.lon, lat: r.lat, height: 30e3, duration: 2 }); + else onOpenEntity(r.id); + }, 160); + } + input.addEventListener('input', () => { geo = []; clearTimeout(timer); - timer = setTimeout(render, 80); + timer = setTimeout(render, 60); + }); + input.addEventListener('keydown', (e) => { + const rows = $$('.sr', sheet.body); + if (e.key === 'ArrowDown' || e.key === 'ArrowUp') { + e.preventDefault(); + cursor = Math.max( + 0, + Math.min(rows.length - 1, cursor + (e.key === 'ArrowDown' ? 1 : -1)), + ); + rows.forEach((r, i) => + r.setAttribute('aria-selected', String(i === cursor)), + ); + rows[cursor]?.scrollIntoView({ block: 'nearest' }); + } }); sheet.head.querySelector('form').addEventListener('submit', (e) => { e.preventDefault(); + if (cursor >= 0 && items[cursor]) return choose(items[cursor]); + if (items.length && input.value.trim() && !$('.sr-empty', sheet.body)) + return choose(items[0]); geocode(); }); sheet.head .querySelector('.search-cancel') .addEventListener('click', () => sheet.close()); - sheet.body.addEventListener('click', async (e) => { - const sit = e.target.closest('[data-sit]'); - if (sit) { - const s = (await getSituations()).find( - (x) => String(x.id) === sit.dataset.sit, - ); - sheet.close(); - if (s) setTimeout(() => onOpenSituation(s), 200); - return; - } - const l = e.target.closest('[data-layer]'); - if (l) { + sheet.body.addEventListener('click', (e) => { + const chip = e.target.closest('[data-q]'); + if (chip) { haptic('tick'); - sheet.close(); - onLayer(l.dataset.layer); + input.value = chip.dataset.q; + render(); return; } - const p = e.target.closest('[data-place]'); - if (p) { - const place = sheet.body._places[Number(p.dataset.place)]; - sheet.close(); - if (place) onPlace(place); + if (e.target.closest('[data-clear]')) { + try { + localStorage.removeItem(RECENT_KEY); + } catch { + /* ignore */ + } + emptyState(); + return; } + const r = e.target.closest('[data-i]'); + if (r) choose(items[Number(r.dataset.i)]); }); return { - open() { - input.value = ''; + open(q = '') { + input.value = q; geo = []; render(); sheet.open('large'); setTimeout(() => input.focus({ preventScroll: true }), 120); }, + close: () => sheet.close(), + get isOpen() { + return sheet.isOpen; + }, }; } diff --git a/mobile/ui/sheet.js b/mobile/ui/sheet.js index 5d5427f3a..9da845cc6 100644 --- a/mobile/ui/sheet.js +++ b/mobile/ui/sheet.js @@ -27,7 +27,7 @@ export function createSheet(o) { const root = h(`