{"as_of":"2026-08-10T21:56:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:f124c517c3926943f2120898e40daaa6c6436f9a7b66e0546a2c381f1974cd94","coverage":[{"denominator":52,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":52,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-06T19:16:28.187228Z","state":"measured"},{"denominator":53,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":53,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-10T06:31:04.303077+00:00","state":"measured"},{"denominator":1,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":1,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-10T21:47:44.304625Z","state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":0,"source":"pith","source_observed_at":"2026-08-10T21:47:45.581676Z","state":"measured"}],"external_citation_measurements":[],"inbound":[{"citation":{"cited_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"cited_work":{"arxiv_id":"2507.06112","doi":null,"metadata_source":"pith","pith_arxiv_id":"2507.06112","snapshot_observed_at":"2026-08-10T21:47:45.581676Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","venue":"cs.CR","work_id":"236896bb-400f-43db-8252-4f3ea7270ff1","year":2025},"citing_paper":{"arxiv_id":"2501.04183","last_updated":"2026-07-13T06:10:16Z","snapshot_observed_at":"2026-08-10T21:37:16.023730Z","submitted_at":"2025-01-07T23:29:01Z","title":"Decompiling for Constant-Time Analysis","version":4},"reference_index":29,"source":"pdf_text","source_observed_at":"2026-08-10T21:47:44.304625Z"},"links":{"cited_paper":"/paper/2507.06112","citing_paper":"/paper/2501.04183"},"observation_digest":"sha256:f5350d49dc990be1b2ef768ba4dd295509027a60dbe02df0ed280a06593d8bea","observation_id":"a30d1214-7152-409a-95de-c6ddd25148f5","resolution":{"observed_at":"2026-08-10T21:47:45.586972Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}}],"links":{"evidence":"/evidence","html":"/paper/2507.06112/citation-record","integrity":"/paper/2507.06112/integrity","json":"/paper/2507.06112/citation-record.json","paper":"/paper/2507.06112"},"outbound":[{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.654764Z","title":"Predicting secret keys via branch prediction","venue":null,"work_id":"9e2d533c-57c0-4657-a655-8a930d90ce2b","year":2007},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":1,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:23.511111Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:3c76dcf9a3d3f7b3f71c0b8fd93bf14a3715c7039d48b81e68c4ad43d167c9f1","observation_id":"3a70fc1f-6adc-4459-bfc9-e80e32066db4","resolution":{"observed_at":"2026-08-06T19:16:28.658058Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.646312Z","title":"Rao, and Pankaj Rohatgi","venue":null,"work_id":"e8db40d7-13b1-4fd2-b7c6-14535ac425ab","year":2002},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":2,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:23.672148Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:4a0970230aab0af0ab592864837fb0f0a67cfa9eea1e68065f12aab12fceaaff","observation_id":"8f1becaa-c099-43dd-b50c-0626a4460c26","resolution":{"observed_at":"2026-08-06T19:16:28.649132Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.637048Z","title":"Port contention for fun and profit","venue":null,"work_id":"3c2d69c4-47af-4aac-8ec5-45a58cfba0bc","year":2019},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":3,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:23.833215Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:2b9c0961b83d90c044173375f5bb02903f4fdb1470ba7b1cb6210ae7ca52b969","observation_id":"3b7ff460-b003-4f05-8d41-6dfaed3ef2be","resolution":{"observed_at":"2026-08-06T19:16:28.640080Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.627596Z","title":"Bacelar Almeida, M","venue":null,"work_id":"7e998c6d-e54b-49a6-9679-d3456b162194","year":2017},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":4,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:23.970544Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:be9b8eaeeb8b1e8551bd711ade3736dbef2bd97523a72791d79d3992a1d1a98d","observation_id":"3e741dca-d570-44dd-82f6-18d419aa2fc6","resolution":{"observed_at":"2026-08-06T19:16:28.630357Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.617610Z","title":"Formal verification of a constant-time preserving C compiler","venue":null,"work_id":"41033a8b-ccdb-4288-b55f-418d5fac8230","year":2020},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":5,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.040522Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:8301944d450c4ad10031fff00a5e929213dc70f0c96e53bea2ff431452ff2639","observation_id":"de2cf368-f265-4495-ac1a-9bbdb840fd1b","resolution":{"observed_at":"2026-08-06T19:16:28.620706Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.608950Z","title":"Secure com- pilation of side-channel countermeasures: The case of cryptographic ”constant-time”","venue":null,"work_id":"b540d7fa-6024-49b9-9fc2-7147d7a5d0b0","year":2018},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":6,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.170531Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:e7aff939b19c5bbdc91fe136ee5f87dc67fb4dfe98b4e5688b933c05256781ef","observation_id":"b5627475-3d86-4bcc-b15a-796dd17a5dee","resolution":{"observed_at":"2026-08-06T19:16:28.611854Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.599872Z","title":"Cache-timing attacks on AES, 2005","venue":null,"work_id":"e87f7b40-2406-4578-9c40-9e46d2534d5b","year":2005},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":7,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.235843Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:bcb60a5e61745e39ab8e73d165c6d19bfd771e8762768bb30a0489006a1b9673","observation_id":"76b6fd0d-d0ae-426a-9e5b-da926734ac8a","resolution":{"observed_at":"2026-08-06T19:16:28.602804Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.591485Z","title":"Bernstein, Karthikeyan Bhargavan, Shivam Bhasin, Anupam Chattopadhyay, Tee Kiah Chia, Matthias J","venue":null,"work_id":"5403ef8c-fa91-498a-82ff-6d469048e465","year":2025},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":8,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.330005Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c5895fe02e382699f05e1b646513f8c76c55f3e20ee5544f41101fb6bcb6a8c3","observation_id":"ba90d914-b0a5-4e16-90d0-b8de64964f2e","resolution":{"observed_at":"2026-08-06T19:16:28.594537Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.583028Z","title":"Constantine: Automatic side-channel resistance using efficient control and data flow linearization","venue":null,"work_id":"3a422ec0-3159-498b-9d0b-a43c07e07cec","year":2021},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":9,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.402004Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:1e55507a3e232eabc5ff24f1b26c889303db4ed93af375bf165f94ccd9cca394","observation_id":"0d14358c-d36c-4029-9d43-7ecbdd4a3e66","resolution":{"observed_at":"2026-08-06T19:16:28.586171Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.574478Z","title":null,"venue":null,"work_id":"01c47245-bcaa-48cd-b4ae-16fe66c4d3b2","year":2009},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":10,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.483753Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:78e44901f8908309255c42ea1997a931c1c688786f4ef91ea9fe3352ceb48041","observation_id":"50fb44c0-1da1-437d-8879-a39d7002a2b7","resolution":{"observed_at":"2026-08-06T19:16:28.577293Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.565497Z","title":"Bug 113682 - branches in branchless binary search rather than cmov/csel/csinc","venue":null,"work_id":"c74c6017-2093-485c-98d2-7b9c428c8583","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":11,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.593859Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:2f5bd9f5106bc3601520db391425b6cc1f5aaf81eef801b94cd856b023830bdb","observation_id":"4c856b85-e12a-4fe0-a5ed-4991ea0d61b0","resolution":{"observed_at":"2026-08-06T19:16:28.568216Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.556786Z","title":"Bug 68541 - [6 regression] path splitting causes if- conversion miss","venue":null,"work_id":"ca2aad4c-cdf3-435c-98e0-8f1d4550563a","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":12,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.669200Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:b9c29a82d93053099d3d4bcb11287221a143392c66ec34cca0e41a660aa171c8","observation_id":"e93ace8d-1317-4646-b77d-746617f564a9","resolution":{"observed_at":"2026-08-06T19:16:28.559810Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.547690Z","title":"Wahby, John Renner, Benjamin Gr ´egoire, Gilles Barthe, Ranjit Jhala, and Deian Stefan","venue":null,"work_id":"919e4459-13c4-4639-bf47-aa501593d364","year":2019},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":13,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.745091Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:a12546d04fb3aa26bc359a901bca7de1375678b7ee3d2b05abe3908fc8657ab9","observation_id":"8273401b-68ec-4c14-b7ab-76c7163bb18d","resolution":{"observed_at":"2026-08-06T19:16:28.550737Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.538678Z","title":"Symbolic verification of cache side-channel freedom","venue":null,"work_id":"e094d9f2-c8fa-4d01-af65-2f5a883871e6","year":2018},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":14,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.811236Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:7ec108016573b9a48ea2ba509536a495bb367a718aabc70e8a587760fd7d9b93","observation_id":"1a893826-ae36-4e06-bd5d-242663868c28","resolution":{"observed_at":"2026-08-06T19:16:28.541675Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.529860Z","title":"Binsec/rel: Efficient relational symbolic execution for constant-time at binary-level","venue":null,"work_id":"402f81bd-be68-4ba7-8109-4012084248f4","year":2020},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":15,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:24.888206Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:2a55d02b66982ae7638fc3d8eabdde3f22d9e4287b438bec007053ff019be96d","observation_id":"355af8dc-1517-4051-ad51-e4bdf73c3632","resolution":{"observed_at":"2026-08-06T19:16:28.532985Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.521083Z","title":"Optimize options","venue":null,"work_id":"b989561e-89ec-415c-ac9a-baa4febe1cc2","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":16,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.006194Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:5ae681db0d554f701703bab4a1f90d8f3c6c2c81de6355d5386cc00038cd73ac","observation_id":"76c41e06-cd94-453f-942c-4e5182b2177a","resolution":{"observed_at":"2026-08-06T19:16:28.523933Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.512094Z","title":"Auto-vectorization in llvm","venue":null,"work_id":"caffe1a6-143b-4b75-a3d5-74b24fc85a5e","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":17,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.093297Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:dc07d8756f18e3c563f75eab7c2acbdd9634444d4634ef72ef718efe535e043c","observation_id":"87f2a92c-6e91-4bf0-ab05-83d20218e53c","resolution":{"observed_at":"2026-08-06T19:16:28.515012Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.504172Z","title":"llvm::simpleloopunswitchpass class refer- ence","venue":null,"work_id":"8e9e089f-377c-40e7-9781-7f3cd65ba50c","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":18,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.185795Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:f6e6cd3ecb041f7bb81cf5980e010438dd67e70b377371eb3495f79a22a3aac3","observation_id":"9e3c3c84-dbad-412f-9945-681649e4cd8c","resolution":{"observed_at":"2026-08-06T19:16:28.506924Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.495694Z","title":"X86cmovconversion.cpp file reference","venue":null,"work_id":"ef650433-5662-4b1a-9c97-9b392d5cffd2","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":19,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.272746Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:b1b916532f51cc097df5d19298e1b411c520d4b59d4d24e16468d9fe470c8d05","observation_id":"04a2b5ed-34d2-4cf1-826e-d63615864b63","resolution":{"observed_at":"2026-08-06T19:16:28.498752Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.488194Z","title":"Fletcher","venue":null,"work_id":"22157b35-2468-4069-99ab-08b5fe6f4788","year":2022},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":20,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.340211Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:f2e4d51ee3c460c44914bbe96462bc42d606c8c0105b653d223fd2bcc2de7510","observation_id":"e284dc0f-aab4-468d-bd17-49956367e5dd","resolution":{"observed_at":"2026-08-06T19:16:28.490593Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.480600Z","title":"Disselkoen, S","venue":null,"work_id":"be43a6e6-c580-4628-b63e-01f14f64c33e","year":2020},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":21,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.414065Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:cbdb327fb5c5cb3bdfb9c003d5b6348c2ce75b702052c7c220da158ab1c8090d","observation_id":"66378230-4df0-41b3-9a8b-384a9dc586f5","resolution":{"observed_at":"2026-08-06T19:16:28.483293Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.472297Z","title":"Semi-automated and Easily Interpretable Side-Channel Analysis for Modern JavaScript","venue":null,"work_id":"0344a905-1e89-4124-8586-e8033d9f30d4","year":2024},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":22,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.500163Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c28dcbea615f02b608f772431b0cfc5a7ecd2965510e32c17d057fccc25f7678","observation_id":"edd11542-e607-4360-98ba-835041412828","resolution":{"observed_at":"2026-08-06T19:16:28.475347Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.464641Z","title":"Mbed TLS","venue":null,"work_id":"8e0585a7-ec10-4dc5-85e7-f10f510e5063","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":23,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.597215Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:d9441159df72cc8583aea56a1132d40bbd3c7c7258a80571e33e67a29e15ba41","observation_id":"5917fae2-da63-4ba8-bb29-fb73859f4f03","resolution":{"observed_at":"2026-08-06T19:16:28.467184Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.456535Z","title":"Sharma, Alexandra E","venue":null,"work_id":"79bb588b-3be1-4f73-877f-b13c9e16fbf6","year":2024},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.674331Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:1e552d8a92aea398d3cb04ab7e2bf1b834cd849f063f3e9ea3da5e7e4e363458","observation_id":"699ce685-6916-4f9e-80a0-74783e112145","resolution":{"observed_at":"2026-08-06T19:16:28.459170Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.448683Z","title":"”these results must be false”: A usability evaluation of constant-time analysis tools","venue":null,"work_id":"25ace35c-4bcd-4472-a8d9-7a9199463fc8","year":2024},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":25,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.736009Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:3db3cad1c4a80d4ec0dc973d44dc058754eee3c7fbebcebe482c9f6d9946a961","observation_id":"b69e9af2-5b43-465d-80bb-e22e0dabaa2e","resolution":{"observed_at":"2026-08-06T19:16:28.451723Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.440290Z","title":"A systematic evaluation of automated tools for side-channel vulnerabilities detection in cryptographic libraries","venue":null,"work_id":"b298a126-40c8-47d8-8565-c6f15052dcca","year":2023},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":26,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.818339Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:d624dff12a4d5a0f190db3516709abe3ae0ec0697cf59578dd4dbb0220412855","observation_id":"24ea95b8-19c9-49a7-9717-17b17edf38d8","resolution":{"observed_at":"2026-08-06T19:16:28.443510Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.431013Z","title":"Do Compilers Break Constant-time Guarantees? In Financial Cryptography, 2025","venue":null,"work_id":"0253f248-750c-46e1-abfd-45928d7f417f","year":2025},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":27,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.906468Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c160572188a0f24e15fcb36f19e9b1fe69fd4c82003d6c3a2e0907bc15899e82","observation_id":"60e74c9f-f751-4ed9-8dc8-922beb7d351a","resolution":{"observed_at":"2026-08-06T19:16:28.434552Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.417300Z","title":"Compiler explorer","venue":null,"work_id":"bdb419c5-2b0e-4903-b737-74190cfa6f77","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":28,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:25.987172Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:1428d40536446feca437fba055592999cd07f28afd3e897e5855ec57c89e95e4","observation_id":"9ec8f716-7883-49d2-928f-bcec554e1a68","resolution":{"observed_at":"2026-08-06T19:16:28.420537Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.409492Z","title":"Side-channel analysis of cryptographic software via early-terminating multiplications","venue":null,"work_id":"7de142a9-756a-4d48-94e9-23bf8be1f5bf","year":2009},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":29,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.081984Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:6b51b4948ce44990312393e20dc185a4e9198a24a2fa673912fc747447df751f","observation_id":"e672fbf8-1732-427e-97ce-2a9fc19417dc","resolution":{"observed_at":"2026-08-06T19:16:28.412389Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.401437Z","title":"Request for a conditional move built-in function","venue":null,"work_id":"b479d9b1-5938-469e-b92c-7ac34fdbe0f6","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":30,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.174698Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:a2f282121f4034dd3ac1ffaee9dc7bca3efbce369b0a9eee8cfc459efdf4d7c4","observation_id":"e0615ea8-0471-49e6-92ad-0e9e847773b6","resolution":{"observed_at":"2026-08-06T19:16:28.404494Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.393608Z","title":"Cache attacks enable bulk key recovery on the cloud","venue":null,"work_id":"ce767b2f-013a-4d7a-8aac-16e0ab2bdac2","year":2016},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":31,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.264448Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c848e0b10586bd11d7b440ed4401b5cb0e7fad2c477274e60827ef4769ea17e4","observation_id":"cdd3069e-a5f0-486f-97c6-21648263bd08","resolution":{"observed_at":"2026-08-06T19:16:28.396209Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.385325Z","title":"Guidelines for Mitigating Timing Side Channels Against Cryp- tographic Implementations","venue":null,"work_id":"0b600e2a-508e-40ba-9400-9437c1c7cab8","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":32,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.354692Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:48fe946048c1452d2633b8c9e5c2c971b2751461a7fb1fb8a9c00df9ca2b5a4d","observation_id":"55472df1-18da-403f-b077-fbd3a4734901","resolution":{"observed_at":"2026-08-06T19:16:28.388306Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.377525Z","title":"”they’re not that hard to mitigate”: What cryptographic library develop- ers think about timing attacks","venue":null,"work_id":"4aca5170-567c-48d6-8e25-e4a5eabb6210","year":2022},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":33,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.441027Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:dc84b504d580a89a66d2928e54e09a41d4561c6038ca2321bf6ac4ef15c09c4e","observation_id":"dc76a2b3-7a84-4ba4-9e25-1dddf038f91a","resolution":{"observed_at":"2026-08-06T19:16:28.380251Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.370129Z","title":null,"venue":null,"work_id":"de2f4143-c37c-46f6-a471-f84f316c3530","year":1999},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":34,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.504670Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:9f0e17e09b787462915cd1206ff998461ea9805789dd4c461ce0d68b3494b7f7","observation_id":"320e5a17-13ae-4717-a75e-cd7860a772da","resolution":{"observed_at":"2026-08-06T19:16:28.372697Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.362290Z","title":"ct choose: Constant-time choose between two variables","venue":null,"work_id":"0155c7da-e797-4960-85b8-61dd8d87be0f","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":35,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.510955Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:5d6bdcb15fbf9ed157335a2b603636272474d1a1d204b825c82d373016d203d6","observation_id":"a2ea730b-3b58-4ce7-bc37-3496a43bed40","resolution":{"observed_at":"2026-08-06T19:16:28.365012Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.354761Z","title":"A survey of microarchitectural side-channel vulnerabilities, attacks, and defenses in cryptography","venue":null,"work_id":"84033a9f-4a55-4125-8a04-40c6bd9727d8","year":2022},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":36,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.710121Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:e483737106db5f8de9eefe8496bd0413e9fd8a3914dd5e30ff87eb2b931c4f18","observation_id":"7804e42c-9e4b-494b-b90b-74ee58e1e558","resolution":{"observed_at":"2026-08-06T19:16:28.357505Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2501.04183","last_updated":"2026-07-13T06:10:16Z","snapshot_observed_at":"2026-08-10T21:37:16.023730Z","submitted_at":"2025-01-07T23:29:01Z","title":"Decompiling for Constant-Time Analysis","version":4},"cited_work":{"arxiv_id":"2501.04183","doi":null,"metadata_source":"pith","pith_arxiv_id":"2501.04183","snapshot_observed_at":"2026-08-06T19:16:28.230908Z","title":"Decompiling for Constant-Time Analysis","venue":"cs.PL","work_id":"433d404b-f918-4d42-9ff8-f9eee4a73f34","year":2025},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":37,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.889755Z"},"links":{"cited_paper":"/paper/2501.04183","citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:0b57270928b974f41853f6d41a9640f28c610bbe522ba9a03f159686ce061507","observation_id":"9d561f87-e3c2-4471-b9f3-3ff1d4503425","resolution":{"observed_at":"2026-08-06T19:16:28.234431Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.346885Z","title":"Cache Missing for Fun and Profit","venue":null,"work_id":"c4b3e455-2458-45f2-969a-dd521141f7e9","year":2005},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":38,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:26.992214Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:febdf70b0222e6de6798558c65131a3804fd6dd7a15d16ae14b4dc18d1d79338","observation_id":"98c10d35-1716-4ff1-a793-b2eb981cb75e","resolution":{"observed_at":"2026-08-06T19:16:28.349887Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.338919Z","title":null,"venue":null,"work_id":"6b6c77c2-3e02-4952-a5bb-f3baa6e5f159","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":39,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.078337Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:2d46664147289d3cbd33ee9518ec339d6bf3c2a8f42be55965d4ef9de092a1ec","observation_id":"685548c8-45a0-4ef7-834c-f6682c2b1c2c","resolution":{"observed_at":"2026-08-06T19:16:28.341675Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.331478Z","title":"Constant-time code: The pessimist case","venue":null,"work_id":"8d2a7e97-9333-4188-b963-99351a23d353","year":2025},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":40,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.214837Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:ac5a00947b5fe8a056f8f70326f1928bbf7bb0984981aa7a0bebe3c2926c8c64","observation_id":"16a97e8c-7306-4bbc-a415-055e4cba499d","resolution":{"observed_at":"2026-08-06T19:16:28.334070Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.323697Z","title":"Compiler-introduced timing leak in Kyber reference implementation","venue":null,"work_id":"2bc9e103-a798-4b9c-8852-7d8d00f78ce5","year":2024},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":41,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.314501Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:f782763da8a90d683280dfada2ffc8590ebbdeb6810adda822c36fa655704fd5","observation_id":"ff5e5a7a-3dec-4152-91d0-1621374cc5dc","resolution":{"observed_at":"2026-08-06T19:16:28.326423Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2410.13489","last_updated":"2025-09-02T07:57:35Z","snapshot_observed_at":"2026-08-06T15:22:16.593027Z","submitted_at":"2024-10-17T12:34:02Z","title":"Breaking Bad: How Compilers Break Constant-Time Implementations","version":2},"cited_work":{"arxiv_id":"2410.13489","doi":null,"metadata_source":"pith","pith_arxiv_id":"2410.13489","snapshot_observed_at":"2026-08-06T19:16:28.215867Z","title":"Breaking Bad: How Compilers Break Constant-Time Implementations","venue":"cs.CR","work_id":"40d4b1c1-9546-4b6c-b2b5-1c8a79071504","year":2024},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":42,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.379645Z"},"links":{"cited_paper":"/paper/2410.13489","citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:a6c968cdfe1500b6968e0010c60afc94c687db97716f738f8a8a7906f77d9d34","observation_id":"1d851552-e248-43e9-ba69-c91222341217","resolution":{"observed_at":"2026-08-06T19:16:28.221270Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.315963Z","title":"Chan Kim, D","venue":null,"work_id":"a6261f7d-4eda-433c-8b84-ba3a1d5c69c8","year":2018},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":43,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.486847Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:1fa57e1969cd8002126910becd91c8b4f537ea6ffe572403d621d906a15a98a6","observation_id":"62a24534-9a6f-4f54-8dff-d284f6adb685","resolution":{"observed_at":"2026-08-06T19:16:28.318446Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.307821Z","title":"Anderson","venue":null,"work_id":"642a0f00-2582-4944-9a40-2bca7b37b4a7","year":2018},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":44,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.583634Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:30c54adc63662974925ee09f64867977bf1cff735c61089a56b33d2edeff7385","observation_id":"d352e068-1331-4069-b6c3-d5eb8a7fd680","resolution":{"observed_at":"2026-08-06T19:16:28.310831Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.300108Z","title":"Side-channel resistant values","venue":null,"work_id":"6795c3b8-dcb4-4618-9f11-e7192362dbb8","year":2019},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":45,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.658377Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:3747083b9a76fda1d26adc65178db89542561a44b5b9efc980df6bbeb522f6dd","observation_id":"a3fbd625-cf35-4cab-b760-fb933293e0b5","resolution":{"observed_at":"2026-08-06T19:16:28.302645Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.291976Z","title":"Stallman and the GCC Developer Community","venue":null,"work_id":"6cacda02-135c-40dd-b6f1-e6bc280c5c65","year":null},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":46,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.759132Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:2c11fc8a74b11957606e8649b4bed74409a3628db8a328f391aa332c2956a65f","observation_id":"2c470d28-0810-4999-8f66-6e4c00539eca","resolution":{"observed_at":"2026-08-06T19:16:28.294696Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.283682Z","title":"Wichelmann, F","venue":null,"work_id":"8bfb1521-b5fc-480c-b9b5-bed6d98e3d20","year":2022},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":47,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.871948Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:7753b965e75560a27b42ff78e6118671f5b7f6a28b26b9349f49272881e95f15","observation_id":"29d40dfc-3522-4a48-8436-da453cf21499","resolution":{"observed_at":"2026-08-06T19:16:28.286841Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.275244Z","title":"Microwalk: A framework for finding side channels in binaries","venue":null,"work_id":"db9df78e-c978-476f-ac78-3c051ae4f95b","year":2018},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":48,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:27.973952Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c4d00f3f9ee80159bc68f88bb765917c875c1ca56c547e04d95ac6c14b93291f","observation_id":"b47e3def-6b98-49ef-87dd-da57cccf4cee","resolution":{"observed_at":"2026-08-06T19:16:28.278331Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.266420Z","title":"Silent Bugs Matter: A Study of Compiler- Introduced Security Bugs","venue":null,"work_id":"3a605ddd-e90d-4c40-8a94-8b36cc224c5c","year":2023},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":49,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:28.095221Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:28be720e53f764bff235f8f945fd47d5857358be6f387194c9698f96f960c9e6","observation_id":"3c9bff37-9d22-4b13-b2c4-c3c9b75f2b94","resolution":{"observed_at":"2026-08-06T19:16:28.269577Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.257482Z","title":"FLUSH+RELOAD: A high reso- lution, low noise, L3 cache side-channel attack","venue":null,"work_id":"6365aa65-d968-41cd-a1f5-95afe6ea7851","year":2014},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":50,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:28.173804Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:fb9a6328a424ac60a4aeb7c88e801e9d7f648fc6ec9fc2b979df1f50eb1b4a66","observation_id":"e6479828-a6e7-4b43-b289-7c33dbfe13d2","resolution":{"observed_at":"2026-08-06T19:16:28.260389Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.249184Z","title":"CT-LLVM: Automatic Large-Scale Constant-Time Analysis","venue":null,"work_id":"c888758a-8cd9-475a-88dc-b0afc735b50b","year":2025},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":51,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:28.182785Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:f9d72a90d51455bbe147eb09bb1e9f3ce729ea298cbb046af89afed28c7bc159","observation_id":"96717aeb-8cdd-4554-8880-e5725df1bacb","resolution":{"observed_at":"2026-08-06T19:16:28.252035Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-06T19:16:28.240392Z","title":null,"venue":null,"work_id":"b1d1014d-fcf6-4885-8e4b-8781646dec51","year":2017},"citing_paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code","version":1},"reference_index":52,"source":"pdf_text","source_observed_at":"2026-08-06T19:16:28.187228Z"},"links":{"citing_paper":"/paper/2507.06112"},"observation_digest":"sha256:c8e864525f219bf0ff794cf4830a3f6fa91f1b19ee85646442a2789b0759e309","observation_id":"ed9325a3-387c-43b0-ab7d-9bf821f6cd2a","resolution":{"observed_at":"2026-08-06T19:16:28.243799Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-10T06:31:04.303077+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"state":"measured"}}],"paper":{"arxiv_id":"2507.06112","last_updated":"2025-07-08T15:52:17Z","latest_version":1,"primary_category":"cs.CR","snapshot_observed_at":"2026-08-09T08:45:56.321406Z","submitted_at":"2025-07-08T15:52:17Z","title":"Fun with flags: How Compilers Break and Fix Constant-Time Code"},"reference_resolution":{"displayed":52,"state_counts":{"malformed_identifier":0,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":4,"verified_exact":2,"verified_fuzzy":46},"total_outbound_references":52},"refusal":"A citation records a reference. It does not transfer a finding from one paper to another.","schema":"pith.paper-citation-record.v1","standing_sources":[{"observed_at":"2026-08-10T06:31:04.303077+00:00","source":"crossref"},{"observed_at":"2026-08-10T06:30:57.382061+00:00","source":"retraction_watch"}],"thesis":"As of 10 August 2026, this Paper Citation Record lists 52 of 52 outbound references and 1 inbound Pith citation observation for arXiv:2507.06112."}