Python tool for aircraft Doppler audio geolocation using historical ADS-B flight data (Source-available)
Python acoustic-geolocationads-baircraft-trackingairplaneaudio-forensicsdoppler-effectdoppler-shiftgeolocationosintsignal-processing
Document measured costs and make real performance controls portable
Cinna Davisf805f6fc6bb7
diff --cc README.mdindex 9b0e42f,9b0e42f..e301f2f--- a/README.md+++ b/README.md@@@ -174,6 -174,6 +174,7 @@@ Fully vibecoded if it wasn't obvious. U- [Methodology](docs/METHODOLOGY.md) — geometry, Doppler and acoustic propagation- [Installation and reproducibility](docs/SETUP.md) — environments, verification, restoration++- [Pipeline performance measurements](docs/PIPELINE_PERFORMANCE_2026-11-03.md) — real-input timings, comparison controls, and reproduction commands- [Automatic event discovery](docs/AUDIO_DISCOVERY.md) — detector design and known failure modes- [Confidence and decision rules](docs/CONFIDENCE.md) — ambiguity, abstention, incomplete coverage- [Finite-search evidence](docs/FINITE_SEARCH_PRODUCER.md) and [clock-trial accounting](docs/SCORING_ASSESSMENT.md) — retained/discarded candidates and unknown model workdiff --cc benchmarks/results/pipeline-components-20261103.jsonindex 0000000,0000000..298ab89new file mode 100644--- /dev/null+++ b/benchmarks/results/pipeline-components-20261103.json@@@ -1,0 -1,0 +1,951 @@@++{++ "date_utc": "2026-11-03",++ "scope": "Runtime and result consistency on recorded audio and historical trajectories; no independent location accuracy claim.",++ "sources": {++ "original_baseline": "7a8dd27979bd9a984c8675c38a00dfbf98a5b01e",++ "core_changes": "a2236ac",++ "core_with_main": "fa19b59492a15ca3f3dd526bed5706b770793a58",++ "combined_http": "00727d4",++ "combined_scoring_dependency": "3725e9d2027d979e579ba9c347fb688ebf0895c3"++ },++ "runtime": {++ "numerical_packages": {++ "numpy": "2.3.5",++ "scipy": "1.17.0",++ "pandas": "2.2.3",++ "pyarrow": "26.0.1",++ "pyproj": "3.8.0",++ "rasterio": "1.5.2",++ "soundfile": "0.14.0"++ },++ "numerical_threads": 1,++ "audio_helpers_search_python": "3.12.14",++ "cache_empty_tiles_configured_http_python": "3.12.3",++ "cache_empty_tiles_configured_http_sqlite": "3.45.1"++ },++ "inputs": {++ "wav_sha256": "262d9c4eba1c80657813c604140ba2afbbaabed2b3aebc833cba7cafdc005e9f",++ "wav_duration_s": 3600.1845,++ "wav_ridges": 18,++ "wav_independent_groups": 16,++ "mp3_sha256": "707083f0344823eeea7f130faec6c22b6628b8b9fea04d026915d93df9a07b15",++ "mp3_ridges": 17,++ "mp3_independent_groups": 15,++ "clock_note": "Historical fitted clock, not independent timing evidence",++ "coverage_note": "Regional observed archive excludes known jets; complete coverage is not established"++ },++ "audio": {++ "comparison": "Original/new implementation, three alternating pairs; intake and plots excluded",++ "discovery": {++ "baseline": {++ "trials": [++ {++ "wall_s": 9.284779882999942,++ "cpu_s": 9.239130253999999++ },++ {++ "wall_s": 7.356600091000018,++ "cpu_s": 7.355370614000002++ },++ {++ "wall_s": 6.731685112999912,++ "cpu_s": 6.730280811++ }++ ],++ "median_wall_s": 7.356600091000018,++ "median_cpu_s": 7.355370614000002++ },++ "current": {++ "trials": [++ {++ "wall_s": 6.414081021000015,++ "cpu_s": 6.4099143330000015++ },++ {++ "wall_s": 5.961681690000091,++ "cpu_s": 5.953134779000003++ },++ {++ "wall_s": 6.04402048999998,++ "cpu_s": 6.043257627000003++ }++ ],++ "median_wall_s": 6.04402048999998,++ "median_cpu_s": 6.043257627000003++ },++ "wall_speedup": 1.217169945596932,++ "cpu_speedup": 1.2171201474412996,++ "exact_event_payload_match": true,++ "ridge_count": 18,++ "independent_group_count": 16++ },++ "configured_ridges": [++ {++ "event": 1,++ "spectrum_shape": [++ 921,++ 713++ ],++ "exact_frequency_and_weight_match": true,++ "baseline": {++ "trials": [++ {++ "wall_s": 0.18297023399998125,++ "cpu_s": 0.1829722699999934++ },++ {++ "wall_s": 0.17685444400001415,++ "cpu_s": 0.17680868999999433++ },++ {++ "wall_s": 0.18520073299998785,++ "cpu_s": 0.18520574200000084++ }++ ],++ "median_wall_s": 0.18297023399998125,++ "median_cpu_s": 0.1829722699999934++ },++ "current": {++ "trials": [++ {++ "wall_s": 0.058338671999990765,++ "cpu_s": 0.05833744499999938++ },++ {++ "wall_s": 0.06065663100002894,++ "cpu_s": 0.0606612240000004++ },++ {++ "wall_s": 0.06332199999997101,++ "cpu_s": 0.06331132200000411++ }++ ],++ "median_wall_s": 0.06065663100002894,++ "median_cpu_s": 0.0606612240000004++ },++ "wall_speedup": 3.016491865496024,++ "cpu_speedup": 3.0162970335051624++ },++ {++ "event": 2,++ "spectrum_shape": [++ 721,++ 333++ ],++ "exact_frequency_and_weight_match": true,++ "baseline": {++ "trials": [++ {++ "wall_s": 0.07580405500004872,++ "cpu_s": 0.07584756099999623++ },++ {++ "wall_s": 0.0735758349999287,++ "cpu_s": 0.07330923200000683++ },++ {++ "wall_s": 0.0675049259999696,++ "cpu_s": 0.06750940799999938++ }++ ],++ "median_wall_s": 0.0735758349999287,++ "median_cpu_s": 0.07330923200000683++ },++ "current": {++ "trials": [++ {++ "wall_s": 0.029976841999996395,++ "cpu_s": 0.02998151999999976++ },++ {++ "wall_s": 0.025200435999977344,++ "cpu_s": 0.02520547499999992++ },++ {++ "wall_s": 0.025601695999966978,++ "cpu_s": 0.025605783999999687++ }++ ],++ "median_wall_s": 0.025601695999966978,++ "median_cpu_s": 0.025605783999999687++ },++ "wall_speedup": 2.873865661088375,++ "cpu_speedup": 2.862995017063634++ }++ ]++ },++ "helpers": {++ "scope": "Real observations and archived candidate coordinates; component timings only",++ "cpu_affinity": [++ 6++ ],++ "tracks": 214,++ "samples": 71571,++ "independent_decodes_exact": true,++ "old_new_identity_relation_exact": true,++ "duplicate_track_geometry_exact": true,++ "terrain_arrays_exact": true,++ "candidate_rows": 283,++ "unique_candidate_coordinates": 274,++ "identity_digest": {++ "trials": {++ "baseline": [++ {++ "wall_s": 0.7115346380001029,++ "cpu_s": 0.7115334740000003++ },++ {++ "wall_s": 0.6816926090000379,++ "cpu_s": 0.6816836399999993++ },++ {++ "wall_s": 0.7168531109998639,++ "cpu_s": 0.7168470490000001++ }++ ],++ "current": [++ {++ "wall_s": 0.011288004000107321,++ "cpu_s": 0.011292508000000367++ },++ {++ "wall_s": 0.009811315999968429,++ "cpu_s": 0.009814100999999908++ },++ {++ "wall_s": 0.010700293999889254,++ "cpu_s": 0.010702902000000236++ }++ ]++ },++ "median": {++ "baseline": {++ "wall_s": 0.7115346380001029,++ "cpu_s": 0.7115334740000003++ },++ "current": {++ "wall_s": 0.010700293999889254,++ "cpu_s": 0.010702902000000236++ }++ },++ "wall_speedup": 66.49673719315255,++ "cpu_speedup": 66.48042502864968++ },++ "duplicate_index_query": {++ "trials": {++ "baseline": [++ {++ "wall_s": 2.97018349699988,++ "cpu_s": 2.9699184150000004++ },++ {++ "wall_s": 2.807910829000093,++ "cpu_s": 2.8075487179999996++ },++ {++ "wall_s": 3.2889418439999645,++ "cpu_s": 3.288740260999999++ }++ ],++ "current": [++ {++ "wall_s": 1.3139952129999983,++ "cpu_s": 1.3139138050000003++ },++ {++ "wall_s": 1.490499765000095,++ "cpu_s": 1.490374632++ },++ {++ "wall_s": 1.762300514000117,++ "cpu_s": 1.7621483060000003++ }++ ]++ },++ "median": {++ "baseline": {++ "wall_s": 2.97018349699988,++ "cpu_s": 2.9699184150000004++ },++ "current": {++ "wall_s": 1.490499765000095,++ "cpu_s": 1.490374632++ }++ },++ "wall_speedup": 1.9927433514219242,++ "cpu_speedup": 1.9927328010236829++ },++ "terrain_scalar_queries": {++ "trials": {++ "baseline": [++ {++ "wall_s": 0.4443265560000782,++ "cpu_s": 0.44422315499999954++ },++ {++ "wall_s": 0.48182881100001396,++ "cpu_s": 0.4817972530000034++ },++ {++ "wall_s": 0.49004781799999364,++ "cpu_s": 0.4900461589999985++ }++ ],++ "current": [++ {++ "wall_s": 0.1664448099998026,++ "cpu_s": 0.1664502170000013++ },++ {++ "wall_s": 0.1315762229999109,++ "cpu_s": 0.13158169000000086++ },++ {++ "wall_s": 0.1506844049999927,++ "cpu_s": 0.15069019499999925++ }++ ]++ },++ "median": {++ "baseline": {++ "wall_s": 0.48182881100001396,++ "cpu_s": 0.4817972530000034++ },++ "current": {++ "wall_s": 0.1506844049999927,++ "cpu_s": 0.15069019499999925++ }++ },++ "wall_speedup": 3.197602372986357,++ "cpu_speedup": 3.1972700878116576++ },++ "terrain_vector_query": {++ "trials": {++ "baseline": [++ {++ "wall_s": 0.0019550570000319567,++ "cpu_s": 0.0019570879999974977++ },++ {++ "wall_s": 0.0018791140000757878,++ "cpu_s": 0.0018804039999977817++ },++ {++ "wall_s": 0.0031173479999324627,++ "cpu_s": 0.003119555000001384++ }++ ],++ "current": [++ {++ "wall_s": 0.000638515999980882,++ "cpu_s": 0.0006401309999972682++ },++ {++ "wall_s": 0.00037645799989149964,++ "cpu_s": 0.0003774209999996003++ },++ {++ "wall_s": 0.0004980270000487508,++ "cpu_s": 0.0004988109999999324++ }++ ]++ },++ "median": {++ "baseline": {++ "wall_s": 0.0019550570000319567,++ "cpu_s": 0.0019570879999974977++ },++ "current": {++ "wall_s": 0.0004980270000487508,++ "cpu_s": 0.0004988109999999324++ }++ },++ "wall_speedup": 3.925604434780806,++ "cpu_speedup": 3.92350609749537++ },++ "terrain_transform_cache": {++ "hits": 1704,++ "misses": 2,++ "maxsize": 32,++ "currsize": 2++ }++ },++ "empty_tiles": {++ "scope": "Recorded empty coarse tiles with receiver cells; includes geometry, real index queries, coarse/global stages, checksums and checkpoint writes; excludes progress/resume reads",++ "tiles": 256,++ "batch_size": 32,++ "passes": 3,++ "runtime": {++ "python": "3.12.3",++ "sqlite": "3.45.1"++ },++ "timings": {++ "ordinary": [++ {++ "wall_s": 2.1692930350000097,++ "cpu_s": 1.09747029++ },++ {++ "wall_s": 2.009673713999746,++ "cpu_s": 1.0613797029999992++ },++ {++ "wall_s": 2.317755713999759,++ "cpu_s": 1.1247887930000005++ }++ ],++ "batched": [++ {++ "wall_s": 0.7647061020002184,++ "cpu_s": 0.741824603++ },++ {++ "wall_s": 0.7330908949998047,++ "cpu_s": 0.7171870200000003++ },++ {++ "wall_s": 0.928092106999884,++ "cpu_s": 0.8675067000000007++ }++ ]++ },++ "median_wall_s": {++ "ordinary": 2.1692930350000097,++ "batched": 0.7647061020002184++ },++ "speedup": 2.836767000192435,++ "all_checkpoints_match_recorded_tiles": true,++ "all_ledger_tables_match": true,++ "all_committed_stages_valid": true,++ "stage_count": 512++ },++ "track_cache": {++ "regional": {++ "scope": "Repeated real trajectory query; excludes acquisition, audio and scoring",++ "bounds": [++ -74.299988,++ 40.100005,++ -72.700011,++ 41.599964++ ],++ "time_range_s": [++ 1788898500.0,++ 1788902400.0++ ],++ "passes": {++ "uncached": [++ {++ "wall_s": 1.5943461480001133,++ "cpu_s": 1.5940993289999998,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 1.5704857300002004,++ "cpu_s": 1.5702036489999998,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 1.531997720000163,++ "cpu_s": 1.531999172,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 1.567756417000055,++ "cpu_s": 1.5673321649999998,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ }++ ],++ "cached": [++ {++ "wall_s": 1.5197348029996647,++ "cpu_s": 1.519719695,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 441,++ "serialized_cache_bytes": 26737306++ },++ {++ "wall_s": 0.104930924999735,++ "cpu_s": 0.10493462900000061,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 441,++ "serialized_cache_bytes": 26737306++ },++ {++ "wall_s": 0.10096911500022543,++ "cpu_s": 0.10097258199999981,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 441,++ "serialized_cache_bytes": 26737306++ },++ {++ "wall_s": 0.10028485099974205,++ "cpu_s": 0.1002887260000005,++ "tracks": 441,++ "samples": 89504,++ "geometry_and_labels_sha256": "e82c50a6054bcb7f5646ab11d55ff631069ae5cb6127baaf4f586c019ef80ecc",++ "cached_tracks": 441,++ "serialized_cache_bytes": 26737306++ }++ ]++ },++ "same_geometry_and_labels": true,++ "median_warm_query_s": {++ "uncached": 1.567756417000055,++ "cached": 0.10096911500022543++ },++ "warm_query_speedup": 15.527088823117394,++ "first_query_s": {++ "uncached": 1.5943461480001133,++ "cached": 1.5197348029996647++ },++ "all_query_passes_s": {++ "uncached": 6.264586015000532,++ "cached": 1.8259196939993672++ },++ "all_passes_speedup_including_cold_cache": 3.4309208863830256,++ "comparison": "Cache off/on in the same final source, one cold decoded-cache query and three warm queries; operating-system cache is uncontrolled."++ },++ "full_day": {++ "scope": "Repeated real trajectory query; excludes acquisition, audio and scoring",++ "bounds": [++ -74.05,++ 40.55,++ -73.55,++ 41.05++ ],++ "time_range_s": [++ 1788825600.0,++ 1788912000.0++ ],++ "passes": {++ "uncached": [++ {++ "wall_s": 4.041226284999993,++ "cpu_s": 4.041035789,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 4.72467777699967,++ "cpu_s": 4.642505895999998,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 4.651927691999845,++ "cpu_s": 4.651892911000001,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ },++ {++ "wall_s": 4.753316680000353,++ "cpu_s": 4.751010804,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 0,++ "serialized_cache_bytes": 0++ }++ ],++ "cached": [++ {++ "wall_s": 4.936198077999961,++ "cpu_s": 4.9358338879999994,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 441,++ "serialized_cache_bytes": 33430432++ },++ {++ "wall_s": 2.6574560640001437,++ "cpu_s": 2.65744765,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 441,++ "serialized_cache_bytes": 33430432++ },++ {++ "wall_s": 2.744923665999977,++ "cpu_s": 2.7434365110000023,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 441,++ "serialized_cache_bytes": 33430432++ },++ {++ "wall_s": 3.078974736999953,++ "cpu_s": 3.0784054989999987,++ "tracks": 1183,++ "samples": 287491,++ "geometry_and_labels_sha256": "b1ec19df74ed40615dfc500abde45420a005d75d7224887ff9032c9f7f916f44",++ "cached_tracks": 441,++ "serialized_cache_bytes": 33430432++ }++ ]++ },++ "same_geometry_and_labels": true,++ "median_warm_query_s": {++ "uncached": 4.72467777699967,++ "cached": 2.744923665999977++ },++ "warm_query_speedup": 1.72124195493009,++ "first_query_s": {++ "uncached": 4.041226284999993,++ "cached": 4.936198077999961++ },++ "all_query_passes_s": {++ "uncached": 18.17114843399986,++ "cached": 13.417552545000035++ },++ "all_passes_speedup_including_cold_cache": 1.3542818910570409,++ "comparison": "Cache off/on in the same final source, one cold decoded-cache query and three warm queries; operating-system cache is uncontrolled."++ }++ },++ "configured_workers": {++ "scope": "Full configured reference replay using original audio, observations and source-informed event/grid settings; not automatic or independent localization validation",++ "upstream_parallelism": "PR #210, merged in adbfb3e; final local performance changes active in both controls",++ "runtime": {++ "python": "3.12.3",++ "sqlite": "3.45.1",++ "blas_threads": 1,++ "cpu_affinity": {++ "workers_1": [++ 4++ ],++ "workers_4": [++ 4,++ 5,++ 7,++ 8++ ]++ }++ },++ "measurement_design": "One sequential pair with fresh process/output directories; all scientific settings identical; worker count is the only setting changed",++ "workers": [++ 1,++ 4++ ],++ "process_wall_s": [++ 63.080272204000266,++ 50.85959439999988++ ],++ "report_elapsed_s": [++ 60.038204577000215,++ 47.425417169999946++ ],++ "process_wall_speedup": 1.240282643779802,++ "process_wall_reduction_fraction": 0.19373216660319692,++ "same_scientific_json": true,++ "same_csv_bytes": true,++ "excluded_report_metadata": [++ "elapsed_s",++ "provenance",++ "implementation_sha256",++ "implementation_sources",++ "config.scoring_workers",++ "sources entry with roles=[configuration]"++ ],++ "ranked_rows": 283,++ "coarse_points": 2525,++ "trajectory_segments": 3587,++ "accepted_location": false,++ "scientific_json_artifact_count": 16,++ "csv_artifact_count": 3++ },++ "search_architecture_comparison": {++ "dense": {++ "case": "previous-fit",++ "scope": "One separately loaded process per frozen variant; same recorded arrays, query tracks, point, clocks and budgets. No location accuracy claim.",++ "timings": {++ "pr212": {++ "wall_seconds": 16.130660911000177,++ "cpu_seconds": 16.091403776,++ "load_seconds_excluded": 1.0451894960001482,++ "operations": {++ "scalar_fit_calls": 68,++ "acoustic_calls": 397,++ "scored_candidates": 1927++ },++ "peak_rss_mib": 230.953125,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 100,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "exact": {++ "wall_seconds": 19.287786888000028,++ "cpu_seconds": 19.256217652,++ "load_seconds_excluded": 0.9172454069998821,++ "operations": {++ "scalar_fit_calls": 6493,++ "acoustic_calls": 397,++ "scored_candidates": 1927++ },++ "peak_rss_mib": 255.4375,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 100,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "original": {++ "wall_seconds": 35.92530473200031,++ "cpu_seconds": 35.877964218,++ "load_seconds_excluded": 0.9022394250000616,++ "operations": {++ "scalar_fit_calls": 32255,++ "acoustic_calls": 397,++ "scored_candidates": 1927++ },++ "peak_rss_mib": 241.79296875,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 100,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "corrected": {++ "wall_seconds": 36.8815337570004,++ "cpu_seconds": 36.826490442,++ "load_seconds_excluded": 0.840361995999956,++ "operations": {++ "scalar_fit_calls": 32255,++ "acoustic_calls": 397,++ "scored_candidates": 1927++ },++ "peak_rss_mib": 241.58984375,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 100,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ }++ },++ "exact_variant_equal_original": true,++ "pr212_equal_corrected_baseline": true,++ "pr212_retained_equal_original": true,++ "pr212_accounting_equal_original": true,++ "original_to_corrected": {++ "difference_count": 11,++ "first_differences": [++ {++ "path": "$.all_scored_candidates[1079].event_diagnostics[0].f0_hz",++ "before": 113.02531383265242,++ "after": 113.02531383265243,++ "absolute_difference": 1.4210854715202004e-14,++ "difference_in_ulp_at_before": 1.0++ },++ {++ "path": "$.all_scored_candidates[1079].event_diagnostics[0].rmse_hz",++ "before": 1.6618731136088518,++ "after": 1.6618731136088511,++ "absolute_difference": 6.661338147750939e-16,++ "difference_in_ulp_at_before": 3.0++ },++ {++ "path": "$.all_scored_candidates[1079].event_diagnostics[0].score",++ "before": -1.2918469704343516,++ "after": -1.2918469704343505,++ "absolute_difference": 1.1102230246251565e-15,++ "difference_in_ulp_at_before": 5.0++ },++ {++ "path": "$.all_scored_candidates[1079].event_diagnostics[0].source_drift_hz",++ "before": -1.6022669802499345,++ "after": -1.6022669802499139,++ "absolute_difference": 2.0650148258027912e-14,++ "difference_in_ulp_at_before": 93.0++ },++ {++ "path": "$.all_scored_candidates[1079].event_diagnostics[0].source_drift_hz_s",++ "before": -0.08475750862738778,++ "after": -0.0847575086273867,++ "absolute_difference": 1.0824674490095276e-15,++ "difference_in_ulp_at_before": 78.0++ },++ {++ "path": "$.all_scored_candidates[1079].event_scores[0]",++ "before": -1.2918469704343516,++ "after": -1.2918469704343505,++ "absolute_difference": 1.1102230246251565e-15,++ "difference_in_ulp_at_before": 5.0++ },++ {++ "path": "$.all_scored_candidates[1079].f0_hz[0]",++ "before": 113.02531383265242,++ "after": 113.02531383265243,++ "absolute_difference": 1.4210854715202004e-14,++ "difference_in_ulp_at_before": 1.0++ },++ {++ "path": "$.all_scored_candidates[1079].residual_score",++ "before": -7.66681274669189,++ "after": -7.666812746691889,++ "absolute_difference": 8.881784197001252e-16,++ "difference_in_ulp_at_before": 1.0++ },++ {++ "path": "$.all_scored_candidates[1079].score",++ "before": 1.4443957511027032,++ "after": 1.4443957511027037,++ "absolute_difference": 4.440892098500626e-16,++ "difference_in_ulp_at_before": 2.0++ },++ {++ "path": "$.retention.records[42][2]",++ "before": 1.4443957511027032,++ "after": 1.4443957511027037,++ "absolute_difference": 4.440892098500626e-16,++ "difference_in_ulp_at_before": 2.0++ },++ {++ "path": "$.retention.stages[0][1]",++ "before": "853b303924e0d892b94e0254837f004aa0c937876326d4118deca573394ef45d",++ "after": "4099f0a939775b98a2fb0c6f1ce807c124d9e36c1ca59238cab8f701233b433b"++ }++ ]++ },++ "corrected_to_pr212": {++ "difference_count": 0,++ "first_differences": []++ },++ "original_to_exact": {++ "difference_count": 0,++ "first_differences": []++ },++ "pr212_cpu_speedup_over_exact": 1.1966773017479218,++ "pr212_cpu_speedup_over_original": 2.2296354449517484++ },++ "sparse": {++ "case": "offset",++ "scope": "One separately loaded process per frozen variant; same recorded arrays, query tracks, point, clocks and budgets. No location accuracy claim.",++ "timings": {++ "corrected": {++ "wall_seconds": 3.6900103289999606,++ "cpu_seconds": 3.683335948,++ "load_seconds_excluded": 0.9317238620001262,++ "operations": {++ "scalar_fit_calls": 2191,++ "acoustic_calls": 297,++ "scored_candidates": 206++ },++ "peak_rss_mib": 205.8359375,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 28,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "original": {++ "wall_seconds": 3.1404853110002477,++ "cpu_seconds": 3.130182064,++ "load_seconds_excluded": 0.7733666260000973,++ "operations": {++ "scalar_fit_calls": 2191,++ "acoustic_calls": 297,++ "scored_candidates": 206++ },++ "peak_rss_mib": 206.23046875,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 28,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "exact": {++ "wall_seconds": 2.685179932999745,++ "cpu_seconds": 2.6791283659999996,++ "load_seconds_excluded": 0.8818394079999052,++ "operations": {++ "scalar_fit_calls": 1161,++ "acoustic_calls": 297,++ "scored_candidates": 206++ },++ "peak_rss_mib": 225.56640625,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 28,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ },++ "pr212": {++ "wall_seconds": 2.034704806999798,++ "cpu_seconds": 2.030037885,++ "load_seconds_excluded": 0.7205967680001777,++ "operations": {++ "scalar_fit_calls": 437,++ "acoustic_calls": 297,++ "scored_candidates": 206++ },++ "peak_rss_mib": 203.91015625,++ "peak_rss_scope": "Worker lifetime through scoring, including imports and input loading",++ "retained": 28,++ "independent_groups": 16,++ "scope": "Real measured audio and observed regional ADS-B; development receiver hypotheses; no independent location-accuracy claim. The restored historical region excludes known jets and does not establish complete flight coverage."++ }++ },++ "exact_variant_equal_original": true,++ "pr212_equal_corrected_baseline": true,++ "pr212_retained_equal_original": true,++ "pr212_accounting_equal_original": true,++ "original_to_corrected": {++ "difference_count": 0,++ "first_differences": []++ },++ "corrected_to_pr212": {++ "difference_count": 0,++ "first_differences": []++ },++ "original_to_exact": {++ "difference_count": 0,++ "first_differences": []++ },++ "pr212_cpu_speedup_over_exact": 1.31974303819458,++ "pr212_cpu_speedup_over_original": 1.5419328314653595++ }++ },++ "verification": {++ "focused_real_tests": 23,++ "result": "passed",++ "elapsed_s": 2.47,++ "source": "fa19b594",++ "cli_help": "passed",++ "synthetic_suites_run": false++ },++ "full_workflow": {++ "status": "in_progress",++ "fresh_run_speedup": null++ },++ "preserved_failures": [++ "Two original-baseline runs stopped after SQLite retention-database errors under Python 3.12.14 / SQLite 3.53.1. Root cause is unestablished.",++ "The system-runtime baseline reached the 900-second HTTP timeout. A separate continuation retains its original source and inputs; its cumulative active cost is not a fresh-run timing."++ ]++}diff --cc docs/PIPELINE_PERFORMANCE_2026-11-03.mdindex 0000000,0000000..26fbf40new file mode 100644--- /dev/null+++ b/docs/PIPELINE_PERFORMANCE_2026-11-03.md@@@ -1,0 -1,0 +1,130 @@@++# Pipeline performance: 2026-11-03++++The core changes in [PR #222](https://github.com/1337isnot1337/DOPPLERGEIST/pull/222) reduce repeated audio work, trajectory construction, coordinate transforms, and database commits. They preserve the scientific search rules. The committed [component evidence](../benchmarks/results/pipeline-components-20261103.json) contains individual timings, input hashes, runtime versions, and comparison results.++++## Source and measurement scope++++| Revision | Role |++| --- | --- |++| `7a8dd27979bd9a984c8675c38a00dfbf98a5b01e` | Unmodified source baseline |++| Core `a2236ac`, tested with main as `fa19b594` | Core changes described here; public commit `1d045b3664648060071fa6e0799738a3fe74b19a` has the same source tree |++| `931b1bd` | Separate scoring alternative that preserves the original numerical results exactly |++| `3725e9d` from [PR #212](https://github.com/1337isnot1337/DOPPLERGEIST/pull/212), combined as `00727d4` | Separate scoring implementation used in the combined HTTP evaluation |++++All workloads use actual recordings and observed trajectories. The full WAV produces 18 ridges in 16 independent groups. The common HTTP MP3 produces 17 ridges in 15 groups. Each comparison uses identical input bytes within its pair. These development workloads measure runtime and result consistency. They do not establish location accuracy.++++## Core changes++++- **Audio:** discovery uses scalar medians from upstream [PR #221](https://github.com/1337isnot1337/DOPPLERGEIST/pull/221). PR #222 adds reusable transition slices, penalties, and predecessor indices for ridge tracing. Window lengths and strict tie comparisons stay unchanged.++- **Flight decoding:** an index reuses decoded-track snapshots. Every read still checks the stored payload hash. Each return contains independent objects. Admission protection stops large repeated queries from evicting entries they just used.++- **Duplicate tracks:** canonical binary geometry replaces float-to-JSON conversion for private duplicate detection. Persisted evidence hashes retain their original representation.++- **Terrain:** a bounded cache reuses up to 32 coordinate transforms. DEM and geoid samples remain exactly equal.++- **Retention:** serial search commits at most 32 empty tiles together. Coarse stages, global stages, checksums, bounds, and checkpoint files remain present. Normal stage validation rejects checkpoints from an interrupted, uncommitted transaction.++++The track cache holds at most 32 MiB of serialized, uncompressed snapshots and 2,048 entries per index instance. These limits exclude returned objects and temporary allocations. `track_cache_bytes=0` disables reuse. The transaction benchmark compares ordinary commits with `--batch-size 32`. It measures the same implementation in both arms.++++The discovery measurement below used the equivalent local scalar-median implementation before PR #221 merged. The final integration adopts that upstream implementation.++++## Component timings++++Times below are wall seconds. Audio, helper, and empty-tile rows use medians from three alternating pairs. Warm-cache rows use three queries after an initial query. The [evidence file](../benchmarks/results/pipeline-components-20261103.json) preserves CPU timings where measured.++++| Workload | Control | Before | After | Speedup |++| --- | --- | ---: | ---: | ---: |++| Full WAV discovery, intake and plots excluded | Old/new source | 7.357 | 6.044 | 1.22× |++| Two recorded ridge windows | Old/new source | 0.183 / 0.0736 | 0.0607 / 0.0256 | 3.02× / 2.87× |++| 441 tracks, 89,504 samples, warm query | Cache disabled/enabled | 1.568 | 0.101 | 15.53× |++| 1,183 tracks, 287,491 samples, warm query | Cache disabled/enabled | 4.725 | 2.745 | 1.72× |++| Geometry identities for 214 tracks | Old/new helper | 0.712 | 0.0107 | 66.50× |++| Duplicate-index query, track cache disabled | Old/new helper | 2.970 | 1.490 | 1.99× |++| 283 scalar DEM and geoid queries | Old/new helper | 0.482 | 0.151 | 3.20× |++| 256 recorded empty tiles | Ordinary/batched commits | 2.169 | 0.765 | 2.84× |++++The helper query contains 71,571 samples. Terrain sampling covers 274 distinct candidate coordinates. Empty-tile timing includes real index queries, geometry, checkpoint writes, and all 512 ledger stages. It excludes progress updates, resume reads, and nonempty scoring.++++Audio, helper, and scoring measurements use Python 3.12.14. Cache, transaction, configured-worker, and HTTP controls use Python 3.12.3 with SQLite 3.45.1. Each pair uses the same interpreter and numerical packages. Cross-runtime ratios are not controlled comparisons.++++### Cold and warm cache behavior++++Cold means an empty decoded-track cache. Warm means reuse after an earlier query. Neither term establishes a cold operating-system file cache. The dense query costs 4.041 seconds without caching and 4.936 seconds with caching on its first pass: approximately **22% slower**. Across one cold and three warm passes, it improves by 1.35×. The regional workload improves by 3.43× across all four passes. Its 15.53× result applies only to warm queries.++++## Separate scoring implementations++++The four-arm comparison loads each frozen variant in a separate process. Each cell below is **one process CPU measurement**, not a median. Input loading is excluded. Both workloads use the same 16 observed groups, receiver hypothesis, clock range, and budgets across variants.++++| Workload | Original baseline | Arithmetic-corrected baseline | Exact alternative `931b1bd` | PR #212 `3725e9d` |++| --- | ---: | ---: | ---: | ---: |++| Dense: 1,927 associations | 35.878 s | 36.826 s | 19.256 s | 16.091 s |++| Offset: 206 associations | 3.130 s | 3.683 s | 2.679 s | 2.030 s |++++PR #212 is 2.23× and 1.54× faster than the original on these cases. It exactly matches the corrected baseline, including discarded candidates and ledger contents. Retained candidates and accounting also match the original baseline. A separate power-arithmetic correction changes one discarded dense candidate's total score by two units in the last place. Related diagnostics and its ledger checksum also change. The comparison preserves those differences without treating them as exact equivalence.++++The exact alternative matches the original results and remains available separately. Its portable scoring workload and paired benchmark are preserved at `931b1bd`, in `docs/verification/REAL_SEARCH_BATCH_PERFORMANCE.md`. Those scoring changes are separate from the core changes here.++++## Reproduce the core comparisons++++Follow [installation instructions](SETUP.md), then run from the repository root. Select the same interpreter and package versions for both arms. Limit numerical threads. Optional Linux CPU affinity can reduce interference. Use a new output path for every run.++++```bash++. .venv/bin/activate++export PYTHONPATH=src++export OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 MKL_NUM_THREADS=1++python scripts/restore_artifacts.py \++ --bundle data-source --bundle data-adsb-derived --bundle data-terrain++git worktree add --detach ../DOPPLERGEIST-perf-baseline \++ 7a8dd27979bd9a984c8675c38a00dfbf98a5b01e++PERF_BASELINE=../DOPPLERGEIST-perf-baseline++PERF_INDEX=results/perf-input/reference-region.sqlite++++python - <<'PY'++import json++from pathlib import Path++from dopplergeist.data_access import FlightIndex++fixture = json.loads(Path('tests/data/real-empty-tile-workload.json').read_text())++FlightIndex.from_parquet(++ 'results/perf-input/reference-region.sqlite',++ 'data/adsb/2026-09-08/reference-region.parquet',++ coverage=fixture['index_inputs'][0]['coverage'],++)++PY++++python scripts/benchmark_real_audio_performance.py \++ data/source/reference-recording.wav --baseline "$PERF_BASELINE" \++ --ridge-config data/source/reproduce-local.json \++ --repeats 3 --output results/new-audio-comparison++++python scripts/benchmark_real_performance_helpers.py \++ --index "$PERF_INDEX" \++ --bounds -73.87498229500986 40.62693175890468 -73.17498229500987 41.12693175890468 \++ --time-range 1788897749.6620934 1788903449.6620934 \++ --baseline "$PERF_BASELINE" --repeats 3 --output results/new-helper-comparison++++python scripts/benchmark_real_track_cache.py --index "$PERF_INDEX" \++ --bounds -74.299988 40.100005 -72.700011 41.599964 \++ --time-range 1788898500 1788902400 --passes 4 \++ --output results/new-track-cache.json++++python scripts/benchmark_real_empty_tiles.py --index "$PERF_INDEX" \++ --tiles 256 --batch-size 32 --passes 3 --output results/new-empty-tile-comparison++```++++For the dense cache case, substitute bounds `-74.05 40.55 -73.55 41.05`, times `1788825600 1788912000`, and limits `--max-tracks 5000 --max-samples 750000`. The portable empty-tile fixture contains completed checkpoints from a failed baseline run. It compares all scientific index inputs and source byte hashes, allowing only local source paths to change after restoration.++++## Verification and complete workflows++++The merged core revision passed **23 focused real-input checks in 2.47 seconds**, plus CLI help. No synthetic suite ran. Component gates require exact measured arrays, diagnostics, accounting, and logical ledger contents. Numeric differences fail these gates. Event thresholds, harmonic grouping, clock domains, coverage requirements, and unknown-support rules remain unchanged. The regional archive excludes known jets and cannot establish complete coverage. Historical receiver and clock hypotheses do not provide independent accuracy evidence.++++Configured scoring with one versus four workers took **63.08 versus 50.86 seconds**, a 1.24× improvement in one sequential pair. This uses upstream [PR #210](https://github.com/1337isnot1337/DOPPLERGEIST/pull/210) from `adbfb3e`, with the same local changes in both arms. All 16 scientific JSON artifacts, three CSV files, and 283 ranked rows match after explicit metadata exclusions. The source-informed configured replay remains unaccepted, with incomplete model support.++++The complete automatic HTTP comparison is pending. Two original baseline attempts stopped with retention database errors. Their cause is unestablished. The system-runtime baseline reached its 900-second HTTP timeout. Its original receipt remains failed. A separate continuation preserves the baseline source and inputs and records restart/replay costs explicitly.++++After both workers stop, the comparator requires full-workflow evidence and compares discovery, candidates, clocks, associations, diagnostics, decisions, and logical retention ledgers. It ignores only enumerated implementation and run metadata. Use the explicit continuation report:++++```bash++python scripts/compare_real_upload_performance.py \++ --baseline path/to/baseline --current path/to/current \++ --baseline-continuation path/to/baseline/continuation.json \++ --output results/new-upload-comparison.json++```++++A resumed baseline can establish scientific parity. Its cumulative active-time ratio is reported separately and cannot establish an uninterrupted fresh-run speedup. Stage history has polling uncertainty. Failed or incomplete workflows do not qualify for an overall speedup claim.diff --cc scripts/benchmark_real_empty_tiles.pyindex 7fda696,0000000..74ad5c9mode 100644,000000..100644--- a/scripts/benchmark_real_empty_tiles.py+++ b/scripts/benchmark_real_empty_tiles.py@@@ -1,130 -1,0 +1,176 @@@+"""Replay recorded empty tiles, comparing ordinary commits with bounded batches.+- Supply an existing real search directory and its original native flight index.- Every timed path queries the original data and must reproduce each saved tile.++Supply a restored real flight index. The committed fixture contains 256 actual++completed tiles and their query settings. --search instead replays an existing++search directory against its original index. Every timed path queries the real++data and must reproduce each saved tile.+This measures empty coarse tiles only, not complete search or location accuracy.+"""+import argparse+from contextlib import nullcontext+import json+from pathlib import Path+import platform+import sqlite3+import statistics+import time++from dopplergeist.data_access import FlightIndex, content_hash, sha256, write_json+from dopplergeist.finite_search import RetentionLedger+from dopplergeist.tiled_search import (SearchBudget, _expanded_bounds, _tile_coordinates,+ _tracks, grid_tiles, merge_candidates)++++def portable_index_identity(report):++ """Preserve every input identity field except the local source file path."""++ keys = ("index_version", "sources", "coverage", "normalizer_sha256",++ "classification_map_hash", "max_gap_s", "max_flight_samples")++ identity = {key: report[key] for key in keys}++ if content_hash(identity) != report["input_hash"]:++ raise ValueError("Flight index input identity is inconsistent")++ identity["sources"] = [{key: value for key, value in source.items() if key != "path"}++ for source in identity["sources"]]++ return identity+++++def ledger_contents(ledger):+ with ledger.connect() as db:+ return {table: db.execute(f"SELECT * FROM {table} ORDER BY 1,2").fetchall()+ for table in ("run", "stages", "records", "bounds")}+++def main():+ parser = argparse.ArgumentParser(description=__doc__)- parser.add_argument("--search", type=Path, required=True)++ inputs = parser.add_mutually_exclusive_group()++ inputs.add_argument("--search", type=Path,++ help="Existing real search with completed tile checkpoints and original index")++ inputs.add_argument("--fixture", type=Path,++ help="Portable recorded-tile fixture; defaults to the committed 256-tile workload")+ parser.add_argument("--index", type=Path, action="append", required=True)+ parser.add_argument("--tiles", type=int, default=256)+ parser.add_argument("--batch-size", type=int, default=32)+ parser.add_argument("--passes", type=int, default=3)+ parser.add_argument("--output", type=Path, required=True)+ args = parser.parse_args()+ if min(args.tiles, args.batch_size, args.passes) <= 0:+ parser.error("tile, batch and pass counts must be positive")- args.output.mkdir(parents=True, exist_ok=False)- manifest = json.loads((args.search / "manifest.json").read_text())- config, run_hash = manifest["configuration"], manifest["run_hash"]- if content_hash(config) != run_hash:- raise ValueError("Saved manifest identity mismatch")+ indexes = [FlightIndex(path) for path in args.index]+ identities = [{"input_hash": index.report["input_hash"], "file_sha256": sha256(index.path)}+ for index in indexes]- if identities != config["indexes"]:- raise ValueError("Indexes differ from the saved real search")++ if args.search:++ manifest = json.loads((args.search / "manifest.json").read_text())++ config, run_hash = manifest["configuration"], manifest["run_hash"]++ if content_hash(config) != run_hash:++ raise ValueError("Saved manifest identity mismatch")++ if identities != config["indexes"]:++ raise ValueError("Indexes differ from the saved real search")++ radius = max(event["slant_range_m"][1] for event in config["events"])++ mode = config["scoring"].get("mode", "brightness")++ score_kind = ("matched_group_support_minus_normalized_residual"++ if mode == "robust_ridge" and config["filters"]["association"] == "subsets"++ else {"robust_ridge": "negative_robust_ridge_loss_hz", "ridge": "negative_ridge_rmse_hz",++ "brightness": "summed_spectral_contrast"}[mode])++ recorded = None++ else:++ args.fixture = args.fixture or Path(__file__).resolve().parents[1] / "tests/data/real-empty-tile-workload.json"++ fixture = json.loads(args.fixture.read_text())++ if fixture["schema_version"] != 1:++ raise ValueError("Unsupported recorded-tile fixture version")++ if [portable_index_identity(index.report) for index in indexes] != fixture["index_inputs"]:++ raise ValueError("Index source bytes or scientific input settings differ from the recorded workload")++ config, run_hash = fixture["query"], fixture["run_hash"]++ radius, score_kind = config["radius_m"], fixture["score_kind"]++ recorded = {}++ for tile in fixture["tiles"]:++ payload = dict(fixture["empty_payload"], cells=tile["cells"])++ if tile["tile_id"] in recorded:++ raise ValueError("Duplicate tile in the recorded workload")++ recorded[tile["tile_id"]] = {"run_hash": run_hash, "payload_hash": tile["payload_hash"],++ "payload": payload}+ budget = SearchBudget(**config["budget"])+ bounds, crs = config["bounds"], config["crs"]- radius = max(event["slant_range_m"][1] for event in config["events"])- mode = config["scoring"].get("mode", "brightness")- score_kind = ("matched_group_support_minus_normalized_residual"- if mode == "robust_ridge" and config["filters"]["association"] == "subsets"- else {"robust_ridge": "negative_robust_ridge_loss_hz", "ridge": "negative_ridge_rmse_hz",- "brightness": "summed_spectral_contrast"}[mode])+ tiles = []+ for tile_id, cells in grid_tiles(bounds, budget.spacing_m, budget.tile_cells, crs):- path = args.search / f"tile-{tile_id}.json"- if not path.exists():- continue- saved = json.loads(path.read_text())++ if recorded is None:++ path = args.search / f"tile-{tile_id}.json"++ if not path.exists():++ continue++ saved = json.loads(path.read_text())++ else:++ saved = recorded.get(tile_id)++ if saved is None:++ continue+ payload = saved["payload"]- if saved["run_hash"] != run_hash or saved["payload_hash"] != content_hash(payload):- raise ValueError(f"Invalid recorded tile: {path}")++ if (saved["run_hash"] != run_hash or saved["payload_hash"] != content_hash(payload)++ or payload["cells"] != list(cells)):++ raise ValueError(f"Invalid recorded tile: {tile_id}")+ if payload["ranked"] or payload["counts"] or payload["tracks"]:+ continue+ if not len(_tile_coordinates(cells, budget.spacing_m, bounds, crs)):+ continue+ tiles.append((tile_id, cells, saved))+ if len(tiles) == args.tiles:+ break+ if len(tiles) != args.tiles:+ raise ValueError(f"Only {len(tiles)} recorded empty tiles with receiver cells were available")+++ args.output.mkdir(parents=True, exist_ok=False)+ expected_contents = None+ results = {"ordinary": [], "batched": []}+ for pass_number in range(args.passes):+ order = ("ordinary", "batched") if pass_number % 2 == 0 else ("batched", "ordinary")+ for name in order:+ output = args.output / f"{name}-{pass_number + 1}"+ output.mkdir()+ ledger = RetentionLedger(output / "retention.sqlite", run_hash, score_kind)+ batch_size = 1 if name == "ordinary" else args.batch_size+ started, cpu_started = time.perf_counter(), time.process_time()+ for first in range(0, len(tiles), batch_size):+ with ledger.batch() if batch_size > 1 else nullcontext():+ for tile_id, cells, saved in tiles[first:first + batch_size]:+ points = _tile_coordinates(cells, budget.spacing_m, bounds, crs)+ tracks = _tracks(indexes, _expanded_bounds(cells, budget.spacing_m, radius, crs),+ config["time_range_s"], budget) if len(points) else []+ if tracks:+ raise AssertionError(f"Recorded empty tile now has tracks: {tile_id}")+ stage = f"coarse:{tile_id}"+ ledger.record(stage, [], [], 0)+ payload = {"ranked": [], "counts": {}, "grid_points": 0, "tracks": 0,+ "cells": list(cells), "terrain_files": [], "terrain_ocean_tiles": [],+ "terrain_failures": [], "retention_checksum": ledger.checksum(stage)}+ checkpoint = {"run_hash": run_hash, "payload_hash": content_hash(payload), "payload": payload}+ if checkpoint != saved:+ raise AssertionError(f"Recorded tile changed: {tile_id}")+ write_json(output / f"tile-{tile_id}.json", checkpoint)+ merge_candidates([], budget.top_k, ledger=ledger, stage=f"global:{tile_id}")+ results[name].append({"wall_s": time.perf_counter() - started,+ "cpu_s": time.process_time() - cpu_started})+ contents = ledger_contents(ledger)+ if expected_contents is None:+ expected_contents = contents+ if contents != expected_contents:+ raise AssertionError("Retention tables changed between runs")+ for tile_id, _, saved in tiles:+ for phase in ("coarse", "global"):+ if not ledger.stage_valid(f"{phase}:{tile_id}", saved["payload"]["retention_checksum"]):+ raise AssertionError("Committed stage fails normal resume validation")+ medians = {name: statistics.median(row["wall_s"] for row in rows) for name, rows in results.items()}+ summary = {"scope": "Recorded empty coarse tiles with receiver cells; includes geometry, real index queries, "+ "coarse/global stages, checksums and checkpoint writes; excludes progress/resume reads",- "source_search": str(args.search), "indexes": identities, "tiles": len(tiles),++ "source_search": str(args.search) if args.search else None,++ "source_fixture": str(args.fixture.resolve()) if args.fixture else None,++ "index_identity_check": "original input and file hashes" if args.search else++ "all input fields except local source paths",++ "indexes": identities, "tiles": len(tiles),+ "batch_size": args.batch_size, "passes": args.passes,+ "runtime": {"python": platform.python_version(), "sqlite": sqlite3.sqlite_version},+ "timings": results, "median_wall_s": medians,+ "speedup": medians["ordinary"] / medians["batched"],+ "all_checkpoints_match_recorded_tiles": True, "all_ledger_tables_match": True,+ "all_committed_stages_valid": True, "stage_count": len(expected_contents["stages"])}+ write_json(args.output / "summary.json", summary)+ print(json.dumps(summary, indent=2))+++if __name__ == "__main__":+ main()diff --cc scripts/benchmark_real_performance_helpers.pyindex 60a1cb9,0000000..9d34aa8mode 100644,000000..100644--- a/scripts/benchmark_real_performance_helpers.py+++ b/scripts/benchmark_real_performance_helpers.py@@@ -1,172 -1,0 +1,181 @@@+#!/usr/bin/env python3+"""Compare identity/terrain helpers on restored observations and candidate rows.++This is a component benchmark. Both duplicate-query variants use the same+current, cache-disabled FlightIndex so the identity change is measured alone.+No observations, receiver results, or timing evidence are generated artificially.+"""+import argparse+import importlib.util+import json+import os+from pathlib import Path+from statistics import median+import sys+import time++import numpy as np++from dopplergeist import terrain, tiled_search+from dopplergeist.data_access import FlightIndex, content_hash+++def load_module(name, path):+ spec = importlib.util.spec_from_file_location(name, path)+ module = importlib.util.module_from_spec(spec)+ sys.modules[name] = module+ spec.loader.exec_module(module)+ return module+++def json_geometry_digest(track):+ return content_hash([track.id, track.time.tolist(), track.xyz.tolist(), track.spline.c.tolist()])+++def identity_partition(values):+ groups = {}+ for index, value in enumerate(values):+ groups.setdefault(value, []).append(index)+ return sorted(groups.values())+++def assert_tracks_equal(actual, expected):+ assert [track.id for track in actual] == [track.id for track in expected]+ for got, want in zip(actual, expected):+ for name in ("time", "xyz"):+ np.testing.assert_array_equal(getattr(got, name), getattr(want, name))+ np.testing.assert_array_equal(got.spline.c, want.spline.c)+++def timed(function):+ wall, cpu = time.perf_counter(), time.process_time()+ result = function()+ return result, {"wall_s": time.perf_counter() - wall, "cpu_s": time.process_time() - cpu}+++def compare(functions, repeats, verify):+ trials = {name: [] for name in functions}+ names = list(functions)+ for iteration in range(repeats):+ for name in names if iteration % 2 == 0 else reversed(names):+ result, elapsed = timed(functions[name])+ verify(name, result)+ trials[name].append(elapsed)+ medians = {name: {metric: median(row[metric] for row in rows)+ for metric in ("wall_s", "cpu_s")}+ for name, rows in trials.items()}+ return {"trials": trials, "median": medians,+ "wall_speedup": medians["baseline"]["wall_s"] / medians["current"]["wall_s"],+ "cpu_speedup": medians["baseline"]["cpu_s"] / medians["current"]["cpu_s"]}+++def close_terrain(sampler):+ for raster in sampler.rasters:+ raster.close()+ if sampler.geoid:+ close_terrain(sampler.geoid)+++def main():+ parser = argparse.ArgumentParser(description=__doc__)- parser.add_argument("--fixture", type=Path, required=True,- help="Real search fixture containing index path and query bounds/time")++ parser.add_argument("--fixture", type=Path,++ help="Optional historical fixture containing index path and query bounds/time")++ parser.add_argument("--index", type=Path, help="Restored real flight index; overrides the fixture path")++ parser.add_argument("--bounds", type=float, nargs=4, metavar=("W", "S", "E", "N"))++ parser.add_argument("--time-range", type=float, nargs=2, metavar=("START", "END"))+ parser.add_argument("--baseline", type=Path, required=True)+ parser.add_argument("--output", type=Path, required=True)+ parser.add_argument("--repeats", type=int, default=3)+ args = parser.parse_args()+ if args.repeats < 1:+ parser.error("--repeats must be positive")- args.output.mkdir(parents=True, exist_ok=False)+ root = Path(__file__).resolve().parents[1]- fixture = json.loads(args.fixture.read_text())- index_path = fixture["real_index"]- query_args = fixture["query_bounds"], fixture["query_time_s"]++ fixture = json.loads(args.fixture.read_text()) if args.fixture else {}++ index_path = args.index or fixture.get("real_index")++ bounds = args.bounds or fixture.get("query_bounds")++ time_range = args.time_range or fixture.get("query_time_s")++ if index_path is None or bounds is None or time_range is None:++ parser.error("Supply --index, --bounds and --time-range, or a fixture containing those values")++ query_args = bounds, time_range++ args.output.mkdir(parents=True, exist_ok=False)+ baseline_tiles = load_module("dopplergeist._reference_helper_tiles",+ args.baseline / "src/dopplergeist/tiled_search.py")+ baseline_terrain = load_module("dopplergeist._reference_helper_terrain",+ args.baseline / "src/dopplergeist/terrain.py")++ def decode():+ return list(FlightIndex(index_path, track_cache_bytes=0).query(*query_args))++ first, second = decode(), decode()+ assert first and all(a is not b for a, b in zip(first, second))+ assert_tracks_equal(first, second)+ old = [json_geometry_digest(track) for track in first + second]+ new = [tiled_search._track_geometry_digest(track) for track in first + second]+ assert identity_partition(old) == identity_partition(new)+ expected_digests = {"baseline": old[:len(first)], "current": new[:len(first)]}++ def verify_digests(name, result):+ assert result == expected_digests[name]++ digest_results = compare({+ "baseline": lambda: [json_geometry_digest(track) for track in first],+ "current": lambda: [tiled_search._track_geometry_digest(track) for track in first],+ }, args.repeats, verify_digests)+ print(json.dumps({"stage": "identity_digest", **digest_results["median"]}), flush=True)++ def duplicate_query(module):+ indexes = [FlightIndex(index_path, track_cache_bytes=0) for _ in range(2)]+ return module._tracks(indexes, *query_args, tiled_search.SearchBudget())++ duplicate_results = compare({+ "baseline": lambda: duplicate_query(baseline_tiles),+ "current": lambda: duplicate_query(tiled_search),+ }, args.repeats, lambda name, result: assert_tracks_equal(result, first))+ print(json.dumps({"stage": "duplicate_query", **duplicate_results["median"]}), flush=True)++ rows = json.loads((root / "evidence/results/reference-local-fast/ranked.json").read_text())+ lat, lon = [np.asarray([row[key] for row in rows]) for key in ("lat", "lon")]+ dem = root / "data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif"+ geoid = root / "data/terrain/us_nga_egm96_15.tif"+ samplers = {name: module.Terrain([dem], geoid_path=geoid)+ for name, module in (("baseline", baseline_terrain), ("current", terrain))}+ terrain._raster_transformer.cache_clear()+ try:+ expected = samplers["baseline"].sample(lat, lon)+ np.testing.assert_array_equal(samplers["current"].sample(lat, lon), expected)++ def scalar_samples(name):+ return np.asarray([samplers[name].sample(a, b).item() for a, b in zip(lat, lon)])++ scalar_results = compare({name: lambda name=name: scalar_samples(name) for name in samplers},+ args.repeats, lambda name, result: np.testing.assert_array_equal(result, expected))+ vector_results = compare({name: lambda name=name: samplers[name].sample(lat, lon) for name in samplers},+ args.repeats, lambda name, result: np.testing.assert_array_equal(result, expected))+ cache_info = terrain._raster_transformer.cache_info()._asdict()+ finally:+ for sampler in samplers.values():+ close_terrain(sampler)++ summary = {"scope": "Real observations and archived candidate coordinates; component timings only",- "fixture": str(args.fixture.resolve()), "baseline": str(args.baseline.resolve()),- "cpu_affinity": sorted(os.sched_getaffinity(0)),++ "fixture": str(args.fixture.resolve()) if args.fixture else None,++ "index": str(Path(index_path).resolve()), "query_bounds": bounds, "query_time_s": time_range,++ "baseline": str(args.baseline.resolve()),++ "cpu_affinity": sorted(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else None,+ "threads": {key: os.environ.get(key) for key in+ ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS")},+ "tracks": len(first), "samples": sum(len(track.time) for track in first),+ "independent_decodes_exact": True, "old_new_identity_relation_exact": True,+ "duplicate_track_geometry_exact": True, "terrain_arrays_exact": True,+ "candidate_rows": len(rows), "unique_candidate_coordinates": len(set(zip(lat, lon))),+ "identity_digest": digest_results, "duplicate_index_query": duplicate_results,+ "terrain_scalar_queries": scalar_results, "terrain_vector_query": vector_results,+ "terrain_transform_cache": cache_info}+ (args.output / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")+ print(json.dumps({"output": str(args.output / "summary.json"),+ "speedups": {name: summary[name]["wall_speedup"] for name in+ ("identity_digest", "duplicate_index_query", "terrain_scalar_queries",+ "terrain_vector_query")}}), flush=True)+++if __name__ == "__main__":+ main()diff --cc scripts/compare_real_upload_performance.pyindex 860a51e,0000000..0d5727fmode 100644,000000..100644--- a/scripts/compare_real_upload_performance.py+++ b/scripts/compare_real_upload_performance.py@@@ -1,295 -1,0 +1,369 @@@+#!/usr/bin/env python3+"""Compare two completed real verify_upload_http.py runs without rerunning fits.++Exit zero requires verified full workflows and exact scientific parity. JSON+numbers have no tolerance. Search checkpoints and logical retention rows are+included. The existing verifier owns input and artifact integrity checks.++An explicit continuation report can qualify a resumed baseline for scientific++comparison, but its cumulative active cost is never labeled a fresh-run speedup.+"""+from __future__ import annotations++import argparse+from collections import Counter+from contextlib import ExitStack+from datetime import datetime+import hashlib+from itertools import zip_longest+import json+import math+from pathlib import Path+import sqlite3+++IMPLEMENTATION_FIELDS = {"implementation_files", "run_hash", "search_run_hash",+ "source_fit_code_sha256", "score_code_sha256", "verifier_sha256"}+PERFORMANCE_FIELDS = {"elapsed_s", "process_peak_rss_mib"}+ROOT_JSON = ("upload-request.json", "operator.json", "result.json")+REQUIRED_STAGES = {"automatic_provenance", "intake", "discovery", "acquisition",+ "search", "refinement", "decision"}+MISSING = object()+++def read_json(path):+ def reject(value):+ raise ValueError(f"Nonfinite JSON constant in {path}: {value}")+ return json.loads(path.read_text(), parse_constant=reject)+++def encoded(value):+ return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()+++def summary_value(value):+ if value is MISSING:+ return {"missing": True}+ if isinstance(value, (dict, list)) or (isinstance(value, str) and len(value) > 500):+ return {"type": type(value).__name__, "length": len(value),+ "sha256": hashlib.sha256(encoded(value)).hexdigest()}+ return value+++class Differences:+ def __init__(self, limit):+ self.limit, self.count = limit, 0+ self.examples, self.categories, self.files = [], Counter(), set()+ self.numeric_count, self.maximum_absolute_numeric_difference = 0, 0.0++ def add(self, artifact, path, left, right):+ self.count += 1+ self.files.add(artifact)+ category = "job/search/tile-*.json" if artifact.startswith("job/search/tile-") else artifact+ self.categories[category] += 1+ detail = {"artifact": artifact, "path": "/" + "/".join(map(str, path)),+ "baseline": summary_value(left), "current": summary_value(right)}+ if type(left) in (int, float) and type(right) in (int, float):+ absolute = abs(right - left)+ self.numeric_count += 1+ self.maximum_absolute_numeric_difference = max(self.maximum_absolute_numeric_difference, absolute)+ detail["absolute_difference"] = absolute+ if len(self.examples) < self.limit:+ self.examples.append(detail)++ def compare(self, artifact, left, right, path=()):+ if type(left) is not type(right):+ self.add(artifact, path, left, right)+ elif isinstance(left, dict):+ for key in sorted(left.keys() | right.keys()):+ if key not in left or key not in right:+ self.add(artifact, path + (key,), left.get(key, MISSING), right.get(key, MISSING))+ else:+ self.compare(artifact, left[key], right[key], path + (key,))+ elif isinstance(left, list):+ if len(left) != len(right):+ self.add(artifact, path + ("length",), len(left), len(right))+ for index, (a, b) in enumerate(zip_longest(left, right, fillvalue=MISSING)):+ if a is MISSING or b is MISSING:+ self.add(artifact, path + (index,), a, b)+ else:+ self.compare(artifact, a, b, path + (index,))+ elif left != right or (isinstance(left, float) and left == 0+ and math.copysign(1, left) != math.copysign(1, right)):+ self.add(artifact, path, left, right)++ def report(self):+ return {"count": self.count, "changed_artifact_count": len(self.files),+ "counts_by_artifact": dict(sorted(self.categories.items())),+ "numeric_difference_count": self.numeric_count,+ "maximum_absolute_numeric_difference": self.maximum_absolute_numeric_difference,+ "examples": self.examples, "examples_truncated": self.count > len(self.examples)}+++class Run:- def __init__(self, directory):++ def __init__(self, directory, continuation=None):+ self.directory = directory.resolve()++ if (self.directory / "continuation-start.json").exists() and continuation is None:++ raise ValueError("This job has a continuation; supply its completed --baseline-continuation report")+ # This receipt is committed after service shutdown and verifier checks.+ # Refuse to inspect any job or SQLite database before it exists.+ receipt = self.directory / "http-verification.json"+ if not receipt.is_file():+ raise ValueError(f"Run has no completed HTTP verification receipt: {directory}")+ self.receipt = read_json(receipt)+ if "finished_utc" not in self.receipt or "elapsed_s" not in self.receipt:+ raise ValueError(f"HTTP verification receipt is unfinished: {directory}")+ if self.receipt.get("service", {}).get("returncode") is None:+ raise ValueError(f"Service termination is not established; refusing to inspect its ledger: {directory}")++ self.continuation = read_json(continuation) if continuation is not None else None++ if self.continuation is not None:++ record = self.continuation++ if (record.get("scope") != "resumed_automatic_baseline_continuation"++ or record.get("resumed_baseline") is not True or record.get("fresh_run") is not False++ or record.get("job_id") != self.receipt["job_id"]++ or Path(record["baseline_directory"]).resolve() != self.directory):++ raise ValueError("Continuation report does not identify this resumed baseline")++ if record.get("worker_shutdown_confirmed") is not True:++ raise ValueError("Continuation worker shutdown is not confirmed; refusing to inspect its ledger")+ self.job = self.directory / "jobs" / self.receipt["job_id"]++ self.final = read_json(self.job / "result.json")++ if self.final.get("status") in {"running", "queued"}:++ raise ValueError("Job is active; refusing to inspect its ledger")+ self.ignored = Counter()++ def normalize(self, value, relative, root=False, path=()):+ if isinstance(value, dict):+ result = {}+ for key, item in value.items():+ here = path + (key,)+ reason = None+ if key in IMPLEMENTATION_FIELDS:+ reason = f"field:{key}"+ elif key in PERFORMANCE_FIELDS:+ reason = f"performance:{key}"+ elif not root and relative == "provenance.json" and here == ("operator_configuration_sha256",):+ reason = "operator configuration digest; full normalized operator.json is compared"+ elif not root and relative == "search/manifest.json" and here == ("configuration", "code"):+ reason = "search implementation files"++ elif not root and relative == "provenance.json" and here == ("resumed_from",):++ reason = "explicit resume metadata: resumed_from"++ elif not root and relative == "search/search-report.json" and here == ("tiles_resumed",):++ reason = "explicit resume performance metadata: tiles_resumed"+ if reason:+ self.ignored[reason] += 1+ continue+ normalized_key = self.normalize(key, relative, root, path)+ result[normalized_key] = self.normalize(item, relative, root, here)+ return result+ if isinstance(value, list):+ return [self.normalize(item, relative, root, path + (index,)) for index, item in enumerate(value)]+ if isinstance(value, str):+ return (value.replace(str(self.job), "<job>")+ .replace(str(self.directory), "<run>")+ .replace(self.receipt["job_id"], "<job-id>"))+ return value++ def json(self, relative, *, root=False):+ return self.normalize(read_json((self.directory if root else self.job) / relative), relative, root)++ def full_pipeline(self):++ if self.continuation is not None:++ record = self.continuation++ evidence = record.get("pipeline_evidence", {})++ segments = record.get("segments", [])++ timed = (len(segments) >= 2 and all(++ isinstance(segment.get(key), (int, float)) and not isinstance(segment.get(key), bool)++ and math.isfinite(segment[key]) and segment[key] >= 0++ for segment in segments for key in ("wall_s", "cpu_s")))++ timed = timed and all(math.isclose(record.get(total, -1), sum(segment[key] for segment in segments),++ rel_tol=1e-12, abs_tol=1e-9)++ for key, total in (("wall_s", "cumulative_active_wall_s"),++ ("cpu_s", "cumulative_cpu_s")))++ return (all(record.get(key) is True for key in++ ("original_http_receipt_unchanged", "implementation_unchanged",++ "worker_shutdown_confirmed", "pipeline_evidence_passed",++ "full_pipeline_observed", "full_pipeline_requirements_met"))++ and timed and segments[-1].get("returncode") == 0++ and record.get("final_status") == self.final.get("status")++ and record.get("reason_code") == self.final.get("reason_code")++ and record.get("candidate_count") == len(self.final.get("candidates", [])) > 0++ and record.get("event_count") == len(self.final.get("events", []))++ and record.get("source_sha256") == self.receipt.get("source_sha256")++ and self.final.get("recording", {}).get("source_sha256") == self.receipt.get("source_sha256")++ and evidence.get("passed") is True and evidence.get("full_pipeline_observed") is True++ and REQUIRED_STAGES.issubset(evidence.get("stages_verified", [])))+ evidence = read_json(self.directory / "pipeline-evidence.json")+ return (all(self.receipt.get(key) is True for key in+ ("verification_passed", "http_checks_passed", "pipeline_evidence_passed",+ "full_pipeline_observed", "full_pipeline_requirements_met"))+ and self.receipt.get("candidate_count", 0) > 0+ and evidence.get("passed") is True and evidence.get("full_pipeline_observed") is True+ and REQUIRED_STAGES.issubset(evidence.get("stages_verified", [])))++ def timing(self):+ rows = [json.loads(line) for line in (self.directory / "history.jsonl").read_text().splitlines()]+ timestamp = lambda value: datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()+ transitions = []+ for row in rows:+ result = row["result"]+ stage = result.get("stage") if result["status"] in ("running", "queued") else "terminal:" + result["status"]+ if not transitions or transitions[-1]["stage"] != stage:+ transitions.append({"stage": stage, "observed_utc": row["observed_utc"]})+ totals = Counter()+ for current, following in zip(transitions, transitions[1:]):+ duration = timestamp(following["observed_utc"]) - timestamp(current["observed_utc"])+ current["until_next_transition_s"] = duration+ totals[current["stage"]] += duration- return {"receipt_elapsed_s": self.receipt["elapsed_s"], "poll_records": len(rows),- "observed_stage_seconds": dict(totals), "transitions": transitions,- "note": "Stage durations use first observed HTTP transitions and include polling uncertainty; unobserved short stages have no inferred duration."}++ result = {"receipt_elapsed_s": self.receipt["elapsed_s"], "poll_records": len(rows),++ "observed_stage_seconds": dict(totals), "transitions": transitions,++ "note": "Stage durations use first observed HTTP transitions and include polling uncertainty; unobserved short stages have no inferred duration."}++ if self.continuation is not None:++ result["continuation"] = {key: self.continuation[key] for key in++ ("segments", "cumulative_active_wall_s", "cumulative_cpu_s")}++ result["note"] += " History describes the original HTTP attempt only. Continuation segments exclude idle time between attempts and are not a fresh run."++ return result+++def ignored_artifact(relative):- return relative in {"resume.json", "intake/intake.json"} or relative.startswith("search/.tile-workers/")++ return (relative in {"resume.json", "intake/intake.json"}++ or relative.startswith("search/.tile-workers/")++ or (relative.startswith("result-before-resume-") and relative.endswith(".json")))+++def quote_identifier(value):+ return '"' + value.replace('"', '""') + '"'+++def compare_ledger(left, right, relative, differences):+ artifact = "job/" + relative+ with ExitStack() as stack:+ databases = []+ for run in (left, right):+ connection = sqlite3.connect((run.job / relative).as_uri() + "?mode=ro", uri=True)+ stack.callback(connection.close)+ databases.append(connection)+ table_sets = [{row[0] for row in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}+ for db in databases]+ differences.compare(artifact, sorted(table_sets[0]), sorted(table_sets[1]), ("tables",))+ counts = [{}, {}]+ for table in sorted(table_sets[0] & table_sets[1]):+ schemas = [db.execute(f"PRAGMA table_info({quote_identifier(table)})").fetchall() for db in databases]+ differences.compare(artifact, schemas[0], schemas[1], (table, "schema"))+ cursors, columns = [], []+ for db, schema in zip(databases, schemas):+ names = [row[1] for row in schema]+ columns.append(names)+ keys = [row[1] for row in sorted(schema, key=lambda row: row[5]) if row[5]] or names+ order = ",".join(map(quote_identifier, keys))+ cursors.append(db.execute(f"SELECT * FROM {quote_identifier(table)} ORDER BY {order}"))+ for number, rows in enumerate(zip_longest(*cursors, fillvalue=MISSING)):+ normalized = []+ for side, row in enumerate(rows):+ if row is MISSING:+ normalized.append(MISSING)+ continue+ record = dict(zip(columns[side], row))+ if table == "run":+ record.pop("identity", None)+ for field in ({"stages": ("kept",), "records": ("seed",), "bounds": ("detail",)}.get(table, ())):+ record[field] = json.loads(record[field])+ counts[side][table] = counts[side].get(table, 0) + 1+ normalized.append(record)+ if any(row is MISSING for row in normalized):+ differences.add(artifact, (table, number), *normalized)+ else:+ differences.compare(artifact, *normalized, (table, number))+ return {"baseline_rows": counts[0], "current_rows": counts[1]}++- def compare_runs(baseline, current, max_examples=40):- left, right = Run(baseline), Run(current)++def compare_runs(baseline, current, max_examples=40, baseline_continuation=None):++ left, right = Run(baseline, baseline_continuation), Run(current)+ differences, checked, ledgers = Differences(max_examples), Counter(), {}+ selected = [{path.relative_to(run.job).as_posix() for path in run.job.rglob("*")+ if path.is_file() and path.suffix in {".json", ".sqlite"}+ and not ignored_artifact(path.relative_to(run.job).as_posix())} for run in (left, right)]+ differences.compare("job inventory", sorted(selected[0]), sorted(selected[1]))+ for name in sorted(selected[0] & selected[1]):+ try:+ if name.endswith(".json"):+ differences.compare("job/" + name, left.json(name), right.json(name))+ checked["json"] += 1+ elif name.endswith(".sqlite"):+ ledgers[name] = compare_ledger(left, right, name, differences)+ checked["sqlite"] += 1+ except (OSError, ValueError, sqlite3.DatabaseError) as error:+ differences.add("job/" + name, ("comparison_error",), str(error), MISSING)+ for name in ROOT_JSON:++ if name == "result.json" and left.continuation is not None:++ # The root result is the original HTTP snapshot, possibly absent++ # after a timeout. The final job/result.json is compared above.++ continue+ differences.compare("root/" + name, left.json(name, root=True), right.json(name, root=True))+ checked["root_json"] += 1+ differences.compare("HTTP source identity", {key: left.receipt.get(key) for key in ("source_sha256", "source_bytes")},+ {key: right.receipt.get(key) for key in ("source_sha256", "source_bytes")})+ full = {name: run.full_pipeline() for name, run in (("baseline", left), ("current", right))}+ passed = differences.count == 0 and all(full.values())+ timings = {name: run.timing() for name, run in (("baseline", left), ("current", right))}- return {"scope": "Exact semantic comparison of completed actual HTTP upload workflows",++ return {"scope": "Exact semantic comparison of actual upload workflows, with explicit continuation evidence when supplied",+ "baseline": str(left.directory), "current": str(right.directory),++ "run_kinds": {"baseline": "resumed_baseline" if left.continuation is not None else "fresh_http",++ "current": "fresh_http"},+ "passed": passed, "scientific_payloads_exact": differences.count == 0,+ "full_pipeline_verified": full,+ "checked_artifacts": dict(checked), "retention_ledgers": ledgers,- "outcomes": {name: {key: run.receipt.get(key) for key in- ("status", "reason_code", "candidate_count", "event_count", "supported_decision")}++ "outcomes": {name: {"status": run.final.get("status"), "reason_code": run.final.get("reason_code"),++ "candidate_count": len(run.final.get("candidates", [])),++ "event_count": len(run.final.get("events", []))}+ for name, run in (("baseline", left), ("current", right))},++ "original_http_outcomes": {name: {key: run.receipt.get(key) for key in++ ("status", "reason_code", "verification_passed", "full_pipeline_observed")}++ for name, run in (("baseline", left), ("current", right))},+ "differences": differences.report(), "timings": timings,- "verified_full_workflow_speedup": (left.receipt["elapsed_s"] / right.receipt["elapsed_s"] if passed else None),++ "verified_full_workflow_speedup": (left.receipt["elapsed_s"] / right.receipt["elapsed_s"]++ if passed and left.continuation is None else None),++ "resumed_active_wall_to_current_receipt_ratio": (++ left.continuation["cumulative_active_wall_s"] / right.receipt["elapsed_s"]++ if passed and left.continuation is not None else None),+ "normalization": {"implementation_fields": sorted(IMPLEMENTATION_FIELDS),+ "performance_fields": sorted(PERFORMANCE_FIELDS),+ "path_rule": "Only each run directory, job directory and exact job identifier are replaced.",+ "sqlite_rule": "Compare all logical tables, columns and rows; ignore only run.identity and physical SQLite/index layout.",- "excluded_metadata": ["resume.json", "intake/intake.json", "search/.tile-workers/**"],++ "excluded_metadata": ["resume.json", "intake/intake.json", "search/.tile-workers/**",++ "result-before-resume-*.json", "provenance.json/resumed_from",++ "search/search-report.json/tiles_resumed"],+ "scope": "Scientific JSON and logical ledger contents. Existing HTTP verification owns integrity checks; real-audio validation separately checks measured arrays.",+ "observed_ignored_counts": {"baseline": dict(left.ignored), "current": dict(right.ignored)}},+ "limitations": ["Exact parity establishes consistency with the baseline, not geolocation accuracy.",+ "No withheld-location comparison or synthetic observations are used.",++ "A resumed baseline retains its unsuccessful original HTTP receipt. Its cumulative active cost includes restart/replay overhead and is not uninterrupted runtime.",+ "All semantic differences fail the gate, including floating-point roundoff; examples alone are bounded."]}+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--baseline", type=Path, required=True)+ parser.add_argument("--current", type=Path, required=True)++ parser.add_argument("--baseline-continuation", type=Path,++ help="Explicit completed continuation evidence; never rewrites the original HTTP receipt")+ parser.add_argument("--output", type=Path, required=True, help="New JSON report path")+ parser.add_argument("--max-examples", type=int, default=40)+ args = parser.parse_args()+ if args.max_examples < 1:+ parser.error("--max-examples must be positive")- report = compare_runs(args.baseline, args.current, args.max_examples)++ report = compare_runs(args.baseline, args.current, args.max_examples, args.baseline_continuation)+ args.output.parent.mkdir(parents=True, exist_ok=True)+ with args.output.open("x") as stream:+ json.dump(report, stream, indent=2, allow_nan=False)+ stream.write("\n")+ print(json.dumps({"report": str(args.output), "passed": report["passed"],+ "scientific_payloads_exact": report["scientific_payloads_exact"],+ "semantic_differences": report["differences"]["count"],+ "full_pipeline_verified": report["full_pipeline_verified"],- "verified_full_workflow_speedup": report["verified_full_workflow_speedup"]}))++ "run_kinds": report["run_kinds"],++ "verified_full_workflow_speedup": report["verified_full_workflow_speedup"],++ "resumed_active_wall_to_current_receipt_ratio": report["resumed_active_wall_to_current_receipt_ratio"]}))+ return 0 if report["passed"] else 1+++if __name__ == "__main__":+ raise SystemExit(main())diff --cc tests/data/real-empty-tile-workload.jsonindex 0000000,0000000..5f5e317new file mode 100644--- /dev/null+++ b/tests/data/real-empty-tile-workload.json@@@ -1,0 -1,0 +1,340 @@@++{++ "schema_version": 1,++ "provenance": {++ "source_revision": "7a8dd27979bd9a984c8675c38a00dfbf98a5b01e",++ "recording_sha256": "707083f0344823eeea7f130faec6c22b6628b8b9fea04d026915d93df9a07b15",++ "observed_work": "First 256 completed empty coarse tiles with receiver cells, in grid order, from the stopped original automatic baseline. That full run failed; these completed checkpoints alone are replayed. No full-run or location-accuracy claim.",++ "input_path_rule": "Only local source paths are omitted from index input identity; source bytes and every scientific setting must match.",++ "original_index_input_hashes": [++ "db5e5207045e1a8df431fc697faa89bb8abb54d8a4001b4c114a68f48d0f9cf5"++ ]++ },++ "run_hash": "325db0284c070f24313517f8b8c0dcfde7e7baa79283c23a20f2c0f3250d2e24",++ "index_inputs": [++ {++ "index_version": 2,++ "sources": [++ {++ "sha256": "fa4e2b82849b3ea8c22ffbe50d4f8f00b7bb3727486307feeaab4821562718a0",++ "bytes": 32823780++ }++ ],++ "coverage": {++ "bounds": [++ -74.299988,++ 40.100005,++ -72.700011,++ 41.599964++ ],++ "time_range_s": [++ 1788825600.17,++ 1788911999.6++ ],++ "all_aircraft": false,++ "source_note": "Restored historical reference-region.parquet. The listed bounds and times are observed sample extrema, not established selection coverage. Original geographic selection bounds are unknown. The original ingestion excluded known jets. This index cannot establish complete coverage.",++ "selection_bounds_known": false,++ "extent_kind": "observed_sample_extrema_only"++ },++ "normalizer_sha256": "543f483cee756fdb9efdd69c8e8f05b32e290f19187af3523160f19d2eba90e0",++ "classification_map_hash": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",++ "max_gap_s": 30.0,++ "max_flight_samples": 250000++ }++ ],++ "query": {++ "bounds": [++ -125.0,++ 24.0,++ -66.0,++ 50.0++ ],++ "time_range_s": [++ 1788898745.8333333,++ 1788902290.1845++ ],++ "budget": {++ "spacing_m": 2000,++ "tile_cells": 16,++ "max_tracks_per_tile": 2000,++ "max_track_samples_per_tile": 500000,++ "max_cpa_rows": 100000,++ "max_candidates_per_tile": 20000,++ "top_k": 20,++ "refine_spacing_m": 500,++ "refine_finalists": 3,++ "cpa_step_s": 2.0,++ "max_tiles": null++ },++ "crs": "EPSG:5070",++ "radius_m": 20000.0++ },++ "score_kind": "matched_group_support_minus_normalized_residual",++ "empty_payload": {++ "ranked": [],++ "counts": {},++ "grid_points": 0,++ "tracks": 0,++ "terrain_files": [],++ "terrain_ocean_tiles": [],++ "terrain_failures": [],++ "retention_checksum": "d0edf5f14ccc1f891ccc12df579f8761517f5f41b207dede78db05ec223b257a"++ },++ "tiles": [++ {"tile_id":"-19_3","cells":[-304,54,-288,64],"payload_hash":"e7865cd12be208277dd5f9cc67b36e234cb082fd64f150eeff0e0aa73bc68b9f"},++ {"tile_id":"-18_3","cells":[-288,54,-272,64],"payload_hash":"5144df80628902bc30621f4a3b21b437d011ac32f44f69162f89ce6dd764c374"},++ {"tile_id":"-17_3","cells":[-272,54,-256,64],"payload_hash":"0c720a9c0eac9de93f7ed28e7ac89a70a024e892c3bbe5a79957942c649c9e30"},++ {"tile_id":"-16_3","cells":[-256,54,-240,64],"payload_hash":"8eb15a2463bbb56ba010e3da06a4c49c4f73cb202a5b521f91fa3e9cbbb6bd90"},++ {"tile_id":"-15_3","cells":[-240,54,-224,64],"payload_hash":"3076a21bef42860b1d8428f6e0ce81a8f3f0c3c81ec6c97d93be8738c1986854"},++ {"tile_id":"-14_3","cells":[-224,54,-208,64],"payload_hash":"db0997c66e1951c5494591d763e45e79fb5a67ad8bfa0ebcf342573c899fe21c"},++ {"tile_id":"-13_3","cells":[-208,54,-192,64],"payload_hash":"ce720e2cd092804422de91e77199fc21581f513e74861049cfcc2f79fc5e7c87"},++ {"tile_id":"-12_3","cells":[-192,54,-176,64],"payload_hash":"ef245dc044ea74b9baeac71396772e3c654a514f3a089814b36c33b2157fafdf"},++ {"tile_id":"-11_3","cells":[-176,54,-160,64],"payload_hash":"7bdf3f9bb725f6de7cfff5aa7d4787db28ef1218b4b3ccdfd2ad8ff43ffbc74a"},++ {"tile_id":"-10_3","cells":[-160,54,-144,64],"payload_hash":"e21f99a39a4aef3a04c7cd02f26b8ca0eae32c8089bc44213177d8bd97d36017"},++ {"tile_id":"-9_3","cells":[-144,54,-128,64],"payload_hash":"3e0c56115c5ed142e0ae3b84bf7ed86c75541be29e36e3a083b70e1c7077c471"},++ {"tile_id":"-8_3","cells":[-128,54,-112,64],"payload_hash":"630b7e6372e23f90fe09c0713c2bc85b2f81cf769ed9368d84488d95017bb491"},++ {"tile_id":"-7_3","cells":[-112,54,-96,64],"payload_hash":"b38e76de5c5ae62977b01ba978672ade894e2730750ed8770cf2f76790c874ff"},++ {"tile_id":"-6_3","cells":[-96,54,-80,64],"payload_hash":"e9956cb43918f0d589b0b16b8d6d9feea8c2cdb1ae7097666a00278236aa71f4"},++ {"tile_id":"-5_3","cells":[-80,54,-64,64],"payload_hash":"772161798f7bc4589694b48686e72c3e031b3212167bd9fc73d38ad0f4a54075"},++ {"tile_id":"-4_3","cells":[-64,54,-48,64],"payload_hash":"baaf05c7785e8e25b3266c17a841f9c2388af25367c60571cf0ce9b34364cab6"},++ {"tile_id":"-3_3","cells":[-48,54,-32,64],"payload_hash":"fc9ce0332b6bc6bfed3781778c84d3cd20c0cc3f6f24888b5d9629b30c038899"},++ {"tile_id":"-2_3","cells":[-32,54,-16,64],"payload_hash":"4ff001db0a909a2b999f63789a23946067a73b1d77a299e1dffbd6763743a45d"},++ {"tile_id":"-1_3","cells":[-16,54,0,64],"payload_hash":"0e72d853800188f7b15345278f77e11468b25e3bf3f52d838eb565af77a21848"},++ {"tile_id":"0_3","cells":[0,54,16,64],"payload_hash":"5604e2c996f21a010d93973268e0be53884183d5f9c8c93baa15ceefe43899d1"},++ {"tile_id":"1_3","cells":[16,54,32,64],"payload_hash":"b1d9d129345c328b2568cf2af5113fcb8a5125cff26b3133fbb28daa360b1ad3"},++ {"tile_id":"2_3","cells":[32,54,48,64],"payload_hash":"840ac8df132e154eaeb85649fbfe745aea030b8475747bfb4669fdf372fac8e6"},++ {"tile_id":"3_3","cells":[48,54,64,64],"payload_hash":"1d4dd7a4bba82407ccc430ee95e2a315dfeaa02c96a232c94a06047a21dea59d"},++ {"tile_id":"4_3","cells":[64,54,80,64],"payload_hash":"fdf4c74abd2851e5d52ac40253a70f357f77feae39e5f6d60edc44ce81b90131"},++ {"tile_id":"5_3","cells":[80,54,96,64],"payload_hash":"6dba0ecc500a840a5db9fc1889c45a649a8b79a9a152d4dbcd605b8cf0805e0f"},++ {"tile_id":"6_3","cells":[96,54,112,64],"payload_hash":"740a3675e09b20bcf732f2fe6b190da4a5400ef51bab55eeecd8e655001d0502"},++ {"tile_id":"7_3","cells":[112,54,128,64],"payload_hash":"12559099c0b6b23498793a24607e749f1db1a60759813ffb19c8aaac2fde32d3"},++ {"tile_id":"8_3","cells":[128,54,144,64],"payload_hash":"0b13e9f14c4d2361c743414f8a6ab1b20ce3d6ea8c8a2e4fc0ecaf9e5747ecfe"},++ {"tile_id":"9_3","cells":[144,54,160,64],"payload_hash":"9383dd033d528afa138cbd2c932f1277a140de3161f5d22ff0a39e17420c06c9"},++ {"tile_id":"10_3","cells":[160,54,176,64],"payload_hash":"4483dc09d69b11829eaff44bd8198bc7bd25ff24c0c58421ede98723e0efa063"},++ {"tile_id":"11_3","cells":[176,54,192,64],"payload_hash":"9e72c091f7e36a78c74acf22c2014f2d6100167a0cb1189907c558a03821a99f"},++ {"tile_id":"12_3","cells":[192,54,208,64],"payload_hash":"e6bda8f88627fcf7e74635100da53a94ef9d1f9fc70a37ce685953ca37f40fae"},++ {"tile_id":"13_3","cells":[208,54,224,64],"payload_hash":"a19a0cf93efe20aa19935582d6847a349f0081b3decd7864a58b1fa45eef6038"},++ {"tile_id":"14_3","cells":[224,54,240,64],"payload_hash":"eaa30c1ca69602aa9bee867ecf9a9ce7b61b22d8fda440bd7b917f3852a4700f"},++ {"tile_id":"15_3","cells":[240,54,256,64],"payload_hash":"b88af48a2ead655346c8e387651bd89dba8c5d31fd878abde2b16be2539b945e"},++ {"tile_id":"16_3","cells":[256,54,272,64],"payload_hash":"e2df7c789318458ae5a368e37c06d27bdfe816b6b42a8a7a2d8f9c2b534a1aa9"},++ {"tile_id":"17_3","cells":[272,54,288,64],"payload_hash":"d798aaae97e8b3e69bde60fe4f6bc725ffe4de1e253f20fd92fb6ffb1c8452c2"},++ {"tile_id":"18_3","cells":[288,54,304,64],"payload_hash":"6f96e0d766e05002b3b50de832255c7cbe28b82192538a03c894508ec0da580e"},++ {"tile_id":"-31_4","cells":[-496,64,-480,80],"payload_hash":"b89164782a88cdea82d6924ead9db4baa2f41eaef6e8dc8949776bbfd6d0c945"},++ {"tile_id":"-30_4","cells":[-480,64,-464,80],"payload_hash":"a08c1f98f876d840aa3f16dc2bf9d3b73a7549e15e8c93a26d0de4d9da32dccc"},++ {"tile_id":"-29_4","cells":[-464,64,-448,80],"payload_hash":"c99602a2a9c06622b44441ccfc2e60146f53e7a853fe311c14c4fac873a1fcb3"},++ {"tile_id":"-28_4","cells":[-448,64,-432,80],"payload_hash":"1dad7725d7c3d48982d7865b421922ea628eb4191f693c004a4c27b4304e1b7c"},++ {"tile_id":"-27_4","cells":[-432,64,-416,80],"payload_hash":"d3fe82eef97caca8ddbde90befd0f96ef73fd6d1356080d622027a2a31ada338"},++ {"tile_id":"-26_4","cells":[-416,64,-400,80],"payload_hash":"35e882ade007462e8440604b2ff394d0735a99d46de04d50010517aff012154a"},++ {"tile_id":"-25_4","cells":[-400,64,-384,80],"payload_hash":"d9bd65b3ae1d3c6b9a87578d61001b4469bd6268fcc75f83a137b33f83f7919c"},++ {"tile_id":"-24_4","cells":[-384,64,-368,80],"payload_hash":"bc4e510cf5b4686178fcc18b9e3c43c95bcc63ed4e00e880bb1c75bc8d489c92"},++ {"tile_id":"-23_4","cells":[-368,64,-352,80],"payload_hash":"d3ce85eeaf08c8e66d5ea2fa692be5e110030753c9dc4d0a3636bf51483b6135"},++ {"tile_id":"-22_4","cells":[-352,64,-336,80],"payload_hash":"7e24e07d0f1338f207018bf4a602f520b6b9287f7587042d250241bbd8c73fe3"},++ {"tile_id":"-21_4","cells":[-336,64,-320,80],"payload_hash":"22fceec28d27b778889a52f769a3921fe1d5bce097086343963be892f7b90074"},++ {"tile_id":"-20_4","cells":[-320,64,-304,80],"payload_hash":"5bf0a900e3afd281084d017cdd717fe28aedaf1b9ef8a2f660b656294002cab9"},++ {"tile_id":"-19_4","cells":[-304,64,-288,80],"payload_hash":"bc919caeb584b4982c593c293971cad61b077f7d6d570bb9955740196fbaab25"},++ {"tile_id":"-18_4","cells":[-288,64,-272,80],"payload_hash":"eb9634bc0a46e9ee9227f98ea039385371213f1fa4ac545c3e3ca4d2f594e289"},++ {"tile_id":"-17_4","cells":[-272,64,-256,80],"payload_hash":"5825bda0fc4b5d91635082dd25d04bd6b63b719cb638ca00fa8336f3690b3c94"},++ {"tile_id":"-16_4","cells":[-256,64,-240,80],"payload_hash":"ee6b31f7b9b83c72f1497425ca485b44c82efc0274bedaf71315529eca94691f"},++ {"tile_id":"-15_4","cells":[-240,64,-224,80],"payload_hash":"e33f22807f17f2ce6e2be0d8470a233f5ed69b89367b06c8f86bc6aea050412d"},++ {"tile_id":"-14_4","cells":[-224,64,-208,80],"payload_hash":"032a2e3b6fa2caa61e9475fbcb45fd4e33c0b6dcbbc6534092a969078d74bd28"},++ {"tile_id":"-13_4","cells":[-208,64,-192,80],"payload_hash":"6d251bab4f2df7ad8414a7f372ba520d379b1ac05e142b0f4ab09f0374c3f7b8"},++ {"tile_id":"-12_4","cells":[-192,64,-176,80],"payload_hash":"fca09447ace01b62860ec20512dc1b3ebe54ab485721d2d50e6d6111c6894ec2"},++ {"tile_id":"-11_4","cells":[-176,64,-160,80],"payload_hash":"a5b4df960a0ef7b085118a015c99c2eff09fecadfe15e8f8900dd3253e54b700"},++ {"tile_id":"-10_4","cells":[-160,64,-144,80],"payload_hash":"e5b611f7f6d32bd15ff3dbedb6ca64d51d13090aa5c1feea048be2226d0a8922"},++ {"tile_id":"-9_4","cells":[-144,64,-128,80],"payload_hash":"49fbd56b97b80941cc54081f6ffe79cfd33e2f27264238aed7bc33b9a6f5f209"},++ {"tile_id":"-8_4","cells":[-128,64,-112,80],"payload_hash":"563d72c4d29cc2088b7d45e9bab53db449528ad58f5a82019ed77f7c5f32c29b"},++ {"tile_id":"-7_4","cells":[-112,64,-96,80],"payload_hash":"62bb255cce7c3ba1460d497bacc4867ab8b0931f8c1212b8e8aa744d7a2bef22"},++ {"tile_id":"-6_4","cells":[-96,64,-80,80],"payload_hash":"92aaf7a6458d148166b7a7b4fa1909b2673f2c476c75a046c9aed67224fa4ef6"},++ {"tile_id":"-5_4","cells":[-80,64,-64,80],"payload_hash":"3c69f2a68242fb48922b210ba7d3028b3e4c3ce4a768d9d19616f45ff6db3468"},++ {"tile_id":"-4_4","cells":[-64,64,-48,80],"payload_hash":"463b970bb13fb208b66b3a29aee09166e518710babc5d25338581bf0c0664222"},++ {"tile_id":"-3_4","cells":[-48,64,-32,80],"payload_hash":"22e6f4ced2795aa989e512df55e36814d6a4fa12bfcd044fdf3aeba73a734ef2"},++ {"tile_id":"-2_4","cells":[-32,64,-16,80],"payload_hash":"3bdbde5a98e4f374222679daee6e0a0a8359cdad1926c7fc92efdd61ad1ea187"},++ {"tile_id":"-1_4","cells":[-16,64,0,80],"payload_hash":"eea89dc0f7953a532460b671cf8f9d6ec824ab86873b3b8361fdde8b256bbc79"},++ {"tile_id":"0_4","cells":[0,64,16,80],"payload_hash":"f890cbb0f67994e0b7cf0be0de4a1979d7f97ebe956a17e871d35e85e5b03216"},++ {"tile_id":"1_4","cells":[16,64,32,80],"payload_hash":"b084307969ecdf8753ae2779badc3bf7e6eaa5288187bf474be7f06c24df03ba"},++ {"tile_id":"2_4","cells":[32,64,48,80],"payload_hash":"217524fbf071ef0ad9f203016705714561b5f383340d6a46586b2682fea3a147"},++ {"tile_id":"3_4","cells":[48,64,64,80],"payload_hash":"cbd3cf3f205eae4f9be65807199da2b51b1412fa62a61ac74207c4dc4cd3539f"},++ {"tile_id":"4_4","cells":[64,64,80,80],"payload_hash":"94e2d4d6c25ba9d50cb514e0d437400b282356cd7e85cfdbabcd67e298f3929d"},++ {"tile_id":"5_4","cells":[80,64,96,80],"payload_hash":"19545f4bec58d97d3b21d4ecccb11fe32faeca8f0b16b0f16a46d7967445aab0"},++ {"tile_id":"6_4","cells":[96,64,112,80],"payload_hash":"23f8efa6da3140e489a590e851d7b9d5d01b6822ace785ff5afb10c6b3f1c03e"},++ {"tile_id":"7_4","cells":[112,64,128,80],"payload_hash":"92b7b703c178359fb0fe1f0df03353f3aa75426196b211ae13f5db772ab5fa1d"},++ {"tile_id":"8_4","cells":[128,64,144,80],"payload_hash":"e62667384bb13e1e88715562cb0550e3913bb0d5cb37255c163443cbe9d02425"},++ {"tile_id":"9_4","cells":[144,64,160,80],"payload_hash":"1c91a077bf529744f40967c12ef700bb81fdc4cdda1bb653f4f1c2f3dc9b5511"},++ {"tile_id":"10_4","cells":[160,64,176,80],"payload_hash":"10bcadc2f9cfb77c34b62a5814ed54fff91b59e1654b5bd808753452975d62f3"},++ {"tile_id":"11_4","cells":[176,64,192,80],"payload_hash":"ed7cdaab1cf2dfcd19ef78b71386669bebba9db9e1885ac44f8649c765e420bc"},++ {"tile_id":"12_4","cells":[192,64,208,80],"payload_hash":"d81f35cfe253ec55b4cc43db5b51bf67f2c1bec301e6901e4d44453b1195c9ef"},++ {"tile_id":"13_4","cells":[208,64,224,80],"payload_hash":"94b84f5f0bd657a205ee0a21fe21f6064a8c983633147a8d6953be0ef55f57be"},++ {"tile_id":"14_4","cells":[224,64,240,80],"payload_hash":"2f6aef0965cffe09806937ab7443ca1b417b94859bae89a828a195592ad47590"},++ {"tile_id":"15_4","cells":[240,64,256,80],"payload_hash":"561e6c16322c8b3e8238c675e1aa0933f563faffe0f3caf9c0064108f2d76ed5"},++ {"tile_id":"16_4","cells":[256,64,272,80],"payload_hash":"a9c500ae33f197e81cd4428d7fda1b0cf435cdf989a0ab6ab40a09428c5c70da"},++ {"tile_id":"17_4","cells":[272,64,288,80],"payload_hash":"aad172d8a4e31cf49a26957645c08dcb34924b2be8ebaceb2310824231f15032"},++ {"tile_id":"18_4","cells":[288,64,304,80],"payload_hash":"26d290d9fbbf550cad3fa772c8f31e6fefae495778d93d2e95c56e8107bfde59"},++ {"tile_id":"19_4","cells":[304,64,320,80],"payload_hash":"288f615609154fbf73769015b0088fbe289508db5a55ca1b0b9c1bf505d8152a"},++ {"tile_id":"20_4","cells":[320,64,336,80],"payload_hash":"b579bd9e0b9dc3bfd2508ac2d10d71f8873d231155acf8a9ca8ae37157f06701"},++ {"tile_id":"21_4","cells":[336,64,352,80],"payload_hash":"e72fbe8ce94555b4d13660f37e86548dbd040d10c930954ae75797db43f7752a"},++ {"tile_id":"22_4","cells":[352,64,368,80],"payload_hash":"17f90ce288b4cec009006a06cdceebdbe57c0ee5ebfaadbc8ec3f356da740ed4"},++ {"tile_id":"23_4","cells":[368,64,384,80],"payload_hash":"71b274944e32d4644ec30a6a55f5301cc80d6d11255da0c46b187ca6bbfd8ed0"},++ {"tile_id":"24_4","cells":[384,64,400,80],"payload_hash":"d198bbbf27ad734c9419d4a3091d3720607f7b667c208d02bc8a4efe2b409a57"},++ {"tile_id":"25_4","cells":[400,64,416,80],"payload_hash":"0528a333e8d93fcaefe53219b37e6fa7645d078ab7bf25bee06ce0a01f6af0e1"},++ {"tile_id":"26_4","cells":[416,64,432,80],"payload_hash":"fd71a96d29367dc593a844c2acb9f60eeedde8508b3e365a839571ea13e84ae6"},++ {"tile_id":"27_4","cells":[432,64,448,80],"payload_hash":"41bf8422697a7372871575fac19e0b981a27247c73fe00b383039d427100b452"},++ {"tile_id":"28_4","cells":[448,64,464,80],"payload_hash":"35406681d254319ac82595af1c476a8ebd78aa024a389daf73a22b64f74d4b47"},++ {"tile_id":"29_4","cells":[464,64,480,80],"payload_hash":"1c014e8ddc409824894dd8d576deb92130506010e1e6e855c320a40c739d6de0"},++ {"tile_id":"30_4","cells":[480,64,496,80],"payload_hash":"6c1c96ef9f4fbe4b595f0068e846d41d8bbba7eb73c090f14a0a70a287681f70"},++ {"tile_id":"-40_5","cells":[-640,80,-624,96],"payload_hash":"dfa733916c2721d45f8eedf4da5f0c21700c316f8004284a598142f930dc7291"},++ {"tile_id":"-39_5","cells":[-624,80,-608,96],"payload_hash":"fb26838391ef03bfbdebde7deeaf6e5ff1e4eedb94a7b33a8d3f641f5df53cfe"},++ {"tile_id":"-38_5","cells":[-608,80,-592,96],"payload_hash":"d6eaa195cfec889ea60f1f385186ae1e26084f52085c931b2b60c0ce68cf96c4"},++ {"tile_id":"-37_5","cells":[-592,80,-576,96],"payload_hash":"f2e03a3e54102836f1c051dd6286ec19934911503b1e05e4d2d9884b2f8cf628"},++ {"tile_id":"-36_5","cells":[-576,80,-560,96],"payload_hash":"f51157368f0d87da06a3afe598d35b94cdc0bb2e529da5d3817944deb9d481be"},++ {"tile_id":"-35_5","cells":[-560,80,-544,96],"payload_hash":"5f7fd936e3eae6de9054b70d975a3772fda434088eb1d0d155e9f06229b53e5d"},++ {"tile_id":"-34_5","cells":[-544,80,-528,96],"payload_hash":"9371f7606e921e21b083bdcb939d2c22422d740192c30c95a65bcceed8349e41"},++ {"tile_id":"-33_5","cells":[-528,80,-512,96],"payload_hash":"0a4572e0d6cd3ef964aea1e53c7348f112d1853f452f17179e8329d331b38a19"},++ {"tile_id":"-32_5","cells":[-512,80,-496,96],"payload_hash":"9467a0950f015fbef4bde211c270c578d1c196a6d01f2b02a3338497f6ffc253"},++ {"tile_id":"-31_5","cells":[-496,80,-480,96],"payload_hash":"335ddd269f110840f41d4bdb1b6a4f56a93d80cd5fdab68c7f08e4643cdf6261"},++ {"tile_id":"-30_5","cells":[-480,80,-464,96],"payload_hash":"91d63c0699b6add9c8a64e39de994164233e2194a8bc91dcf3e9e6c613c76364"},++ {"tile_id":"-29_5","cells":[-464,80,-448,96],"payload_hash":"5bf63da166dd998fa245de136f6e204605d9f969fbdad3eb6bf1866b927c2344"},++ {"tile_id":"-28_5","cells":[-448,80,-432,96],"payload_hash":"f1580cd8dcebcadaed90233f672d8182c693597e3f820aecd365a10c9433fab2"},++ {"tile_id":"-27_5","cells":[-432,80,-416,96],"payload_hash":"d163aacbf632bcf2b25241980691f67b8981cb8f4ea415d7809768603a8e0f95"},++ {"tile_id":"-26_5","cells":[-416,80,-400,96],"payload_hash":"ce77e0aabe161face5765da0073d50f1a267b267d9316a0bb16e6baa7eae8297"},++ {"tile_id":"-25_5","cells":[-400,80,-384,96],"payload_hash":"25373100f120c613a8fc22cc89792a7f8b6d4fb0931f94ce03eb4e73bd7b1f2b"},++ {"tile_id":"-24_5","cells":[-384,80,-368,96],"payload_hash":"a374eecfc5ae40cf602da5febda18dc4aae6dc2743115c7d4f388b5400124884"},++ {"tile_id":"-23_5","cells":[-368,80,-352,96],"payload_hash":"3e927c5b695f671cfd34b10e4953f6e4cc3cf06567595086e5daf65a0b0a9ec9"},++ {"tile_id":"-22_5","cells":[-352,80,-336,96],"payload_hash":"3e4076dcb32fa64d74f7cf14f136b4043e96b51e335c44e0d957d4ff0f15b823"},++ {"tile_id":"-21_5","cells":[-336,80,-320,96],"payload_hash":"b700f82ee1f16fbad2e0868e2e308431f0fcf18123dd93402a777ec97002fedd"},++ {"tile_id":"-20_5","cells":[-320,80,-304,96],"payload_hash":"8b1e0518a8e8a5ac47e5b6b4e50953115e600bdfc950603bd7fddeb5a051f02a"},++ {"tile_id":"-19_5","cells":[-304,80,-288,96],"payload_hash":"0753932d4faf752342aeae94d8e9098ad8ff19654a74db3874be50cd5a3f12e4"},++ {"tile_id":"-18_5","cells":[-288,80,-272,96],"payload_hash":"643259d5afc7836f3f476730f33cfce220e3b2d501236f9667407c1c6a522636"},++ {"tile_id":"-17_5","cells":[-272,80,-256,96],"payload_hash":"b0fe6b5a04189bf4a72a22b59d6445d005c8faae59858b60c0f55c7125d87e68"},++ {"tile_id":"-16_5","cells":[-256,80,-240,96],"payload_hash":"8f58bffcb72f7a7232a9c9fab14f9eff4100f87e5de2751102dc6813410854d7"},++ {"tile_id":"-15_5","cells":[-240,80,-224,96],"payload_hash":"bc0a1dd162fa0aa390dfcb5fd165f8e4cbdb98989482fe433d53a1aff22e2cff"},++ {"tile_id":"-14_5","cells":[-224,80,-208,96],"payload_hash":"ada9dd76d4dee4a76db48cfdc9b6ea13d3c5ddeb1807c99e043ec812c49c8319"},++ {"tile_id":"-13_5","cells":[-208,80,-192,96],"payload_hash":"74c335f7e0e8ea8e4809a1328b21caeb91db56bb365d000c98057fd5064f4d18"},++ {"tile_id":"-12_5","cells":[-192,80,-176,96],"payload_hash":"bd65a55993dc3d8103fb4648576b101a116f1156b0804b91ac45029b78b2e990"},++ {"tile_id":"-11_5","cells":[-176,80,-160,96],"payload_hash":"dc2ed459e3805c09247de35dee3da42d5357d017102dd4a7914ddc4c3524d7c8"},++ {"tile_id":"-10_5","cells":[-160,80,-144,96],"payload_hash":"f309036be0e755701ecb90e5cd5b73c911d371b0d77def7f003eab09864f1344"},++ {"tile_id":"-9_5","cells":[-144,80,-128,96],"payload_hash":"217d68a34b7d41dbe2908db8e62ee26b4c26ff37a81683eb104f47516502a893"},++ {"tile_id":"-8_5","cells":[-128,80,-112,96],"payload_hash":"766604a9affca9f674bf2604088443a4cd0f6d6b7733944ce199c249e97b7a42"},++ {"tile_id":"-7_5","cells":[-112,80,-96,96],"payload_hash":"a19c9a6c7c1c1a4e7749828827575ad74fe1887a8eeb5c79319fed19d643e2be"},++ {"tile_id":"-6_5","cells":[-96,80,-80,96],"payload_hash":"3bda50cf8d7e2f0e31ac27f037ea9a666aebe583aea5250b215114c67300ea01"},++ {"tile_id":"-5_5","cells":[-80,80,-64,96],"payload_hash":"d60d0fac348531fa4186ae55b2aaf4eab0886f3590d7a962e63dad7042a2b882"},++ {"tile_id":"-4_5","cells":[-64,80,-48,96],"payload_hash":"96374f42d4cd641db86d468643544595c86906675efef4c7dfaac90bd94dddc5"},++ {"tile_id":"-3_5","cells":[-48,80,-32,96],"payload_hash":"f7731fd0a5b9d013b5b55f91b78e324656ddde765565f67bb9b87542e986343f"},++ {"tile_id":"-2_5","cells":[-32,80,-16,96],"payload_hash":"4874f1491e00ed0b802da5339b6cadbfd02f22b212334b33a8ca7f16cafbde95"},++ {"tile_id":"-1_5","cells":[-16,80,0,96],"payload_hash":"998280926bf2a705734c87a4e447d2d1d9a0b46ae2eacb78228003d69fb8c406"},++ {"tile_id":"0_5","cells":[0,80,16,96],"payload_hash":"0cc95006e364848fa224aafefcf3b8b8127c60595bc9d25dc9c3a9c0e5891dbb"},++ {"tile_id":"1_5","cells":[16,80,32,96],"payload_hash":"c926be43eeaf22e5eb44ce9231649fe5db3fdd51aecd993875de3bba21a3bc49"},++ {"tile_id":"2_5","cells":[32,80,48,96],"payload_hash":"5e86868b37118e74a4995608dc4918baea69d3863ef58de7cf57de4f644708e2"},++ {"tile_id":"3_5","cells":[48,80,64,96],"payload_hash":"050ff10eef30374408d71568798da8069287fb521405fd534f15c46fd1259efa"},++ {"tile_id":"4_5","cells":[64,80,80,96],"payload_hash":"4be52e731dbd24cc34bd35394e921f576bebc19c3b3c265659b8253ce9af89f6"},++ {"tile_id":"5_5","cells":[80,80,96,96],"payload_hash":"4f9a5b59cfae7421ddb44342ca0c40171c1c5085c66784321f25d6e11ef0a9fe"},++ {"tile_id":"6_5","cells":[96,80,112,96],"payload_hash":"d7c3c7eb19f73b13e9a9a6f71fe4aafb2ea5959bbeff547701d327be6d1f214c"},++ {"tile_id":"7_5","cells":[112,80,128,96],"payload_hash":"8ebe6c76a7d97ee18e74862677a1d80e754371f2eb06526a9d83d278c94ef6b7"},++ {"tile_id":"8_5","cells":[128,80,144,96],"payload_hash":"95618d82c8b00abdb54d9f264c54543d8977f2211e47e31cec7566bba01ebf22"},++ {"tile_id":"9_5","cells":[144,80,160,96],"payload_hash":"6eaa8e837cf59fc661f318e7768bf6e4d5d0ad809e53155252d402043a0eb2b8"},++ {"tile_id":"10_5","cells":[160,80,176,96],"payload_hash":"f05675a466c70fa232217595ba772615f6a5f537d0e55fa0d0640e4bea2a0e33"},++ {"tile_id":"11_5","cells":[176,80,192,96],"payload_hash":"68b25f609294562d307cadb1847e4918b2acb2ef0a5e386ccce42f133217d38f"},++ {"tile_id":"12_5","cells":[192,80,208,96],"payload_hash":"42440746cafed15a9fcb8133a3b8888da65e8042dcf57ebf4fb189348a094f8b"},++ {"tile_id":"13_5","cells":[208,80,224,96],"payload_hash":"ed74de1eb0394eea3eeade24ac8350edea2b693b52a0d4a380924369e28c48c0"},++ {"tile_id":"14_5","cells":[224,80,240,96],"payload_hash":"f83181741290f3eff0133de070b1f9deb02541b634ce42da7123037a18d6cb7d"},++ {"tile_id":"15_5","cells":[240,80,256,96],"payload_hash":"9f8056d9d54394880044d0590b6479a82771f2ef4c6814735556afe9a7f16bf7"},++ {"tile_id":"16_5","cells":[256,80,272,96],"payload_hash":"654735b13e3bbbac7b38cd2334d00133448c42590b167b05c0646a939912b7ba"},++ {"tile_id":"17_5","cells":[272,80,288,96],"payload_hash":"be0fa187879e5f9b581d2ccb33c633ba88d49d8aa7fad5c2132ceb88342c48f4"},++ {"tile_id":"18_5","cells":[288,80,304,96],"payload_hash":"f82cba97ac493a057337ef21ab83210c706597e561e841ff48bcb5248e23e499"},++ {"tile_id":"19_5","cells":[304,80,320,96],"payload_hash":"71fab11688f6b7b0a18ce4734e540712487d9ca086929dcb0dd0d87a185bda20"},++ {"tile_id":"20_5","cells":[320,80,336,96],"payload_hash":"bae3b3466c4426709e773e08ee4828c6349bf9f3e60accb0607b983e474465db"},++ {"tile_id":"21_5","cells":[336,80,352,96],"payload_hash":"364eba4fb100b8ef8f0bde07e6c085cbcca07b5cd72598ad579270802cc1e88e"},++ {"tile_id":"22_5","cells":[352,80,368,96],"payload_hash":"e4f708b51a3602ce40320e909b3326d2593265d23739d5208e5b5b866c50fffa"},++ {"tile_id":"23_5","cells":[368,80,384,96],"payload_hash":"df466c5b9391773e199e80f92da0effd7584e93aed9e0db529f7ed23a4150c3b"},++ {"tile_id":"24_5","cells":[384,80,400,96],"payload_hash":"a9643c3c4b133a3d85b481dab97e5cb362d6e146c2046cb6c1a6e1018993ac3a"},++ {"tile_id":"25_5","cells":[400,80,416,96],"payload_hash":"4a73cf7f2ca5f19f7ef51d91ee46fcea139b1a1b2f0d01d838276586cd64de04"},++ {"tile_id":"26_5","cells":[416,80,432,96],"payload_hash":"be4ac5d01f77103aa02b3f8baab1c7d5d0f9dca426ef853a1874c77e44bd84eb"},++ {"tile_id":"27_5","cells":[432,80,448,96],"payload_hash":"ba02b9469dd51636c81a4733f85beb50cae082c95c796e037246552c5b714f43"},++ {"tile_id":"28_5","cells":[448,80,464,96],"payload_hash":"b0a5da1ccae0b5dc089c1c6b3e091e33d9860943e5dcbc45134ecd4e0fc7d59b"},++ {"tile_id":"29_5","cells":[464,80,480,96],"payload_hash":"c96adc347e2dfd50cd3356faf199901c4af2c6337b6d9a8559925b3bd7317d4e"},++ {"tile_id":"30_5","cells":[480,80,496,96],"payload_hash":"375eab5f2f7b0798a4c14f94a02cf99beb7ad7a4362d8f660abb5524045178bd"},++ {"tile_id":"31_5","cells":[496,80,512,96],"payload_hash":"3d37781300e9b274151c131734fca5370857d31fbb449c3eb41006ef6dc78670"},++ {"tile_id":"32_5","cells":[512,80,528,96],"payload_hash":"9908b0a0e5d6be4f5781e809eeb46772a7b072fd8c1f2292d3211db305dae730"},++ {"tile_id":"33_5","cells":[528,80,544,96],"payload_hash":"b8584fecdcb9cea03c1593c1dab64f235a36967b4d798d06d470bbd414e5fb43"},++ {"tile_id":"34_5","cells":[544,80,560,96],"payload_hash":"312f7245a5ad45a5a621ca5be0ce3130b06d921d93cde093e5d0352b389061bb"},++ {"tile_id":"35_5","cells":[560,80,576,96],"payload_hash":"e3633855829fd7a1ba21b228339d4b4b5f4bb50101aeba5c2d6147b438b44b15"},++ {"tile_id":"36_5","cells":[576,80,592,96],"payload_hash":"5e21c0952d568da0277fe922b3407b7f428fda87abc20f961361b240b70fce5c"},++ {"tile_id":"37_5","cells":[592,80,608,96],"payload_hash":"8130c8bb8cd7c2b76f22a0454f403619fb83dd398848fcddf74cd7ecf8d8f525"},++ {"tile_id":"38_5","cells":[608,80,624,96],"payload_hash":"406d3d6ecf88159b2c98f0fb308274b883e17719580795725d970b9d2842aed9"},++ {"tile_id":"39_5","cells":[624,80,640,96],"payload_hash":"32f25b9c39620faf525160e114f61170fa5a9dabce148f82ffdc642fa69e5d63"},++ {"tile_id":"-47_6","cells":[-752,96,-736,112],"payload_hash":"3d3315bcdf1b37cf760c219631ecd104a2f7ec2bc2afdce2162ccb8d380f0eaa"},++ {"tile_id":"-46_6","cells":[-736,96,-720,112],"payload_hash":"ea76e69acd2e25e15c6b75c2f33c4dc61c0897273877271ee6d6d590376712f4"},++ {"tile_id":"-45_6","cells":[-720,96,-704,112],"payload_hash":"8e83db7b74aae68c21e0a9c2f1dcdadebd58e0fb9a7184505b6f9a8e9a60058f"},++ {"tile_id":"-44_6","cells":[-704,96,-688,112],"payload_hash":"df834dc251fc91fa666aae8db61e6d7a2b6360060ffa955320cca3fb2a415b79"},++ {"tile_id":"-43_6","cells":[-688,96,-672,112],"payload_hash":"a424d515d901a69b6a389891d7fcf1b26b920b736b85eedd030acb536f0d4bcc"},++ {"tile_id":"-42_6","cells":[-672,96,-656,112],"payload_hash":"fb6a32050ede11701e53c1bbdd88a1418e86891b7ce33ef450d124b473473e24"},++ {"tile_id":"-41_6","cells":[-656,96,-640,112],"payload_hash":"00b38a1d199394e52abf84d8761c06da4deac1bcc7777dad36a51086942778e2"},++ {"tile_id":"-40_6","cells":[-640,96,-624,112],"payload_hash":"318f382851cc0779c16821e56c4c17fb16d4443e9d292ffafb8d07241ce55ca2"},++ {"tile_id":"-39_6","cells":[-624,96,-608,112],"payload_hash":"4ded9c0ae77c52fc2f0bb2c7484040baa9f57dd4effa0c22accb47b9e24b52bc"},++ {"tile_id":"-38_6","cells":[-608,96,-592,112],"payload_hash":"187c17abfa9f878549ff88f19249b0772cfc55264b46784811c196dd758a048f"},++ {"tile_id":"-37_6","cells":[-592,96,-576,112],"payload_hash":"bdcdf0137a67047dba2909fb1eac619bdd94f0e35c753859716365692c84c42c"},++ {"tile_id":"-36_6","cells":[-576,96,-560,112],"payload_hash":"b038b3ed7752c93f58b70608243773de119d65e5995ca0e13da80f7bc745bddd"},++ {"tile_id":"-35_6","cells":[-560,96,-544,112],"payload_hash":"4ebb763c610f1cd8fccdb21f79fd53e3da072e6a1ff8778b18dd87ca67feece7"},++ {"tile_id":"-34_6","cells":[-544,96,-528,112],"payload_hash":"197e46db8e986de9ff9c657113b7b0610a52886d14ec56b3ab4ec6818e7af363"},++ {"tile_id":"-33_6","cells":[-528,96,-512,112],"payload_hash":"b8092ffcc54eaa1364fee65560922a3dafa60d59a5381655e0696e92fbdfed87"},++ {"tile_id":"-32_6","cells":[-512,96,-496,112],"payload_hash":"5db8cddc7ebf5b89ecd1cf855d3fbfac19dbed490f1d9aacab6f0da03241abb5"},++ {"tile_id":"-31_6","cells":[-496,96,-480,112],"payload_hash":"19afda34284059937e7a46e7c6d6aa8d25a7a04046646738e0cca8dbae01738f"},++ {"tile_id":"-30_6","cells":[-480,96,-464,112],"payload_hash":"4a0d7464b5c13d11f2c78610dc083fe7fdda2dc9a23b1ae330be5a476baad0b1"},++ {"tile_id":"-29_6","cells":[-464,96,-448,112],"payload_hash":"33a6b4b6fad8c15cb9d9d6d2e0bad8a01ab7ad97875f59ee2bc643734b84aac2"},++ {"tile_id":"-28_6","cells":[-448,96,-432,112],"payload_hash":"cc5fe6ad7f7d9fab6002e6420b9f46e1c6e4876f7f0d0a3704f9f99644810187"},++ {"tile_id":"-27_6","cells":[-432,96,-416,112],"payload_hash":"470f842409ddd855f72f66fde597ea322f48877c4e7c0eee0cf2d52c12b21b5c"},++ {"tile_id":"-26_6","cells":[-416,96,-400,112],"payload_hash":"2c4dd33d87b90e3aa8d25380d318f68a808402a59c0bcdb681e525a2533047d5"},++ {"tile_id":"-25_6","cells":[-400,96,-384,112],"payload_hash":"972a900ee79df699ebbf4cd525d9ca6cfb57a5d6921d1c42c90b2ab4ea195104"},++ {"tile_id":"-24_6","cells":[-384,96,-368,112],"payload_hash":"14fdfefc83f6351733bd5ff5fb5775b5275e4f6a8721ccd256ae88d785e1c999"},++ {"tile_id":"-23_6","cells":[-368,96,-352,112],"payload_hash":"c32a9adf48682aa9628a02a0c52fcb1a5df8e74984157ad7752bb68b9dd870fc"},++ {"tile_id":"-22_6","cells":[-352,96,-336,112],"payload_hash":"079d7e026ea0fe77a2895f944669766388ef190dcab77bebf8519a3442034a54"},++ {"tile_id":"-21_6","cells":[-336,96,-320,112],"payload_hash":"b975db7367b93d74e3bc6a9088263ad2d12abbf9961cf24f1d4c58fe79a8c84c"},++ {"tile_id":"-20_6","cells":[-320,96,-304,112],"payload_hash":"3ec0ce5c83912bb29217aed21287bb792ac3a133621e125476fbaf6d30e7f5c9"},++ {"tile_id":"-19_6","cells":[-304,96,-288,112],"payload_hash":"001c89172ec652be35ec0857537fdaa9ac633a1f887bc36728a3226b389567e9"},++ {"tile_id":"-18_6","cells":[-288,96,-272,112],"payload_hash":"f29ba8a4d31db792dd16c80f5e1e0322e5cf66b15a35ff9ed2ab94fae89357dd"},++ {"tile_id":"-17_6","cells":[-272,96,-256,112],"payload_hash":"df2fe8137bc4ee103cdccd44ffdda72727bb748dec15f803c2fd6633d9cc7154"},++ {"tile_id":"-16_6","cells":[-256,96,-240,112],"payload_hash":"5125313ac04c5c38aebcadca29ac5b0d669d736b4c0aa09cf1c32ebeac529925"},++ {"tile_id":"-15_6","cells":[-240,96,-224,112],"payload_hash":"a8573dd723989c928058907fedb863f30dbf62bb6e612e666773495adf8c2fee"},++ {"tile_id":"-14_6","cells":[-224,96,-208,112],"payload_hash":"1740db6a1d327bc61589584d6a7a65d6cb8f524d0fba0f573e32813a8ea50ad2"},++ {"tile_id":"-13_6","cells":[-208,96,-192,112],"payload_hash":"15b57653f3820981abdf274bfc363e825a078f1629a5170cf81f87957f236fd1"},++ {"tile_id":"-12_6","cells":[-192,96,-176,112],"payload_hash":"4443c25bd0d40594b542176eff1dee6a5fa049fc1c53029f67aa15312f992b1b"},++ {"tile_id":"-11_6","cells":[-176,96,-160,112],"payload_hash":"702f9c1e50070f396c2f60734b918e2fa523d69542200a7e49c48445ff186ec4"},++ {"tile_id":"-10_6","cells":[-160,96,-144,112],"payload_hash":"14b90a810587f5bab178db7fb8671f169bb56b8a166da11f959285a803bdc7a5"},++ {"tile_id":"-9_6","cells":[-144,96,-128,112],"payload_hash":"1a109d055053359400bacf986cd210a2ea524cab4753527a5646b3f2a1ee42fd"},++ {"tile_id":"-8_6","cells":[-128,96,-112,112],"payload_hash":"f5163089bece04cc9213f4a01e5987ebd04d795724175a6cd4096dd1ca06d95a"},++ {"tile_id":"-7_6","cells":[-112,96,-96,112],"payload_hash":"a5b3503445eefbe2cc91aaffdab36b45f29eb4910378a21213eea09d21c5f6df"},++ {"tile_id":"-6_6","cells":[-96,96,-80,112],"payload_hash":"6de3804564e09d3b41663631e1000991f5552c4de117ec8bb089c9c1db9c33cb"},++ {"tile_id":"-5_6","cells":[-80,96,-64,112],"payload_hash":"2c6946d05f7667a70d25c74c3672f38210a5cb2fd17babc563a91189f5656fce"},++ {"tile_id":"-4_6","cells":[-64,96,-48,112],"payload_hash":"70a8690056063198147c2f29d333498047a883345e0c5bb8c8c74d27fbd1cda5"},++ {"tile_id":"-3_6","cells":[-48,96,-32,112],"payload_hash":"9aca3e14382574914bde99b649f64531b20173be99ffbf01383950aa374c7066"},++ {"tile_id":"-2_6","cells":[-32,96,-16,112],"payload_hash":"58bda36ba6a2befb900fb3d78d56b55c95e7e4b55e268fdf174b529b19ff9bed"},++ {"tile_id":"-1_6","cells":[-16,96,0,112],"payload_hash":"a07ea747e1d5cdc6d7e6edfae86d2eec5cba9675f62dc08dc6d2016a7e2c3628"},++ {"tile_id":"0_6","cells":[0,96,16,112],"payload_hash":"d128d60d7e1eec9ce5307d91d3ea027bff8eae162206074d3c291f0c8534218d"},++ {"tile_id":"1_6","cells":[16,96,32,112],"payload_hash":"287ba9ef9d8b1095c8e931f51a2ddb8724b74ac4ccc0f0f271c5feabff746b46"},++ {"tile_id":"2_6","cells":[32,96,48,112],"payload_hash":"3fe3d7dfb2bc8f8967cc3bba17357aa5fbc759204047d189ec9751a46b140900"},++ {"tile_id":"3_6","cells":[48,96,64,112],"payload_hash":"ea5945fa90c959a46e2e958f6e819b6252df65d88e63b10f37240f24b397c0a5"},++ {"tile_id":"4_6","cells":[64,96,80,112],"payload_hash":"6ecccec7f88814128436c7170cbd8b80cc58e6c191dba6b702eb282be85a54ff"},++ {"tile_id":"5_6","cells":[80,96,96,112],"payload_hash":"e9d187667fb1cf14faa40e5e2b00fe12fb5fe042f4378737d5261d650a7760ea"},++ {"tile_id":"6_6","cells":[96,96,112,112],"payload_hash":"49620c99dcd8b8f9f9c1a645b4fb89744f57f9c320e8febb1503fccc0a505122"},++ {"tile_id":"7_6","cells":[112,96,128,112],"payload_hash":"e81eeec6398e20793fd48dda2d8f9961fb84beda9dae6af9f1ece4e32a41d151"},++ {"tile_id":"8_6","cells":[128,96,144,112],"payload_hash":"fae0a68065a169bf601304881ce4dd6d3556d2a3b4b5d527fd1802cc0a515c29"},++ {"tile_id":"9_6","cells":[144,96,160,112],"payload_hash":"927f761b5d75e8b1668f762f70daf252e2b8498588eea6219f0e80d7cec21dea"},++ {"tile_id":"10_6","cells":[160,96,176,112],"payload_hash":"8c2f7c8b80f9d905ee3001960488d400f94c5a0e2d6907bd128aa3ec02b238b0"},++ {"tile_id":"11_6","cells":[176,96,192,112],"payload_hash":"0ee021e721174689e758c27373f7168ff23c02ab67650914f63347743ec0d42c"},++ {"tile_id":"12_6","cells":[192,96,208,112],"payload_hash":"114564cb6762f533d43d5b4713a58ca8c05fe5df6236f19ae902f86d762f1e52"},++ {"tile_id":"13_6","cells":[208,96,224,112],"payload_hash":"ca02c53053426d5f605dae710ae08ac0930e0c47d5a290f25cb519c679a965a3"},++ {"tile_id":"14_6","cells":[224,96,240,112],"payload_hash":"b765538c4dcef9a57849c4534b84052ad05b3125a62a6b301c0adb81f1123045"},++ {"tile_id":"15_6","cells":[240,96,256,112],"payload_hash":"83c385c2c02ea5d1950fb809b512ecb87685e80bc0b7706d721653d3ed1e31a7"},++ {"tile_id":"16_6","cells":[256,96,272,112],"payload_hash":"af90545ace43df8b66ad5b1e71dc73c4cfeca769224f3d986523efd16ce18bf4"},++ {"tile_id":"17_6","cells":[272,96,288,112],"payload_hash":"f865eeaea33fb22f8174fb7f1a7ceb7be9b4b2e222640de5b54546c97e07691c"},++ {"tile_id":"18_6","cells":[288,96,304,112],"payload_hash":"0f7588fee3764c97a855eaa6f1059039e0edea88cc50f66a7fda293e60d8e19a"},++ {"tile_id":"19_6","cells":[304,96,320,112],"payload_hash":"85da0faefc53d826ce6bbe71ecb1ea68e57397619aaf1870a92729cee664da26"},++ {"tile_id":"20_6","cells":[320,96,336,112],"payload_hash":"2b662f8df9175974cced8b5461341894cd72e37c511566c790bd611be4c940d1"},++ {"tile_id":"21_6","cells":[336,96,352,112],"payload_hash":"4502cd5bf6c145744757a2dde3483dbe51750467b9d6e1035b0128a09dc2c5d5"},++ {"tile_id":"22_6","cells":[352,96,368,112],"payload_hash":"f1f97ad48bb36528a04b698497d42a659ff8f441db45355026a195bcbd1bae2d"},++ {"tile_id":"23_6","cells":[368,96,384,112],"payload_hash":"6b7420605b8d8b0339aba68c5caadf029d6325edac71797ac62d9ce9a5ebfea3"},++ {"tile_id":"24_6","cells":[384,96,400,112],"payload_hash":"c2dd21eb8e37aac4264d83337d042e047d35293ddcffea02af3c4c813045d8cd"},++ {"tile_id":"25_6","cells":[400,96,416,112],"payload_hash":"6ed3a62e70373824ca295e63ebb1a775977f3bda12016a2283ec735058a61e54"},++ {"tile_id":"26_6","cells":[416,96,432,112],"payload_hash":"4de5afd9f3c4894bd149eb33596948f1de88214d6fbdbaeb552f9167b3cbc8fc"},++ {"tile_id":"27_6","cells":[432,96,448,112],"payload_hash":"d75a761225400249c444cd73a3f6692fdfe55d8a034c955b7aa4c27e33038e00"},++ {"tile_id":"28_6","cells":[448,96,464,112],"payload_hash":"201efddd8a310c08b75e129a62af06d5345e7d6d8eac7c5c1c2bf41294f99d4c"}++ ]++}