gitextract_cva_42qr/ ├── .cargo/ │ └── config.toml ├── .docker/ │ └── Dockerfile ├── .dockerignore ├── .envrc ├── .github/ │ ├── assets/ │ │ └── change-padding.sh │ └── workflows/ │ ├── bertie.yml │ ├── changelog.yml │ ├── clippy_rust_engine.yml │ ├── extract_and_run_coq.yml │ ├── flake_lock.yml │ ├── format.yml │ ├── gh_pages.yml │ ├── install_and_test.yml │ ├── licenses.yml │ ├── mldsa.yml │ ├── mlkem.yml │ ├── playwright-docs.yml │ ├── release.yml │ ├── rustc-coverage-tests.yml │ ├── stale.yml │ ├── test.yml │ ├── test_installs.yml │ └── this-month-in-hax.yml ├── .gitignore ├── .utils/ │ ├── jq_utils.jq │ ├── rebuild.sh │ ├── rust-by-example.js │ └── this-month-in-hax-skeleton.sh ├── CHANGELOG.md ├── CI.md ├── CODEOWNERS ├── CONTRIBUTING.md ├── Cargo.toml ├── LICENSE ├── PUBLISHING.md ├── README.md ├── cli/ │ ├── default.nix │ ├── driver/ │ │ ├── Cargo.toml │ │ └── src/ │ │ ├── callbacks_wrapper.rs │ │ ├── driver.rs │ │ ├── exporter.rs │ │ └── features.rs │ └── subcommands/ │ ├── Cargo.toml │ ├── build.rs │ └── src/ │ ├── cargo_hax.rs │ ├── engine_debug_webapp/ │ │ ├── README.md │ │ ├── mod.rs │ │ └── static/ │ │ ├── index.html │ │ └── script.js │ └── json_schema.rs ├── deny.toml ├── dependabot.yml ├── docs/ │ ├── .test/ │ │ ├── .gitignore │ │ ├── global-setup.ts │ │ ├── package.json │ │ ├── playwright.config.ts │ │ └── tests/ │ │ └── docs.spec.ts │ ├── RFCs/ │ │ ├── .nav.yml │ │ ├── 0000-template.md │ │ └── index.md │ ├── blog/ │ │ ├── .authors.yml │ │ ├── index.md │ │ └── posts/ │ │ ├── announce-v0.1.md │ │ ├── hax-for-everyone.md │ │ ├── lucas-departure.md │ │ ├── reworking-names/ │ │ │ └── reworking-names.md │ │ ├── rust-gcd-1.md │ │ ├── rust-gcd-2.md │ │ └── this-month-in-hax/ │ │ ├── 2025-01.md │ │ ├── 2025-02.md │ │ ├── 2025-03.md │ │ ├── 2025-04.md │ │ ├── 2025-05.md │ │ ├── 2025-06.md │ │ ├── 2025-07.md │ │ ├── 2025-08.md │ │ ├── 2025-09.md │ │ ├── 2025-10.md │ │ ├── 2025-11.md │ │ ├── 2026-01.md │ │ ├── 2026-02.md │ │ ├── 2026-03.md │ │ └── 2026-04.md │ ├── default.nix │ ├── dev/ │ │ ├── architecture.md │ │ ├── ast_ebnf.md │ │ ├── docs.md │ │ ├── index.md │ │ └── libraries_macros.md │ ├── engine/ │ │ ├── index.md │ │ └── toolchain_structure/ │ │ └── index.md │ ├── frontend/ │ │ ├── evaluation.md │ │ └── index.md │ ├── index.md │ ├── javascripts/ │ │ ├── ansi_up.js │ │ ├── fstar.js │ │ ├── hax_playground.js │ │ └── lz-string.js │ ├── manual/ │ │ ├── faq/ │ │ │ ├── include-flags.md │ │ │ ├── index.md │ │ │ └── into.md │ │ ├── fstar/ │ │ │ ├── .nav.yml │ │ │ ├── index.md │ │ │ ├── quick_start.md │ │ │ └── tutorial/ │ │ │ ├── data-invariants.md │ │ │ ├── index.md │ │ │ ├── panic-freedom.md │ │ │ ├── proofs/ │ │ │ │ └── fstar/ │ │ │ │ └── extraction/ │ │ │ │ ├── Makefile │ │ │ │ ├── Tutorial_src.Math.Lemmas.fst │ │ │ │ └── Tutorial_src.fst │ │ │ └── properties.md │ │ ├── index.md │ │ └── lean/ │ │ ├── index.md │ │ ├── internals.md │ │ ├── quick_start.md │ │ └── tutorial/ │ │ ├── index.md │ │ ├── panic-freedom.md │ │ └── properties.md │ ├── overrides/ │ │ └── main.html │ ├── publications.md │ └── stylesheets/ │ ├── hax_playground.css │ ├── logo.css │ └── tags-colors.css ├── engine/ │ ├── .ocamlformat │ ├── DEV.md │ ├── backends/ │ │ ├── coq/ │ │ │ ├── coq/ │ │ │ │ ├── coq_backend.ml │ │ │ │ ├── coq_backend.mli │ │ │ │ └── dune │ │ │ ├── coq_ast.ml │ │ │ ├── dune │ │ │ └── ssprove/ │ │ │ ├── dune │ │ │ ├── ssprove_backend.ml │ │ │ └── ssprove_backend.mli │ │ ├── easycrypt/ │ │ │ ├── dune │ │ │ ├── easycrypt_backend.ml │ │ │ └── easycrypt_backend.mli │ │ ├── fstar/ │ │ │ ├── dune │ │ │ ├── fstar-surface-ast/ │ │ │ │ ├── .gitignore │ │ │ │ ├── .ocamlformat-ignore │ │ │ │ ├── FStar_BaseTypes.ml │ │ │ │ ├── FStar_Char.ml │ │ │ │ ├── FStar_Compiler_Effect.ml │ │ │ │ ├── FStar_Compiler_List.ml │ │ │ │ ├── FStar_Compiler_Range.ml │ │ │ │ ├── FStar_Compiler_Util.ml │ │ │ │ ├── FStar_Const.ml │ │ │ │ ├── FStar_Errors.ml │ │ │ │ ├── FStar_Errors_Codes.ml │ │ │ │ ├── FStar_Getopt.ml │ │ │ │ ├── FStar_Ident.ml │ │ │ │ ├── FStar_ImmutableArray_Base.ml │ │ │ │ ├── FStar_List.ml │ │ │ │ ├── FStar_Parser_AST.ml │ │ │ │ ├── FStar_Parser_AST_Util.ml │ │ │ │ ├── FStar_Parser_Const.ml │ │ │ │ ├── FStar_Parser_Driver.ml │ │ │ │ ├── FStar_Parser_LexFStar.ml │ │ │ │ ├── FStar_Parser_Parse.ml │ │ │ │ ├── FStar_Parser_ParseIt.ml │ │ │ │ ├── FStar_Parser_ToDocument.ml │ │ │ │ ├── FStar_Parser_Utf8.ml │ │ │ │ ├── FStar_Parser_Util.ml │ │ │ │ ├── FStar_Pervasives.ml │ │ │ │ ├── FStar_Pervasives_Native.ml │ │ │ │ ├── FStar_Pprint.ml │ │ │ │ ├── FStar_Sedlexing.ml │ │ │ │ ├── FStar_String.ml │ │ │ │ ├── FStar_VConfig.ml │ │ │ │ ├── README │ │ │ │ ├── dune │ │ │ │ ├── prims.ml │ │ │ │ └── z.ml │ │ │ ├── fstar_ast.ml │ │ │ ├── fstar_backend.ml │ │ │ └── fstar_backend.mli │ │ ├── lean/ │ │ │ ├── dune │ │ │ └── lean_backend.ml │ │ └── proverif/ │ │ ├── dune │ │ ├── proverif_backend.ml │ │ └── proverif_backend.mli │ ├── bin/ │ │ ├── dune │ │ ├── dune-js │ │ ├── js_driver.ml │ │ ├── js_stubs/ │ │ │ ├── mutex.js │ │ │ ├── stdint.js │ │ │ └── unix.js │ │ ├── lib.ml │ │ ├── lib.mli │ │ └── native_driver.ml │ ├── default.nix │ ├── doc/ │ │ ├── dune │ │ └── index.mld │ ├── dune-project │ ├── hax-engine.opam │ ├── hax-engine.opam.template │ ├── lib/ │ │ ├── analyses/ │ │ │ ├── function_dependency.ml │ │ │ └── mutable_variables.ml │ │ ├── analyses.ml │ │ ├── ast.ml │ │ ├── ast_builder.ml │ │ ├── ast_destruct.ml │ │ ├── ast_utils.ml │ │ ├── attr_payloads.ml │ │ ├── backend.ml │ │ ├── concrete_ident/ │ │ │ ├── concrete_ident.ml │ │ │ ├── concrete_ident.mli │ │ │ ├── concrete_ident_render_sig.ml │ │ │ ├── concrete_ident_types.ml │ │ │ ├── concrete_ident_view.ml │ │ │ ├── concrete_ident_view.mli │ │ │ ├── concrete_ident_view_types.ml │ │ │ ├── explicit_def_id.ml │ │ │ ├── explicit_def_id.mli │ │ │ ├── impl_infos.ml │ │ │ └── thir_simple_types.ml │ │ ├── dependencies.ml │ │ ├── dependencies.mli │ │ ├── deprecated_generic_printer/ │ │ │ ├── deprecated_generic_printer.ml │ │ │ ├── deprecated_generic_printer.mli │ │ │ └── deprecated_generic_printer_base.ml │ │ ├── diagnostics.ml │ │ ├── dune │ │ ├── export_ast.ml │ │ ├── feature_gate.ml │ │ ├── features.ml │ │ ├── generic_printer/ │ │ │ ├── generic_printer.ml │ │ │ ├── generic_printer_template.generate.js │ │ │ └── generic_printer_template.ml │ │ ├── hax_io.ml │ │ ├── import_ast.ml │ │ ├── import_thir.ml │ │ ├── import_thir.mli │ │ ├── local_ident.ml │ │ ├── local_ident.mli │ │ ├── phase_utils.ml │ │ ├── phases/ │ │ │ ├── phase_and_mut_defsite.ml │ │ │ ├── phase_and_mut_defsite.mli │ │ │ ├── phase_bundle_cycles.ml │ │ │ ├── phase_bundle_cycles.mli │ │ │ ├── phase_cf_into_monads.ml │ │ │ ├── phase_cf_into_monads.mli │ │ │ ├── phase_direct_and_mut.ml │ │ │ ├── phase_direct_and_mut.mli │ │ │ ├── phase_drop_blocks.ml │ │ │ ├── phase_drop_blocks.mli │ │ │ ├── phase_drop_match_guards.ml │ │ │ ├── phase_drop_match_guards.mli │ │ │ ├── phase_drop_references.ml │ │ │ ├── phase_drop_references.mli │ │ │ ├── phase_drop_return_break_continue.ml │ │ │ ├── phase_drop_return_break_continue.mli │ │ │ ├── phase_drop_sized_trait.ml │ │ │ ├── phase_drop_sized_trait.mli │ │ │ ├── phase_explicit_conversions.ml │ │ │ ├── phase_explicit_conversions.mli │ │ │ ├── phase_functionalize_loops.ml │ │ │ ├── phase_functionalize_loops.mli │ │ │ ├── phase_hoist_disjunctive_patterns.ml │ │ │ ├── phase_hoist_disjunctive_patterns.mli │ │ │ ├── phase_local_mutation.ml │ │ │ ├── phase_local_mutation.mli │ │ │ ├── phase_newtype_as_refinement.ml │ │ │ ├── phase_newtype_as_refinement.mli │ │ │ ├── phase_reconstruct_asserts.ml │ │ │ ├── phase_reconstruct_asserts.mli │ │ │ ├── phase_reconstruct_for_index_loops.ml │ │ │ ├── phase_reconstruct_for_index_loops.mli │ │ │ ├── phase_reconstruct_for_loops.ml │ │ │ ├── phase_reconstruct_for_loops.mli │ │ │ ├── phase_reconstruct_question_marks.ml │ │ │ ├── phase_reconstruct_question_marks.mli │ │ │ ├── phase_reconstruct_while_loops.ml │ │ │ ├── phase_reconstruct_while_loops.mli │ │ │ ├── phase_reject.ml │ │ │ ├── phase_reject_impl_type_method.ml │ │ │ ├── phase_reject_impl_type_method.mli │ │ │ ├── phase_reorder_fields.ml │ │ │ ├── phase_reorder_fields.mli │ │ │ ├── phase_rewrite_control_flow.ml │ │ │ ├── phase_rewrite_control_flow.mli │ │ │ ├── phase_rewrite_local_self.ml │ │ │ ├── phase_rewrite_local_self.mli │ │ │ ├── phase_simplify_hoisting.ml │ │ │ ├── phase_simplify_hoisting.mli │ │ │ ├── phase_simplify_match_return.ml │ │ │ ├── phase_simplify_match_return.mli │ │ │ ├── phase_simplify_question_marks.ml │ │ │ ├── phase_simplify_question_marks.mli │ │ │ ├── phase_sort_items.ml │ │ │ ├── phase_sort_items.mli │ │ │ ├── phase_sort_items_namespace_wise.ml │ │ │ ├── phase_sort_items_namespace_wise.mli │ │ │ ├── phase_specialize.ml │ │ │ ├── phase_specialize.mli │ │ │ ├── phase_traits_specs.ml │ │ │ ├── phase_traits_specs.mli │ │ │ ├── phase_transform_hax_lib_inline.ml │ │ │ ├── phase_transform_hax_lib_inline.mli │ │ │ ├── phase_trivialize_assign_lhs.ml │ │ │ └── phase_trivialize_assign_lhs.mli │ │ ├── phases.ml │ │ ├── prelude.ml │ │ ├── print_rust.ml │ │ ├── print_rust.mli │ │ ├── profiling.ml │ │ ├── rust_engine_types.ml │ │ ├── side_effect_utils.ml │ │ ├── span.ml │ │ ├── span.mli │ │ ├── subtype.ml │ │ ├── untyped_phases/ │ │ │ ├── gen.js │ │ │ └── untyped_phases.ml │ │ └── utils.ml │ ├── names/ │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── extract/ │ │ │ ├── Cargo.toml │ │ │ ├── build.rs │ │ │ └── src/ │ │ │ └── main.rs │ │ └── src/ │ │ ├── crypto_abstractions.rs │ │ └── lib.rs │ └── utils/ │ ├── generate_from_ast/ │ │ ├── README.md │ │ ├── codegen_ast_builder.ml │ │ ├── codegen_ast_destruct.ml │ │ ├── codegen_printer.ml │ │ ├── codegen_visitor.ml │ │ ├── dune │ │ ├── errors.ml │ │ ├── generate_from_ast.ml │ │ ├── primitive_types.ml │ │ ├── types.ml │ │ ├── utils.ml │ │ └── visitors.ml │ ├── hacspeclib-macro-parser/ │ │ ├── dune │ │ └── hacspeclib_macro_parser.ml │ ├── ocaml_of_json_schema/ │ │ └── ocaml_of_json_schema.js │ ├── ppx_functor_application/ │ │ ├── README.md │ │ ├── dune │ │ └── ppx_functor_application.ml │ ├── ppx_generate_features/ │ │ ├── README.md │ │ ├── dune │ │ └── ppx_generate_features.ml │ ├── ppx_inline/ │ │ ├── README.md │ │ ├── dune │ │ └── ppx_inline.ml │ ├── ppx_phases_index/ │ │ ├── README.md │ │ ├── dune │ │ └── ppx_phases_index.ml │ ├── sourcemaps/ │ │ ├── base64.ml │ │ ├── dune │ │ ├── location.ml │ │ ├── mappings/ │ │ │ ├── dual.ml │ │ │ ├── instruction.ml │ │ │ ├── mappings.ml │ │ │ ├── mappings.mli │ │ │ ├── spanned.ml │ │ │ └── types.ml │ │ ├── prelude.ml │ │ ├── source_maps.ml │ │ ├── source_maps.mli │ │ └── vql.ml │ └── universe-hash.sh ├── examples/ │ ├── .envrc │ ├── .gitignore │ ├── Cargo.toml │ ├── Makefile │ ├── README.md │ ├── barrett/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ ├── fstar/ │ │ │ │ └── extraction/ │ │ │ │ └── Makefile │ │ │ ├── lean/ │ │ │ │ ├── lakefile.toml │ │ │ │ └── lean-toolchain │ │ │ └── rust/ │ │ │ └── extraction/ │ │ │ └── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ ├── chacha20/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ ├── coq/ │ │ │ │ └── extraction/ │ │ │ │ ├── Chacha20.Hacspec_helper.v │ │ │ │ └── Chacha20.v │ │ │ └── fstar/ │ │ │ └── extraction/ │ │ │ ├── Chacha20.Hacspec_helper.fst │ │ │ ├── Chacha20.fst │ │ │ └── Makefile │ │ ├── src/ │ │ │ ├── hacspec_helper.rs │ │ │ └── lib.rs │ │ └── tests/ │ │ └── kat.rs │ ├── commonArgs.nix │ ├── coq-example/ │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── proofs/ │ │ │ └── coq/ │ │ │ └── extraction/ │ │ │ ├── Coq_example.v │ │ │ ├── Coq_example_Dummy_core_lib.v │ │ │ ├── Coq_proofs.v │ │ │ ├── Makefile │ │ │ └── dummy_core_lib.v │ │ └── src/ │ │ ├── dummy_core_lib.rs │ │ └── lib.rs │ ├── coverage/ │ │ ├── Cargo.toml │ │ ├── default.nix │ │ └── src/ │ │ ├── lib.rs │ │ ├── test_arrays.rs │ │ ├── test_closures.rs │ │ ├── test_enum.rs │ │ ├── test_functions.rs │ │ ├── test_instance.rs │ │ ├── test_primitives.rs │ │ ├── test_sequence.rs │ │ ├── test_struct.rs │ │ └── test_trait.rs │ ├── default.nix │ ├── hax.fst.config.json │ ├── kyber_compress/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ └── fstar/ │ │ │ └── extraction/ │ │ │ └── Makefile │ │ └── src/ │ │ └── lib.rs │ ├── lean_adc/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ └── lean/ │ │ │ ├── lake-manifest.json │ │ │ ├── lakefile.toml │ │ │ └── lean-toolchain │ │ └── src/ │ │ └── lib.rs │ ├── lean_barrett/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ └── lean/ │ │ │ ├── lake-manifest.json │ │ │ ├── lakefile.toml │ │ │ └── lean-toolchain │ │ └── src/ │ │ └── lib.rs │ ├── lean_chacha20/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ └── lean/ │ │ │ ├── lake-manifest.json │ │ │ ├── lakefile.toml │ │ │ └── lean-toolchain │ │ └── src/ │ │ ├── hacspec_helper.rs │ │ └── lib.rs │ ├── lean_tutorial/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── proofs/ │ │ │ └── lean/ │ │ │ ├── lake-manifest.json │ │ │ ├── lakefile.toml │ │ │ └── lean-toolchain │ │ └── src/ │ │ └── lib.rs │ ├── limited-order-book/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── README.md │ │ ├── lob_backend.did │ │ ├── proofs/ │ │ │ ├── coq/ │ │ │ │ └── extraction/ │ │ │ │ └── Lob_backend.v │ │ │ └── fstar/ │ │ │ └── extraction/ │ │ │ ├── Lob_backend.fst │ │ │ └── Makefile │ │ └── src/ │ │ ├── canister.rs │ │ └── lib.rs │ ├── proverif-psk/ │ │ ├── Cargo.toml │ │ ├── Makefile │ │ ├── Readme.md │ │ ├── proofs/ │ │ │ └── proverif/ │ │ │ └── analysis.pv │ │ ├── psk.pv │ │ ├── pv_div_by_zero_fix.diff │ │ └── src/ │ │ └── lib.rs │ └── sha256/ │ ├── .gitignore │ ├── Cargo.toml │ ├── Makefile │ ├── proofs/ │ │ ├── coq/ │ │ │ └── extraction/ │ │ │ └── Sha256.v │ │ └── fstar/ │ │ └── extraction/ │ │ ├── Makefile │ │ └── Sha256.fst │ ├── src/ │ │ └── sha256.rs │ └── tests/ │ └── test_sha256.rs ├── flake.nix ├── frontend/ │ └── exporter/ │ ├── Cargo.toml │ ├── README.md │ ├── adt-into/ │ │ ├── .gitignore │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── src/ │ │ │ └── lib.rs │ │ └── tests/ │ │ └── lib.rs │ ├── default.nix │ ├── options/ │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ └── src/ │ ├── body.rs │ ├── comments.rs │ ├── constant_utils/ │ │ └── uneval.rs │ ├── constant_utils.rs │ ├── deterministic_hash.rs │ ├── id_table.rs │ ├── index_vec.rs │ ├── lib.rs │ ├── prelude.rs │ ├── rustc_utils.rs │ ├── sinto.rs │ ├── state.rs │ ├── traits/ │ │ ├── resolution.rs │ │ └── utils.rs │ ├── traits.rs │ ├── types/ │ │ ├── attributes.rs │ │ ├── def_id.rs │ │ ├── hir.rs │ │ ├── mir.rs │ │ ├── mod.rs │ │ ├── new/ │ │ │ ├── full_def.rs │ │ │ ├── impl_infos.rs │ │ │ ├── item_attributes.rs │ │ │ ├── mod.rs │ │ │ ├── predicate_id.rs │ │ │ ├── synthetic_items.rs │ │ │ └── variant_infos.rs │ │ ├── serialize_int.rs │ │ ├── span.rs │ │ ├── thir.rs │ │ └── ty.rs │ └── utils/ │ ├── error_macros.rs │ ├── mod.rs │ └── type_map.rs ├── hax-bounded-integers/ │ ├── Cargo.toml │ ├── proofs/ │ │ └── fstar/ │ │ └── extraction/ │ │ ├── Hax_bounded_integers.Num_traits.fst │ │ └── Hax_bounded_integers.fst │ └── src/ │ ├── lib.rs │ └── num_traits.rs ├── hax-lib/ │ ├── Cargo.toml │ ├── README.md │ ├── build.rs │ ├── core-models/ │ │ ├── .gitignore │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── alloc/ │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── hax.sh │ │ ├── rand_core/ │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── rust_primitives/ │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── src/ │ │ │ ├── core/ │ │ │ │ ├── array.rs │ │ │ │ ├── borrow.rs │ │ │ │ ├── clone.rs │ │ │ │ ├── cmp.rs │ │ │ │ ├── convert.rs │ │ │ │ ├── default.rs │ │ │ │ ├── error.rs │ │ │ │ ├── f32.rs │ │ │ │ ├── fmt.rs │ │ │ │ ├── hash.rs │ │ │ │ ├── hint.rs │ │ │ │ ├── iter.rs │ │ │ │ ├── marker.rs │ │ │ │ ├── mem.rs │ │ │ │ ├── num/ │ │ │ │ │ ├── error.rs │ │ │ │ │ └── mod.rs │ │ │ │ ├── ops.rs │ │ │ │ ├── option.rs │ │ │ │ ├── panicking.rs │ │ │ │ ├── result.rs │ │ │ │ ├── slice.rs │ │ │ │ └── str.rs │ │ │ └── lib.rs │ │ └── std/ │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ ├── macros/ │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── src/ │ │ │ ├── dummy.rs │ │ │ ├── hax_paths.rs │ │ │ ├── impl_fn_decoration.rs │ │ │ ├── implementation.rs │ │ │ ├── lib.rs │ │ │ ├── quote.rs │ │ │ ├── rewrite_self.rs │ │ │ ├── syn_ext.rs │ │ │ └── utils.rs │ │ └── types/ │ │ ├── Cargo.toml │ │ ├── README.md │ │ └── src/ │ │ └── lib.rs │ ├── proof-libs/ │ │ ├── coq/ │ │ │ ├── coq/ │ │ │ │ ├── .gitignore │ │ │ │ ├── default.nix │ │ │ │ └── generated-core/ │ │ │ │ ├── _CoqProject │ │ │ │ ├── phase_library/ │ │ │ │ │ ├── ControlFlow.v │ │ │ │ │ ├── NumberNotation.v │ │ │ │ │ └── TODO.v │ │ │ │ ├── spec/ │ │ │ │ │ ├── Core_Base_Spec.v │ │ │ │ │ ├── Core_Base_Spec_Binary.v │ │ │ │ │ ├── Core_Base_Spec_Binary_Pos.v │ │ │ │ │ ├── Core_Base_Spec_Binary_Positive.v │ │ │ │ │ ├── Core_Base_Spec_Constants.v │ │ │ │ │ ├── Core_Base_Spec_Haxint.v │ │ │ │ │ ├── Core_Base_Spec_Seq.v │ │ │ │ │ ├── Core_Base_Spec_Unary.v │ │ │ │ │ └── Core_Base_Spec_Z.v │ │ │ │ └── src/ │ │ │ │ ├── Core.v │ │ │ │ ├── Core_Array.v │ │ │ │ ├── Core_Array_Iter.v │ │ │ │ ├── Core_Array_Rec_bundle_579704328.v │ │ │ │ ├── Core_Base.v │ │ │ │ ├── Core_Base_Binary.v │ │ │ │ ├── Core_Base_Number_conversion.v │ │ │ │ ├── Core_Base_Pos.v │ │ │ │ ├── Core_Base_Seq.v │ │ │ │ ├── Core_Base_Z.v │ │ │ │ ├── Core_Base_interface.v │ │ │ │ ├── Core_Base_interface_Coerce.v │ │ │ │ ├── Core_Base_interface_Int.v │ │ │ │ ├── Core_Base_interface_Int_I128_proofs.v │ │ │ │ ├── Core_Base_interface_Int_I16_proofs.v │ │ │ │ ├── Core_Base_interface_Int_I32_proofs.v │ │ │ │ ├── Core_Base_interface_Int_I64_proofs.v │ │ │ │ ├── Core_Base_interface_Int_I8_proofs.v │ │ │ │ ├── Core_Base_interface_Int_U128_proofs.v │ │ │ │ ├── Core_Base_interface_Int_U16_proofs.v │ │ │ │ ├── Core_Base_interface_Int_U32_proofs.v │ │ │ │ ├── Core_Base_interface_Int_U64_proofs.v │ │ │ │ ├── Core_Base_interface_Int_U8_proofs.v │ │ │ │ ├── Core_Clone.v │ │ │ │ ├── Core_Cmp.v │ │ │ │ ├── Core_Convert.v │ │ │ │ ├── Core_Fmt.v │ │ │ │ ├── Core_Intrinsics.v │ │ │ │ ├── Core_Iter.v │ │ │ │ ├── Core_Iter_Range.v │ │ │ │ ├── Core_Iter_Traits.v │ │ │ │ ├── Core_Iter_Traits_Collect.v │ │ │ │ ├── Core_Iter_Traits_Exact_size.v │ │ │ │ ├── Core_Iter_Traits_Iterator.v │ │ │ │ ├── Core_Iter_Traits_Marker.v │ │ │ │ ├── Core_Marker.v │ │ │ │ ├── Core_Num.v │ │ │ │ ├── Core_Num_Int_macros.v │ │ │ │ ├── Core_Num_Uint_macros.v │ │ │ │ ├── Core_Ops.v │ │ │ │ ├── Core_Ops_Arith.v │ │ │ │ ├── Core_Ops_Arith_Impls_for_prims.v │ │ │ │ ├── Core_Ops_Bit.v │ │ │ │ ├── Core_Ops_Bit_Impls_for_prims.v │ │ │ │ ├── Core_Ops_Function.v │ │ │ │ ├── Core_Ops_Index.v │ │ │ │ ├── Core_Ops_Index_range.v │ │ │ │ ├── Core_Ops_Range.v │ │ │ │ ├── Core_Option.v │ │ │ │ ├── Core_Panicking.v │ │ │ │ ├── Core_Primitive.v │ │ │ │ ├── Core_Primitive_Number_conversion.v │ │ │ │ ├── Core_Primitive_Number_conversion_i.v │ │ │ │ ├── Core_Result.v │ │ │ │ ├── Core_Slice.v │ │ │ │ ├── Core_Slice_Index.v │ │ │ │ ├── Core_Slice_Index_Private_slice_index.v │ │ │ │ ├── Core_Slice_Iter.v │ │ │ │ ├── Core_Slice_Iter_Macros.v │ │ │ │ └── _CoqProject │ │ │ └── ssprove/ │ │ │ ├── .gitignore │ │ │ ├── README.md │ │ │ ├── _CoqProject │ │ │ ├── coq-hacspec-ssprove.opam.template │ │ │ ├── docker_build/ │ │ │ │ └── Dockerfile │ │ │ └── src/ │ │ │ ├── ChoiceEquality.v │ │ │ ├── ConCertLib.v │ │ │ ├── Hacspec_Lib.v │ │ │ ├── Hacspec_Lib_Coercions.v │ │ │ ├── Hacspec_Lib_Comparable.v │ │ │ ├── Hacspec_Lib_Controlflow.v │ │ │ ├── Hacspec_Lib_Eq.v │ │ │ ├── Hacspec_Lib_Integers.v │ │ │ ├── Hacspec_Lib_Loops.v │ │ │ ├── Hacspec_Lib_Ltac.v │ │ │ ├── Hacspec_Lib_Monad.v │ │ │ ├── Hacspec_Lib_Natmod.v │ │ │ ├── Hacspec_Lib_Notation.v │ │ │ ├── Hacspec_Lib_Pre.v │ │ │ ├── Hacspec_Lib_Seq.v │ │ │ ├── Hacspec_Lib_TODO.v │ │ │ ├── LocationUtility.v │ │ │ └── dune │ │ ├── fstar/ │ │ │ ├── .envrc │ │ │ ├── Makefile.copy │ │ │ ├── README.md │ │ │ ├── core/ │ │ │ │ ├── Alloc.Alloc.fst │ │ │ │ ├── Alloc.Borrow.fst │ │ │ │ ├── Alloc.Boxed.fst │ │ │ │ ├── Alloc.Collections.Binary_heap.fst │ │ │ │ ├── Alloc.Collections.Btree.Set.fsti │ │ │ │ ├── Alloc.Collections.Vec_deque.fsti │ │ │ │ ├── Alloc.Fmt.fst │ │ │ │ ├── Alloc.Slice.fst │ │ │ │ ├── Alloc.String.fst │ │ │ │ ├── Alloc.Vec.Drain.fst │ │ │ │ ├── Alloc.Vec.Into_iter.fsti │ │ │ │ ├── Alloc.Vec.fst │ │ │ │ ├── Core_models.Array.Iter.fst │ │ │ │ ├── Core_models.Array.fst │ │ │ │ ├── Core_models.Borrow.fsti │ │ │ │ ├── Core_models.Bundle.fst │ │ │ │ ├── Core_models.Clone.fst │ │ │ │ ├── Core_models.Cmp.fst │ │ │ │ ├── Core_models.Convert.fst │ │ │ │ ├── Core_models.Core_arch.Arm_shared.Neon.fsti │ │ │ │ ├── Core_models.Core_arch.X86.Pclmulqdq.fsti │ │ │ │ ├── Core_models.Core_arch.X86.Sse2.fsti │ │ │ │ ├── Core_models.Core_arch.X86.fsti │ │ │ │ ├── Core_models.Core_arch.X86_64_.Sse2.fsti │ │ │ │ ├── Core_models.Core_arch.fsti │ │ │ │ ├── Core_models.Default.fsti │ │ │ │ ├── Core_models.Error.fsti │ │ │ │ ├── Core_models.F32.fst │ │ │ │ ├── Core_models.Fmt.Rt.fsti │ │ │ │ ├── Core_models.Fmt.fsti │ │ │ │ ├── Core_models.Hash.fsti │ │ │ │ ├── Core_models.Hint.fsti │ │ │ │ ├── Core_models.Iter.Adapters.Enumerate.fst │ │ │ │ ├── Core_models.Iter.Adapters.Flat_map.fst │ │ │ │ ├── Core_models.Iter.Adapters.Flatten.fst │ │ │ │ ├── Core_models.Iter.Adapters.Map.fst │ │ │ │ ├── Core_models.Iter.Adapters.Rev.fsti │ │ │ │ ├── Core_models.Iter.Adapters.Step_by.fst │ │ │ │ ├── Core_models.Iter.Adapters.Take.fst │ │ │ │ ├── Core_models.Iter.Adapters.Zip.fst │ │ │ │ ├── Core_models.Iter.Bundle.fst │ │ │ │ ├── Core_models.Iter.Sources.Repeat_with.fsti │ │ │ │ ├── Core_models.Iter.Traits.Collect.fst │ │ │ │ ├── Core_models.Iter.Traits.Iterator.fst │ │ │ │ ├── Core_models.Iter.Traits.fst │ │ │ │ ├── Core_models.Marker.fst │ │ │ │ ├── Core_models.Mem.Manually_drop.fsti │ │ │ │ ├── Core_models.Mem.Maybe_uninit.fsti │ │ │ │ ├── Core_models.Mem.Transmutability.fsti │ │ │ │ ├── Core_models.Mem.fsti │ │ │ │ ├── Core_models.Num.Error.fsti │ │ │ │ ├── Core_models.Num.Niche_types.fsti │ │ │ │ ├── Core_models.Num.fst │ │ │ │ ├── Core_models.Ops.Arith.fsti │ │ │ │ ├── Core_models.Ops.Bit.fsti │ │ │ │ ├── Core_models.Ops.Control_flow.fst │ │ │ │ ├── Core_models.Ops.Deref.fst │ │ │ │ ├── Core_models.Ops.Drop.fst │ │ │ │ ├── Core_models.Ops.Function.fst │ │ │ │ ├── Core_models.Ops.Index.IndexMut.fst │ │ │ │ ├── Core_models.Ops.Index.Index_mut.fst │ │ │ │ ├── Core_models.Ops.Index.fst │ │ │ │ ├── Core_models.Ops.Range.fst │ │ │ │ ├── Core_models.Ops.Try_trait.fst │ │ │ │ ├── Core_models.Option.fst │ │ │ │ ├── Core_models.Panicking.Internal.fsti │ │ │ │ ├── Core_models.Panicking.fst │ │ │ │ ├── Core_models.Result.fst │ │ │ │ ├── Core_models.Slice.Iter.fst │ │ │ │ ├── Core_models.Slice.fst │ │ │ │ ├── Core_models.Str.Converts.fsti │ │ │ │ ├── Core_models.Str.Error.fsti │ │ │ │ ├── Core_models.Str.Iter.fsti │ │ │ │ ├── Core_models.Str.Traits.fsti │ │ │ │ ├── Core_models.Str.fsti │ │ │ │ ├── Core_models.Time.fsti │ │ │ │ ├── Core_models.TypeClassPlaceHolder.fst │ │ │ │ ├── Core_models.fst │ │ │ │ ├── Makefile │ │ │ │ ├── README.md │ │ │ │ ├── Rand.Distr.Distribution.fsti │ │ │ │ ├── Rand.Distr.Integer.fsti │ │ │ │ ├── Rand.Distributions.Distribution.fsti │ │ │ │ ├── Rand.Distributions.Integer.fsti │ │ │ │ ├── Rand.Rng.fsti │ │ │ │ ├── Rand_core.Os.fsti │ │ │ │ ├── Rand_core.fsti │ │ │ │ ├── Std.Collections.Hash.Map.fsti │ │ │ │ ├── Std.F64.fsti │ │ │ │ ├── Std.Hash.Random.fsti │ │ │ │ ├── Std.Io.Error.fsti │ │ │ │ ├── Std.Io.Impls.fsti │ │ │ │ ├── Std.Io.Stdio.fsti │ │ │ │ └── Std.Io.fsti │ │ │ ├── hax_lib/ │ │ │ │ └── Makefile │ │ │ └── rust_primitives/ │ │ │ ├── Makefile │ │ │ ├── Rust_primitives.Arithmetic.fsti │ │ │ ├── Rust_primitives.Arrays.fsti │ │ │ ├── Rust_primitives.BitVectors.fsti │ │ │ ├── Rust_primitives.Char.fsti │ │ │ ├── Rust_primitives.Float.fsti │ │ │ ├── Rust_primitives.Hax.Control_flow_monad.Mexception.fst │ │ │ ├── Rust_primitives.Hax.Control_flow_monad.Moption.fst │ │ │ ├── Rust_primitives.Hax.Control_flow_monad.Mresult.fst │ │ │ ├── Rust_primitives.Hax.Folds.fsti │ │ │ ├── Rust_primitives.Hax.Int.fst │ │ │ ├── Rust_primitives.Hax.Monomorphized_update_at.fsti │ │ │ ├── Rust_primitives.Hax.fst │ │ │ ├── Rust_primitives.Integers.fsti │ │ │ ├── Rust_primitives.Iterators.fsti │ │ │ ├── Rust_primitives.Mem.fsti │ │ │ ├── Rust_primitives.Notations.fsti │ │ │ ├── Rust_primitives.Sequence.fst │ │ │ ├── Rust_primitives.Slice.fsti │ │ │ ├── Rust_primitives.String.fsti │ │ │ └── Rust_primitives.fst │ │ ├── fstar-secret-integers/ │ │ │ ├── .envrc │ │ │ ├── Makefile.copy │ │ │ ├── README.md │ │ │ ├── core/ │ │ │ │ ├── Alloc.Alloc.fst │ │ │ │ ├── Alloc.Collections.Binary_heap.fsti │ │ │ │ ├── Alloc.Slice.fst │ │ │ │ ├── Alloc.Vec.fst │ │ │ │ ├── Core.Array.Iter.fsti │ │ │ │ ├── Core.Array.fst │ │ │ │ ├── Core.Clone.fst │ │ │ │ ├── Core.Cmp.fsti │ │ │ │ ├── Core.Convert.fst │ │ │ │ ├── Core.Iter.Adapters.Enumerate.fst │ │ │ │ ├── Core.Iter.Adapters.Step_by.fst │ │ │ │ ├── Core.Iter.Traits.Collect.fst │ │ │ │ ├── Core.Iter.Traits.Iterator.fst │ │ │ │ ├── Core.Iter.fsti │ │ │ │ ├── Core.Marker.fst │ │ │ │ ├── Core.Num.Error.fsti │ │ │ │ ├── Core.Num.fsti │ │ │ │ ├── Core.Ops.Arith.Neg.fsti │ │ │ │ ├── Core.Ops.Arith.fsti │ │ │ │ ├── Core.Ops.Control_flow.fst │ │ │ │ ├── Core.Ops.Deref.fst │ │ │ │ ├── Core.Ops.Index.IndexMut.fst │ │ │ │ ├── Core.Ops.Index.fst │ │ │ │ ├── Core.Ops.Range.fsti │ │ │ │ ├── Core.Ops.Try_trait.fst │ │ │ │ ├── Core.Ops.fst │ │ │ │ ├── Core.Option.fst │ │ │ │ ├── Core.Panicking.fst │ │ │ │ ├── Core.Result.fst │ │ │ │ ├── Core.Slice.Iter.fst │ │ │ │ ├── Core.Slice.fsti │ │ │ │ ├── Core.Str.Converts.fsti │ │ │ │ ├── Core.Str.Error.fsti │ │ │ │ ├── Core.Str.fsti │ │ │ │ ├── Core.fst │ │ │ │ ├── Makefile │ │ │ │ └── README.md │ │ │ ├── hax_lib/ │ │ │ │ └── Makefile │ │ │ └── rust_primitives/ │ │ │ ├── Makefile │ │ │ ├── Rust_primitives.Arrays.fst │ │ │ ├── Rust_primitives.Arrays.fsti │ │ │ ├── Rust_primitives.BitVectors.fst │ │ │ ├── Rust_primitives.BitVectors.fsti │ │ │ ├── Rust_primitives.Hax.Monomorphized_update_at.fst │ │ │ ├── Rust_primitives.Hax.Monomorphized_update_at.fsti │ │ │ ├── Rust_primitives.Hax.fst │ │ │ ├── Rust_primitives.Integers.fst │ │ │ ├── Rust_primitives.Integers.fsti │ │ │ ├── Rust_primitives.Iterators.fsti │ │ │ └── Rust_primitives.fst │ │ └── lean/ │ │ ├── Hax/ │ │ │ ├── MissingLean/ │ │ │ │ ├── Init/ │ │ │ │ │ ├── Data/ │ │ │ │ │ │ ├── Array/ │ │ │ │ │ │ │ └── Lemmas.lean │ │ │ │ │ │ ├── BitVec/ │ │ │ │ │ │ │ └── Basic.lean │ │ │ │ │ │ ├── Int/ │ │ │ │ │ │ │ └── DivMod/ │ │ │ │ │ │ │ └── Lemmas.lean │ │ │ │ │ │ ├── Nat/ │ │ │ │ │ │ │ ├── Div/ │ │ │ │ │ │ │ │ └── Basic.lean │ │ │ │ │ │ │ └── MinMax.lean │ │ │ │ │ │ ├── SInt/ │ │ │ │ │ │ │ ├── Basic.lean │ │ │ │ │ │ │ ├── Basic_Int128.lean │ │ │ │ │ │ │ ├── Lemmas.lean │ │ │ │ │ │ │ └── Lemmas_Int128.lean │ │ │ │ │ │ ├── UInt/ │ │ │ │ │ │ │ ├── Basic.lean │ │ │ │ │ │ │ ├── BasicAux.lean │ │ │ │ │ │ │ ├── Lemmas.lean │ │ │ │ │ │ │ └── Lemmas_UInt128.lean │ │ │ │ │ │ └── Vector/ │ │ │ │ │ │ └── Basic.lean │ │ │ │ │ ├── GrindInstances/ │ │ │ │ │ │ ├── Ring/ │ │ │ │ │ │ │ ├── SInt.lean │ │ │ │ │ │ │ └── UInt.lean │ │ │ │ │ │ └── ToInt.lean │ │ │ │ │ ├── Prelude.lean │ │ │ │ │ └── While.lean │ │ │ │ ├── Lean/ │ │ │ │ │ ├── Tactic/ │ │ │ │ │ │ └── Simp/ │ │ │ │ │ │ └── BuiltinSimpProcs/ │ │ │ │ │ │ ├── SInt.lean │ │ │ │ │ │ └── UInt.lean │ │ │ │ │ └── ToExpr.lean │ │ │ │ └── Std/ │ │ │ │ └── Do/ │ │ │ │ ├── PostCond.lean │ │ │ │ └── Triple/ │ │ │ │ ├── Basic.lean │ │ │ │ └── SpecLemmas.lean │ │ │ ├── MissingLean.lean │ │ │ ├── Tactic/ │ │ │ │ ├── HaxBVDecide.lean │ │ │ │ ├── HaxConstructPure.lean │ │ │ │ ├── HaxMvcgen.lean │ │ │ │ ├── HaxSpec.lean │ │ │ │ ├── HaxZify.lean │ │ │ │ ├── Init.lean │ │ │ │ └── SpecSet.lean │ │ │ ├── Tactic.lean │ │ │ ├── core_models/ │ │ │ │ ├── core_models.lean │ │ │ │ ├── epilogue/ │ │ │ │ │ ├── alloc.lean │ │ │ │ │ ├── convert.lean │ │ │ │ │ ├── float.lean │ │ │ │ │ ├── folds.lean │ │ │ │ │ ├── function.lean │ │ │ │ │ ├── num.lean │ │ │ │ │ ├── ops.lean │ │ │ │ │ ├── range.lean │ │ │ │ │ ├── result.lean │ │ │ │ │ ├── slice.lean │ │ │ │ │ └── string.lean │ │ │ │ ├── epilogue.lean │ │ │ │ ├── prologue/ │ │ │ │ │ ├── clone.lean │ │ │ │ │ ├── marker.lean │ │ │ │ │ └── num.lean │ │ │ │ └── prologue.lean │ │ │ ├── core_models.lean │ │ │ ├── rust_primitives/ │ │ │ │ ├── BVDecide.lean │ │ │ │ ├── Cast.lean │ │ │ │ ├── GetElemResult.lean │ │ │ │ ├── RustM.lean │ │ │ │ ├── Spec.lean │ │ │ │ ├── USize64.lean │ │ │ │ ├── arithmetic.lean │ │ │ │ ├── boxed.lean │ │ │ │ ├── hax/ │ │ │ │ │ ├── array.lean │ │ │ │ │ ├── int.lean │ │ │ │ │ ├── logical_op.lean │ │ │ │ │ ├── machine_int.lean │ │ │ │ │ ├── never.lean │ │ │ │ │ ├── tuple.lean │ │ │ │ │ └── while_loop.lean │ │ │ │ ├── hax.lean │ │ │ │ ├── hax_lib.lean │ │ │ │ ├── mem.lean │ │ │ │ ├── ops.lean │ │ │ │ ├── sequence.lean │ │ │ │ └── slice.lean │ │ │ └── rust_primitives.lean │ │ ├── Hax.lean │ │ ├── README.md │ │ ├── lake-manifest.json │ │ ├── lakefile.toml │ │ └── lean-toolchain │ ├── proofs/ │ │ └── fstar/ │ │ └── extraction/ │ │ ├── Hax_lib.Abstraction.fst │ │ ├── Hax_lib.Bundle.fst │ │ ├── Hax_lib.Int.Bigint.fst │ │ ├── Hax_lib.Int.fst │ │ ├── Hax_lib.Prop.Bundle.fst │ │ ├── Hax_lib.Prop.Constructors.fst │ │ ├── Hax_lib.Prop.fst │ │ ├── Hax_lib.fst │ │ └── Makefile │ └── src/ │ ├── abstraction.rs │ ├── dummy.rs │ ├── implementation.rs │ ├── int/ │ │ ├── bigint.rs │ │ └── mod.rs │ ├── lib.rs │ ├── proc_macros.rs │ └── prop.rs ├── hax-lib-protocol/ │ ├── Cargo.toml │ ├── README.md │ └── src/ │ ├── crypto.rs │ ├── lib.rs │ └── state_machine.rs ├── hax-lib-protocol-macros/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── hax-types/ │ ├── Cargo.toml │ ├── README.md │ ├── build.rs │ └── src/ │ ├── cli_options/ │ │ ├── extension.rs │ │ └── mod.rs │ ├── diagnostics/ │ │ ├── message.rs │ │ ├── mod.rs │ │ └── report.rs │ ├── driver_api.rs │ ├── engine_api.rs │ ├── lib.rs │ └── prelude.rs ├── justfile ├── mkdocs.yml ├── rust-engine/ │ ├── Cargo.toml │ ├── README.md │ ├── macros/ │ │ ├── Cargo.toml │ │ └── src/ │ │ ├── lib.rs │ │ ├── partial_application.rs │ │ ├── replace.rs │ │ └── struct_fields.rs │ └── src/ │ ├── ast/ │ │ ├── diagnostics.rs │ │ ├── fragment.rs │ │ ├── identifiers/ │ │ │ ├── global_id/ │ │ │ │ ├── compact_serialization.rs │ │ │ │ ├── generated.rs │ │ │ │ ├── generated_names.rs │ │ │ │ └── view.rs │ │ │ └── global_id.rs │ │ ├── identifiers.rs │ │ ├── literals.rs │ │ ├── resugared.rs │ │ ├── span.rs │ │ ├── utils.rs │ │ └── visitors.rs │ ├── ast.rs │ ├── attributes.rs │ ├── backends/ │ │ ├── fstar.rs │ │ ├── lean.rs │ │ ├── rust/ │ │ │ ├── renamings │ │ │ └── renamings.rs │ │ └── rust.rs │ ├── backends.rs │ ├── debugger.rs │ ├── hax_io.rs │ ├── import_thir.rs │ ├── interning.rs │ ├── lib.rs │ ├── main.rs │ ├── names.rs │ ├── ocaml_engine.rs │ ├── phase/ │ │ ├── explicit_monadic.rs │ │ ├── filter_unprintable_items.rs │ │ ├── legacy.rs │ │ └── reject_not_do_lean_dsl.rs │ ├── phase.rs │ ├── printer/ │ │ ├── pretty_ast/ │ │ │ ├── debug_json.rs │ │ │ └── to_document.rs │ │ ├── pretty_ast.rs │ │ └── render_view.rs │ ├── printer.rs │ ├── resugarings.rs │ └── symbol.rs ├── rust-toolchain.toml ├── rustc-coverage-tests/ │ ├── Cargo.toml │ ├── README.md │ ├── proofs/ │ │ ├── fstar/ │ │ │ └── extraction/ │ │ │ └── Makefile │ │ └── lean/ │ │ └── extraction/ │ │ └── lakefile.toml │ ├── requirements.txt │ ├── run-coverage-tests.py │ ├── snapshots/ │ │ └── fstar/ │ │ ├── Coverage.Abort.fst │ │ ├── Coverage.Assert.fst │ │ ├── Coverage.Assert_ne.fst │ │ ├── Coverage.Assert_not.fst │ │ ├── Coverage.Attr.Impl_.fst │ │ ├── Coverage.Attr.Module.Nested_a.Nested_b.fst │ │ ├── Coverage.Attr.Module.Off.fst │ │ ├── Coverage.Attr.Module.On.fst │ │ ├── Coverage.Attr.Module.fst │ │ ├── Coverage.Attr.Off_on_sandwich.fst │ │ ├── Coverage.Attr.Trait_impl_inherit.fst │ │ ├── Coverage.Auxiliary.Discard_all_helper.fst │ │ ├── Coverage.Auxiliary.Used_crate.fst │ │ ├── Coverage.Auxiliary.Used_inline_crate.fst │ │ ├── Coverage.Closure_macro.fst │ │ ├── Coverage.Closure_unit_return.fst │ │ ├── Coverage.Color.fst │ │ ├── Coverage.Condition.Conditions.fst │ │ ├── Coverage.Conditions.fst │ │ ├── Coverage.Continue_.fst │ │ ├── Coverage.Dead_code.fst │ │ ├── Coverage.Drop_trait.fst │ │ ├── Coverage.Fn_sig_into_try.fst │ │ ├── Coverage.Generics.fst │ │ ├── Coverage.If_.fst │ │ ├── Coverage.If_else.fst │ │ ├── Coverage.If_not.fst │ │ ├── Coverage.Ignore_map.fst │ │ ├── Coverage.Ignore_run.fst │ │ ├── Coverage.Inline.fst │ │ ├── Coverage.Inline_dead.fst │ │ ├── Coverage.Inner_items.fst │ │ ├── Coverage.Issue_83601_.fst │ │ ├── Coverage.Lazy_boolean.fst │ │ ├── Coverage.Let_else_loop.fst │ │ ├── Coverage.Long_and_wide.fst │ │ ├── Coverage.Loop_break.fst │ │ ├── Coverage.Loop_break_value.fst │ │ ├── Coverage.Loops_branches.fst │ │ ├── Coverage.Macro_in_closure.fst │ │ ├── Coverage.Match_or_pattern.fst │ │ ├── Coverage.Mcdc.Condition_limit.fst │ │ ├── Coverage.Mcdc.If_.fst │ │ ├── Coverage.Mcdc.Inlined_expressions.fst │ │ ├── Coverage.Mcdc.Nested_if.fst │ │ ├── Coverage.Mcdc.Non_control_flow.fst │ │ ├── Coverage.Nested_loops.fst │ │ ├── Coverage.No_cov_crate.Nested_fns.fst │ │ ├── Coverage.No_cov_crate.fst │ │ ├── Coverage.No_spans.fst │ │ ├── Coverage.No_spans_if_not.fst │ │ ├── Coverage.Overflow.fst │ │ ├── Coverage.Panic_unwind.fst │ │ ├── Coverage.Partial_eq.fst │ │ ├── Coverage.Simple_loop.fst │ │ ├── Coverage.Simple_match.fst │ │ ├── Coverage.Sort_groups.fst │ │ ├── Coverage.Test_harness.fst │ │ ├── Coverage.Tight_inf_loop.fst │ │ ├── Coverage.Trivial.fst │ │ ├── Coverage.Try_error_result.fst │ │ ├── Coverage.Unicode.fst │ │ ├── Coverage.Unused.fst │ │ ├── Coverage.Unused_mod.Unused_module.fst │ │ ├── Coverage.Unused_mod.fst │ │ ├── Coverage.While_.fst │ │ └── Coverage.While_early_ret.fst │ ├── src/ │ │ ├── abort.rs │ │ ├── assert-ne.rs │ │ ├── assert.rs │ │ ├── assert_not.rs │ │ ├── async.rs │ │ ├── async2.rs │ │ ├── async_block.rs │ │ ├── async_closure.rs │ │ ├── attr/ │ │ │ ├── impl.rs │ │ │ ├── mod.rs │ │ │ ├── module.rs │ │ │ ├── nested.rs │ │ │ ├── off-on-sandwich.rs │ │ │ └── trait-impl-inherit.rs │ │ ├── auxiliary/ │ │ │ ├── discard_all_helper.rs │ │ │ ├── executor.rs │ │ │ ├── inline_always_with_dead_code.rs │ │ │ ├── inline_mixed_helper.rs │ │ │ ├── macro_name_span_helper.rs │ │ │ ├── mod.rs │ │ │ ├── unused_mod_helper.rs │ │ │ ├── used_crate.rs │ │ │ └── used_inline_crate.rs │ │ ├── await_ready.rs │ │ ├── bad_counter_ids.rs │ │ ├── bench.rs │ │ ├── branch/ │ │ │ ├── generics.rs │ │ │ ├── guard.rs │ │ │ ├── if-let.rs │ │ │ ├── if.rs │ │ │ ├── lazy-boolean.rs │ │ │ ├── let-else.rs │ │ │ ├── match-arms.rs │ │ │ ├── match-trivial.rs │ │ │ ├── mod.rs │ │ │ ├── no-mir-spans.rs │ │ │ └── while.rs │ │ ├── closure.rs │ │ ├── closure_bug.rs │ │ ├── closure_macro.rs │ │ ├── closure_macro_async.rs │ │ ├── closure_unit_return.rs │ │ ├── color.rs │ │ ├── condition/ │ │ │ ├── conditions.rs │ │ │ └── mod.rs │ │ ├── conditions.rs │ │ ├── continue.rs │ │ ├── coroutine.rs │ │ ├── coverage_attr_closure.rs │ │ ├── dead_code.rs │ │ ├── discard-all-issue-133606.rs │ │ ├── drop_trait.rs │ │ ├── fn_sig_into_try.rs │ │ ├── generic-unused-impl.rs │ │ ├── generics.rs │ │ ├── holes.rs │ │ ├── if.rs │ │ ├── if_else.rs │ │ ├── if_not.rs │ │ ├── ignore_map.rs │ │ ├── ignore_run.rs │ │ ├── inline-dead.rs │ │ ├── inline.rs │ │ ├── inline_mixed.rs │ │ ├── inner_items.rs │ │ ├── issue-83601.rs │ │ ├── issue-84561.rs │ │ ├── issue-85461.rs │ │ ├── issue-93054.rs │ │ ├── lazy_boolean.rs │ │ ├── let_else_loop.rs │ │ ├── lib.rs │ │ ├── long_and_wide.rs │ │ ├── loop-break.rs │ │ ├── loop_break_value.rs │ │ ├── loops_branches.rs │ │ ├── macro_in_closure.rs │ │ ├── macro_name_span.rs │ │ ├── match_or_pattern.rs │ │ ├── mcdc/ │ │ │ ├── condition-limit.rs │ │ │ ├── if.rs │ │ │ ├── inlined_expressions.rs │ │ │ ├── mod.rs │ │ │ ├── nested_if.rs │ │ │ └── non_control_flow.rs │ │ ├── nested_loops.rs │ │ ├── no-core.rs │ │ ├── no_cov_crate.rs │ │ ├── no_spans.rs │ │ ├── no_spans_if_not.rs │ │ ├── overflow.rs │ │ ├── panic_unwind.rs │ │ ├── partial_eq.rs │ │ ├── simple_loop.rs │ │ ├── simple_match.rs │ │ ├── sort_groups.rs │ │ ├── test_harness.rs │ │ ├── tight_inf_loop.rs │ │ ├── trivial.rs │ │ ├── try_error_result.rs │ │ ├── unicode.rs │ │ ├── unreachable.rs │ │ ├── unused.rs │ │ ├── unused_mod.rs │ │ ├── uses_crate.rs │ │ ├── uses_inline_crate.rs │ │ ├── while.rs │ │ ├── while_early_ret.rs │ │ └── yield.rs │ ├── test_config.yaml │ └── update-test-sources.sh ├── rustfmt.toml ├── setup.sh ├── test-harness/ │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ └── src/ │ ├── command_hax_ext.rs │ ├── harness.rs │ ├── lib.rs │ └── snapshots/ │ ├── toolchain__assert into-coq.snap │ ├── toolchain__assert into-fstar.snap │ ├── toolchain__assert into-ssprove.snap │ ├── toolchain__attribute-opaque into-fstar.snap │ ├── toolchain__attributes into-fstar.snap │ ├── toolchain__constructor-as-closure into-fstar.snap │ ├── toolchain__cyclic-modules into-fstar.snap │ ├── toolchain__cyclic-modules into-lean.snap │ ├── toolchain__dyn into-fstar.snap │ ├── toolchain__enum-repr into-coq.snap │ ├── toolchain__enum-repr into-fstar.snap │ ├── toolchain__enum-repr into-ssprove.snap │ ├── toolchain__functions into-coq.snap │ ├── toolchain__functions into-fstar.snap │ ├── toolchain__generics into-fstar.snap │ ├── toolchain__guards into-coq.snap │ ├── toolchain__guards into-fstar.snap │ ├── toolchain__guards into-ssprove.snap │ ├── toolchain__include-flag into-coq.snap │ ├── toolchain__include-flag into-fstar.snap │ ├── toolchain__interface-only into-fstar.snap │ ├── toolchain__lean-core-models into-lean.snap │ ├── toolchain__lean-tests into-lean.snap │ ├── toolchain__let-else into-coq.snap │ ├── toolchain__let-else into-fstar.snap │ ├── toolchain__let-else into-ssprove.snap │ ├── toolchain__literals into-coq.snap │ ├── toolchain__literals into-fstar.snap │ ├── toolchain__literals into-lean.snap │ ├── toolchain__loops into-fstar.snap │ ├── toolchain__mut-ref-functionalization into-fstar.snap │ ├── toolchain__naming into-coq.snap │ ├── toolchain__naming into-fstar.snap │ ├── toolchain__pattern-or into-coq.snap │ ├── toolchain__pattern-or into-fstar.snap │ ├── toolchain__patterns into-fstar.snap │ ├── toolchain__recursion into-fstar.snap │ ├── toolchain__reordering into-coq.snap │ ├── toolchain__reordering into-fstar.snap │ ├── toolchain__reordering into-ssprove.snap │ ├── toolchain__side-effects into-fstar.snap │ ├── toolchain__side-effects into-ssprove.snap │ ├── toolchain__slices into-coq.snap │ ├── toolchain__slices into-fstar.snap │ ├── toolchain__statics into-fstar.snap │ ├── toolchain__traits into-fstar.snap │ └── toolchain__unsafe into-fstar.snap └── tests/ ├── .gitignore ├── Cargo.toml ├── README.md ├── assert/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── attribute-opaque/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── attributes/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── cli/ │ ├── include-flag/ │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ └── interface-only/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── constructor-as-closure/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── cyclic-modules/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── dyn/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── enum-repr/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── enum-struct-variant/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── even/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── functions/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── generics/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── guards/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── if-let/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── lean-core-models/ │ ├── Cargo.toml │ └── src/ │ ├── default.rs │ ├── function.rs │ ├── lib.rs │ ├── option.rs │ ├── phantom.rs │ └── result.rs ├── lean-tests/ │ ├── Cargo.toml │ └── src/ │ ├── array.rs │ ├── associated_types.rs │ ├── binops.rs │ ├── casts.rs │ ├── comments.rs │ ├── constants.rs │ ├── enums.rs │ ├── floats.rs │ ├── ite.rs │ ├── lib.rs │ ├── loops.rs │ ├── matching.rs │ ├── monadic.rs │ ├── nested_control_flow.rs │ ├── opaque.rs │ ├── recursion.rs │ ├── specs.rs │ ├── structs.rs │ ├── traits.rs │ └── types.rs ├── let-else/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── literals/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── loops/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── mut-ref-functionalization/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── naming/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── nested-derefs/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── never-type/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── odd/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── pattern-or/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── patterns/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── proverif-basic-structs/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── proverif-fn-to-letfun/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── proverif-minimal/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── proverif-noise/ │ ├── Cargo.toml │ └── src/ │ ├── lib.rs │ ├── noise_crypto.rs │ ├── noise_kkpsk0.rs │ └── noise_lib.rs ├── proverif-ping-pong/ │ ├── Cargo.toml │ ├── pingpong.pv │ └── src/ │ ├── a.rs │ ├── b.rs │ └── lib.rs ├── raw-attributes/ │ ├── Cargo.toml │ ├── README.md │ └── src/ │ └── lib.rs ├── recursion/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── reordering/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── side-effects/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── slices/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── statics/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── traits/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs ├── tuples/ │ ├── Cargo.toml │ └── src/ │ └── lib.rs └── unsafe/ ├── Cargo.toml └── src/ └── lib.rs